diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..de1ffff --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +__pycache__/* +*.aux +*.nav +*.snm +*.toc +*.blg +*.bbl +*.gif + +*.out +*.log +*.sync* + +*/*.aux +*/*.nav +*/*.snm +*/*.toc +*/*.blg +*/*.bbl +*/*.gif + +*/*.out +*/*.log +*/*.sync* + +*/*/*.aux +*/*/*.nav +*/*/*.snm +*/*/*.toc +*/*/*.blg +*/*/*.bbl +*/*/*.gif + +*/*/*.out +*/*/*.log +*/*/*.sync* + + +*.pyc +tex/PGM.pdf +tex/PGM.pdf +tex/PGM.pdf diff --git a/DoubleOracle/DO.py b/DoubleOracle/DO.py new file mode 100644 index 0000000..edc3f7e --- /dev/null +++ b/DoubleOracle/DO.py @@ -0,0 +1,162 @@ + +import numpy as np +from stable_baselines3 import SAC, PPO +import time +from src.environments import ConPricingGame +import src.globals as gl +import src.classes as cl +import os + + +def initial_matrix(env_class, random=False): + if not random: + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + # strt4 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.spe, name="spe") + init_low = [strt1, strt2, strt3] + init_high = [strt1, strt2, strt3] + else: + model_name = f"rndstart_{job_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + model_dir = f"{gl.MODELS_DIR}/{model_name}" + if not os.path.exists(f"{model_dir}.zip"): + train_env = env_class(tuple_costs=None, adversary_mixed_strategy=None, memory=12) + model = SAC('MlpPolicy', train_env, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + model.save(model_dir) + + strt_rnd = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name=model_name, action_step=None, memory=12) + + init_low = [strt_rnd] + init_high = [strt_rnd] + + low_strts, high_strts = db.get_list_of_added_strategies() + return cl.BimatrixGame( + low_cost_strategies=init_low+low_strts, high_cost_strategies=init_high+high_strts, env_class=env_class) + + +if __name__ == "__main__": + + gl.initialize() + + env_class = ConPricingGame + + num_rounds = 3 + num_procs = 1 + start_random = True + job_name = "test" + + db_name = job_name+".db" + db = cl.DataBase(db_name) + cl.set_job_name(job_name) + cl.create_directories() + equilibria = [] + + # params + lrs = [0.0003, 0.00016] + memories = [12, 18] + algs = [SAC] + + start_game = initial_matrix(env_class=env_class, random=start_random) + + bimatrix_game = cl.load_latest_game(game_data_name=f"game_{job_name}", new_game=start_game) + + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + + all_equilibria = bimatrix_game.compute_equilibria() + equilibria = all_equilibria[:min(len(all_equilibria), gl.NUM_TRACE_EQUILIBRIA)] + game_size = bimatrix_game.size() + + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + + added_low = 0 + added_high = 0 + # for equilibrium in dictionaries: + for equi in equilibria: + new_equi_low = 0 + new_equi_high = 0 + + # low_prob_str = ", ".join( + # map("{0:.2f}".format, equi["low_cost_probs"])) + # high_prob_str = ", ".join( + # map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: {str(equi.row_support)}, {str(equi.col_support)}\n payoffs= {equi.row_payoff:.2f}, {equi.col_payoff:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi.col_probs+([0]*added_high)) if + added_high > 0 else equi.col_probs)) + + for alg in algs: + for lr in lrs: + for mem_i, memory in enumerate(memories): + + print(f'training low-cost agents with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + results = cl.train_processes(db=db, env_class=env_class, costs=[gl.LOW_COST, gl.HIGH_COST], + adv_mixed_strategy=high_mixed_strat, target_payoff=equi.row_payoff, + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff, base_agent_name = result + if acceptable: + new_equi_low += 1 + added_low += 1 + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi.row_probs+([0]*added_low)) if added_low > 0 else equi.row_probs)) + + for alg in algs: + for lr in lrs: + for memory in memories: + print(f'training high-cost player with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + results = cl.train_processes(db=db, env_class=env_class, costs=[gl.HIGH_COST, gl.LOW_COST], + adv_mixed_strategy=low_mixed_strat, target_payoff=equi.col_payoff, + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff, base_agent_name = result + if acceptable: + new_equi_high += 1 + added_high += 1 + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name}, alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + # because high_mixed_strt is defined before the changes to bimatrix.high_strategies. (error in str(high_mixed)) + if new_equi_high > 0: + high_mixed_strat.strategy_probs += [0]*new_equi_high + + # if new_equi_low>0 or new_equi_high>0: + # equilibria.append( + # [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + # to do: add the equilibria to the db + db.insert_new_equi(game_size=game_size, low_strategy_txt=str(low_mixed_strat), high_strategy_txt=str( + high_mixed_strat), low_payoff=equi.row_payoff, high_payoff=equi.col_payoff, low_new_num=new_equi_low, high_new_num=new_equi_high) + + if added_low == 0 and added_high == 0: + gl.N_EPISODES_BASE *= 1.1 + gl.N_EPISODES_LOAD *= 1.1 + else: + all_equilibria = bimatrix_game.compute_equilibria() + equilibria = all_equilibria[:min(len(all_equilibria), gl.NUM_TRACE_EQUILIBRIA)] + game_size = bimatrix_game.size() + + all_equilibria = bimatrix_game.compute_equilibria() + equilibria = all_equilibria[:min(len(all_equilibria), gl.NUM_TRACE_EQUILIBRIA)] diff --git a/DoubleOracle/NOV24.db b/DoubleOracle/NOV24.db new file mode 100644 index 0000000..735bfba Binary files /dev/null and b/DoubleOracle/NOV24.db differ diff --git a/DoubleOracle/game_NOV24.pickle b/DoubleOracle/game_NOV24.pickle new file mode 100644 index 0000000..b71df14 Binary files /dev/null and b/DoubleOracle/game_NOV24.pickle differ diff --git a/DoubleOracle/src/bimatrix.py b/DoubleOracle/src/bimatrix.py new file mode 100644 index 0000000..d601dcd --- /dev/null +++ b/DoubleOracle/src/bimatrix.py @@ -0,0 +1,400 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils as utils +import src.columnprint as columnprint +import src.lemke as lemke +import src.randomstart as randomstart +import random # random.seed +# import src.classes as cl + +class Equi(): + def __init__(self,row_probs,col_probs,row_payoff,col_payoff,row_support,col_support, found=1): + self.row_probs=row_probs + self.col_probs=col_probs + self.row_payoff=row_payoff + self.col_payoff=col_payoff + self.row_support=row_support + self.col_support=col_support + self.found=found + def __str__(self) -> str: + row_sup= [f"{i}: {self.row_probs[i]:.3f}" for i in self.row_support] + col_sup= [f"{i}: {self.col_probs[i]:.3f}" for i in self.col_support] + return f"[{', '.join(row_sup)}]x[{', '.join(col_sup)}]\nfound: {self.found}, payoff=({self.row_payoff:.2f},{self.col_payoff:.2f})" + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + + + equilibria = [] + + for i in range(len(sorted_trset)): + if sorted_trset[i][1] > 0: + equilibria.append(self.set_equi(sorted_trset[i])) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + def set_equi(self,dict_item)-> Equi: + found=dict_item[1] + eq=dict_item[0] + m = self.A.numrows + n = self.A.numcolumns + row_probs=[float(i) for i in eq[0:m]] + col_probs=[float(i) for i in eq[m:m+n]] + row_support,col_support = supports(eq,m,n) + row_payoff = np.matmul(row_probs, np.matmul( + self.A.matrix, np.transpose(col_probs))) + col_payoff = np.matmul(row_probs, np.matmul( + self.B.matrix, np.transpose(col_probs))) + return Equi(row_probs,col_probs,row_payoff,col_payoff,row_support,col_support,found) + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/DoubleOracle/src/classes.py b/DoubleOracle/src/classes.py new file mode 100644 index 0000000..dab63e9 --- /dev/null +++ b/DoubleOracle/src/classes.py @@ -0,0 +1,938 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +# from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix as bimatrix +import time +import os +import sqlite3 as sql +from collections import namedtuple +from stable_baselines3 import SAC, PPO +import copy +import pickle +import src.environments as envs +import multiprocessing as mp +import pandas as pd + + +class Iter_row: + def __init__(self, adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands): + self.adv = adv + self.agent_return = agent_return + self.adv_return = adv_return + self.rewards = rewards + self.adv_rewards = adv_rewards + self.actions = actions + self.prices = prices + self.adv_prices = adv_prices + self.demands = demands + self.adv_demands = adv_demands + +class BaseDataBase(): + def __init__(self, name="data.db") -> None: + self.db_name = name + self.reset() + + def reset(self) -> None: + pass + def execute_insert_query(self, query): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute(query) + connection.commit() + last_id = cursor.lastrowid + connection.close() + return last_id + + def execute_select_query(self, query, fetch_one=False): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute(query) + if fetch_one: + result = cursor.fetchone() + else: + result = cursor.fetchall() + return result + + def dataframe_select(self,query): + connection = sql.connect(self.db_name, timeout=10) + df = pd.read_sql_query(query, connection) + connection.close() + return df + +class DataBase(BaseDataBase): + + AgentRow = namedtuple( + "AgentRow", "name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, alg, lr, memory, added, action_step, seed, num_process, running_time") + + AGENTS_TABLE = "trained_agents" + ITERS_TABLE = "agents_iters" + EQUI_TABLE = "game_equilibria" + AGENTS_COLS = "id integer PRIMARY key AUTOINCREMENT,name text NOT NULL,base_agent text DEFAULT NULL,n_ep integer NOT NULL,cost integer NOT NULL,mixed_adv text NOT NULL,expected_payoff real,payoff_treshhold real,alg text NOT NULL,lr real NOT NULL,memory integer NOT NULL, action_step integer DEFAULT NULL,seed integer,num_procs integer DEFAULT 1,running_time integer, added integer,time text" + ITERS_COLS = "id integer PRIMARY key AUTOINCREMENT,agent_id integer NOT NULL,adv text NOT NULL,agent_return text,adv_return text,agent_rewards text,adv_rewards text,actions text,agent_prices text,adv_prices text, agent_demands text,adv_demands text" + EQUI_COLS = "id integer PRIMARY key AUTOINCREMENT,game_size text NOT NULL,low_strategy text NOT NULL,high_strategy NOT NULL,low_payoff real NOT NULL,high_payoff real NOT NULL, num_new_low real DEFAULT 0, num_new_high real DEFAULT 0,time text" + + + + def reset(self): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.AGENTS_TABLE}({self.AGENTS_COLS});') + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.ITERS_TABLE}({self.ITERS_COLS});') + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.EQUI_TABLE}({self.EQUI_COLS});') + connection.close() + + # def insert_new_agent(self, name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, lr, memory, added, action_step=None, seed=0, num_process=1, running_time=0): + + + def insert_new_agent(self, row): + """ + adds a new agent to db and returns the id + row: AgentRow named tuple + """ + query = f'INSERT INTO {self.AGENTS_TABLE} VALUES (NULL,\'{row.name}\',' + ('NULL' if (row.base_agent is None) else f'\'{row.base_agent}\'') + \ + f',{row.num_ep},{row.cost},\'{row.mixed_adv_txt}\',{row.expected_payoff},{row.payoff_treshhold},\"{row.alg}\",{row.lr},{row.memory},{("NULL" if row.action_step is None else row.action_step)},{row.seed},{row.num_process},{row.running_time},{int(row.added)},\'{ time.ctime(time.time())}\')' + # print(query) + return self.execute_insert_query(query=query) + + def insert_new_iteration(self, agent_id, adv_txt, agent_return, adv_return, agent_rewards_txt, adv_rewards_txt, actions_txt, agent_prices_txt, adv_prices_txt, + agent_demands_txt, adv_demands_txt): + """ + adds a new iteration to db and returns the id + """ + query = f'INSERT INTO {self.ITERS_TABLE} VALUES (NULL,{agent_id},\'{adv_txt}\',{agent_return},{adv_return},\'{agent_rewards_txt}\',\'{adv_rewards_txt}\',\ + \'{actions_txt}\',\'{agent_prices_txt}\',\'{adv_prices_txt}\',\'{agent_demands_txt}\',\'{adv_demands_txt}\')' + # print(query) + return self.execute_insert_query(query=query) + + def insert_new_equi(self, game_size, low_strategy_txt, high_strategy_txt, low_payoff, high_payoff, low_new_num, high_new_num): + """ + adds a new equilibrium to db and returns the id + """ + EQUI_COLS = "id integer PRIMARY key AUTOINCREMENT,game_size text NOT NULL,low_strategy text NOT NULL,high_strategy NOT NULL,low_payoff real NOT NULL,high_payoff real NOT NULL,low_new real DEFAULT 0,high_new real DEFAULT 0,time text" + query = f'INSERT INTO {self.EQUI_TABLE} VALUES (NULL,\'{str(game_size)}\',\'{low_strategy_txt}\',\'{high_strategy_txt}\',{low_payoff},{high_payoff},{low_new_num},{high_new_num}, \'{ time.ctime(time.time())}\')' + # print(query) + return self.execute_insert_query(query=query) + + def get_list_of_added_strategies(self): + """ returns two lists of low_cost and high_cost strategies """ + low_q = f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.LOW_COST})" + high_q = f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.HIGH_COST})" + low_lst = [] + high_lst = [] + + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + + cursor.execute(low_q) + low_all = cursor.fetchall() + for tup in low_all: + if tup[1] == str(SAC): + model = SAC + elif tup[1] == str(PPO): + model = PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [], [] + + low_lst.append(Strategy(strategy_type=StrategyType.sb3_model, model_or_func=model, + name=tup[0], memory=tup[2], action_step=tup[3])) + + cursor.execute(high_q) + high_all = cursor.fetchall() + for tup in high_all: + if tup[1] == str(SAC): + model = SAC + elif tup[1] == str(PPO): + model = PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [], [] + + high_lst.append(Strategy(strategy_type=StrategyType.sb3_model, model_or_func=model, + name=tup[0], memory=tup[2], action_step=tup[3])) + connection.close() + return low_lst, high_lst + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def size(self): + return (len(self.low_strategies), len(self.high_strategies)) + + def get_subgame(self, num_row, num_col): + sub_game=BimatrixGame(low_cost_strategies=self.low_strategies[:num_row],\ + high_cost_strategies=self.high_strategies[:num_col], \ + env_class=self.env_class) + sub_game.matrix_A=self.matrix_A[:num_row,:num_col] + sub_game.matrix_B=self.matrix_B[:num_row,:num_col] + return sub_game + + def to_dict(self): + return { + 'low_strategies': [strt.to_dict() for strt in self.low_strategies], + 'high_strategies': [strt.to_dict() for strt in self.high_strategies], + 'env_class': self.env_class.__name__, + 'matrix_A': self.matrix_A, + 'matrix_B': self.matrix_B + } + + @classmethod + def from_dict(cls, data_dict): + + env_class = str_to_envclass(data_dict['env_class']) + low_strategies = [Strategy.from_dict(strt_data) for strt_data in data_dict['low_strategies']] + high_strategies = [Strategy.from_dict(strt_data) for strt_data in data_dict['high_strategies']] + + obj = cls(low_cost_strategies=low_strategies, high_cost_strategies=high_strategies, env_class=env_class) + obj.matrix_A = data_dict['matrix_A'] + obj.matrix_B = data_dict['matrix_B'] + return obj + + def save_game(self, file_name): + with open(f"{file_name}.pickle", "wb") as file: + pickle.dump(self.to_dict(), file) + + def load_game(file_name): + name = f"{file_name}.pickle" + if os.path.exists(name): + with open(name, "rb") as file: + instance_data = pickle.load(file) + return BimatrixGame.from_dict(instance_data) + else: + return None + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + strt_L = self.low_strategies[low_index] + strt_H = self.high_strategies[high_index] + strt_L.reset() + strt_H.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=strt_H.to_mixed_strategy(), memory=strt_L.memory) + payoffs = [strt_L.play_against(env, strt_H) + for _ in range(gl.NUM_MATRIX_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + game_name = f"game_{job_name}" + + self.save_game(game_name) + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"{game_name}.txt", "w") as out: + out.write(output) + output += "\nlow-cost strategies: \n" + for strt in self.low_strategies: + output += f" {strt.name} " + + output += "\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output += f" {strt.name} " + + with open(f"games/game_{job_name}_{int(time.time())}.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self,num_trace=100,write_matrix=True, prt_progress=True): + """ returns a list of Equi, all the equilibria found for the bimatrix game""" + if write_matrix: + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_all = game.tracing(num_trace) + if prt_progress: + prt(f"\n all equilibria: {len(equilibria_all)} \n") + for i in range(len(equilibria_all)): + prt(f"{i} - {equilibria_all[i]}") + + return equilibria_all + + # return equilibria_all[0:(min(gl.NUM_TRACE_EQUILIBRIA, len(equilibria_all)))] + # for equilibrium in equilibria_traces: + # low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + # equilibrium) + # low_cost_probabilities = return_distribution( + # len(self.low_strategies), low_cost_probs, low_cost_support) + # high_cost_probabilities = return_distribution( + # len(self.high_strategies), high_cost_probs, high_cost_support) + # low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + # self.matrix_A, np.transpose(high_cost_probabilities))) + # high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + # self.matrix_B, np.transpose(high_cost_probabilities))) + + # result = {"low_cost_probs": low_cost_probabilities, + # "high_cost_probs": high_cost_probabilities, + # "low_cost_payoff": low_cost_payoff, + # "high_cost_payoff": high_cost_payoff, + # "low_cost_support": low_cost_support, + # "high_cost_support": high_cost_support + # } + # equilibria.append(result) + return equilibria + + + +class Strategy(): + """ + strategies can be static or they can be models trained with sb3. + """ + type = None + env = None + name = None + memory = None + policy = None + model = None + first_price = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, memory=0, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.memory = memory + + self.action_step = action_step + + if strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def __str__(self) -> str: + return f"{self.name}:{self.memory},{self.action_step}" + + def reset(self): + pass + + def to_dict(self): + return { + 'type': self.type, + 'name': self.name, + 'model_or_func': (self.model if self.type == StrategyType.sb3_model else self.policy), + 'first_price': self.first_price, + 'memory': self.memory, + 'action_step': self.action_step + } + + @classmethod + def from_dict(cls, data_dict): + return cls(strategy_type=data_dict['type'], model_or_func=data_dict['model_or_func'], name=data_dict['name'], first_price=data_dict['first_price'], memory=data_dict['memory'], action_step=data_dict['action_step']) + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.sb3_model: + if self.policy is None: + if env.memory != self.memory: + env_new = (env.__class__)(tuple_costs=env.costs, + adversary_mixed_strategy=env.adversary_mixed_strategy, memory=self.memory) + # env_new shouldn't it be multi level? + self.policy = (self.model.load(self.dir, env=env_new)).predict + else: + self.policy = (self.model.load(self.dir, env=env)).predict + state = env.get_state( + stage=env.stage, player=player, memory=self.memory) + action, _ = self.policy(state) + # compute price for co model and disc model + price = (env.myopic(player)-action[0]) if (self.action_step is None) else ( + env.myopic(player)-(self.action_step*action)) + + if player == 0: + env.actions[env.stage] = (action[0] if ( + self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy = adversary.to_mixed_strategy() + + state, _ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size = support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + if len(self.strategies) != len(self.strategy_probs): + print(len(self.strategies)) + print(self.strategy_probs) + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + def reduce(self): + """ only keeps the strategies with positive probablity, returns a new mixed strategy""" + strts = [] + probs = [] + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + strts.append(self.strategies[i]) + probs.append(self.strategy_probs[i]) + return MixedStrategy(strategies_lst=strts, probablities_lst=probs) + + def copy_unload(self): + """a copy of strategies with models not loaded, returns a mixed strategy """ + strts = [] + probs = [] + for i in range(len(self.strategies)): + strt = copy.deepcopy(self.strategies[i]) + if self.strategies[i].type == StrategyType.sb3_model: + strt.policy = None + strts.append(strt) + probs.append(self.strategy_probs[i]) + + return MixedStrategy(strategies_lst=strts, probablities_lst=probs) + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def spe(env, player, firstprice=0): + """ + returns the subgame perfect equilibrium price + """ + t = env.stage + P = gl.SPE_a[t]*(env.demand_potential[player][t]-200) + gl.SPE_b[t] + gl.SPE_k[t]*(env.costs[player]-64) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt', 'a') as file: + file.write("\n"+string) + + +# def write_to_excel(file_name, new_row): +# """ +# row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time +# """ + +# path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + +# wb = load_workbook(path) +# sheet = wb.active +# row = 2 +# col = 1 +# sheet.insert_rows(idx=row) + +# for i in range(len(new_row)): +# sheet.cell(row=row, column=col+i).value = new_row[i] +# wb.save(path) + + +# def write_results(new_row): +# write_to_excel(f'results_{job_name}.xlsx', new_row) + + +# def write_agents(new_row): +# # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ +# # gamma seed num_procs running_time date + +# write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + + +# def recover_probs(test): +# low_cost_probs, high_cost_probs, rest = test.split(")") +# low_cost_probs = low_cost_probs.split("(")[1] +# _, high_cost_probs = high_cost_probs.split("(") +# high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] +# low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] +# _, low_cost_support, high_cost_support = rest.split('[') +# high_cost_support, _ = high_cost_support.split(']') +# high_cost_support = [int(s) for s in high_cost_support.split(',')] +# low_cost_support, _ = low_cost_support.split(']') +# low_cost_support = [int(s) for s in low_cost_support.split(',')] +# return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +# def return_distribution(number_players, cost_probs, cost_support): +# player_probabilities = [0] * number_players +# for index, support in enumerate(cost_support): +# player_probabilities[support] = cost_probs[support] +# return player_probabilities + + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.GAMES_DIR): + os.makedirs(gl.GAMES_DIR) + + +def set_job_name(name): + global job_name + job_name = name + + +def find_base_agents(db, alg, memory, cost, mix_strt, size): + """ the startegies should be the same class of agents as we are training. if low cost then low-cost strategies should be given to find similar ones. The trained agents that are not even added will be considered """ + strats = copy.deepcopy(mix_strt.strategies) + probs = copy.deepcopy(mix_strt.strategy_probs) + cands = [None] + cand_w = [1.00] + for i in range(len(probs)-1): + for j in range(i+1, len(probs)): + if probs[i] < probs[j]: + strats[i], strats[j] = strats[j], strats[i] + probs[i], probs[j] = probs[j], probs[i] + for st in strats: + if st.type == StrategyType.sb3_model and memory == st.memory and (alg is st.model): + cands.append(st.name) + cand_w.append(2.00) + + query = f'SELECT name FROM {DataBase.AGENTS_TABLE} WHERE cost={cost} and memory={memory} and alg=\"{str(alg)}\" and added=1 ORDER BY id DESC LIMIT {(size-len(cands))}' + + tmps = db.execute_select_query(query=query) + if tmps is not None: + for tmp in tmps: + cands.append(tmp[0]) + cand_w.append(1.00) + cand_w = np.array(cand_w) + cand_w /= sum(cand_w) + agents = np.random.choice(np.array(cands), size, replace=True, p=cand_w) + return agents + + +def read_matrices_from_file(file_name): + lines = [*open(file=file_name)] + size = tuple(int(num) for num in lines[0].split()) + matrix_A = np.zeros(size) + matrix_B = np.zeros(size) + + for i in range(2, 2+size[0]): + matrix_A[i-2] = [float(num) for num in lines[i].split()] + for i in range(3+size[0], 3+2*size[0]): + matrix_B[i-3-size[0]] = [float(num) for num in lines[i].split()] + + return matrix_A, matrix_B + + +def load_latest_game(game_data_name, new_game): + """ loads the game from game_data file and adds the extra strategies from new_game that were not saved in the data file and should be in the game""" + + old_game = BimatrixGame.load_game(game_data_name) + if old_game is None: # no data to load + new_game.reset_matrix() + new_game.fill_matrix() + return new_game + else: + new_lows = new_game.low_strategies + new_highs = new_game.high_strategies + + low_trained_i = 0 + while low_trained_i < len(old_game.low_strategies) and old_game.low_strategies[low_trained_i].type != StrategyType.sb3_model: + low_trained_i += 1 + + low_new_trained_i = 0 + while low_new_trained_i < len(new_lows) and new_lows[low_new_trained_i].type != StrategyType.sb3_model: + low_new_trained_i += 1 + + low_extra_start = len(old_game.low_strategies) - low_trained_i-1 + low_new_trained_i + # low_extra_start shows index of 1st low strategy that is not in the previous saved game, all strategies after this index should be added to the game + while low_extra_start >= 0 and (new_lows[low_extra_start].name != old_game.low_strategies[-1].name): + low_extra_start -= 1 + + for i in range(low_extra_start+1, len(new_lows)): + old_game.low_strategies.append(new_lows[i]) + n = len(old_game.high_strategies) + old_game.add_low_cost_row(np.zeros(n), np.zeros(n)) + for j in range(len(old_game.high_strategies)): + old_game.update_matrix_entry((len(old_game.low_strategies)-1), j) + + high_trained_i = 0 + while high_trained_i < len(old_game.high_strategies) and old_game.high_strategies[high_trained_i].type != StrategyType.sb3_model: + high_trained_i += 1 + + high_new_trained_i = 0 + while high_new_trained_i < len(new_highs) and new_highs[high_new_trained_i].type != StrategyType.sb3_model: + high_new_trained_i += 1 + + high_extra_start = len(old_game.high_strategies) - high_trained_i-1 + high_new_trained_i + # low_extra_start shows index of 1st low strategy that is not in the previous saved game, all strategies after this index should be added to the game + while high_extra_start >= 0 and (new_highs[high_extra_start].name != old_game.high_strategies[-1].name): + high_extra_start -= 1 + + for i in range(high_extra_start+1, len(new_highs)): + old_game.high_strategies.append(new_highs[i]) + n = len(old_game.low_strategies) + old_game.add_high_cost_col(np.zeros(n), np.zeros(n)) + for j in range(len(old_game.low_strategies)): + old_game.update_matrix_entry(j, (len(old_game.high_strategies)-1)) + + return old_game + + +def str_to_envclass(s): + if s == envs.ConPricingGame.__name__: + return envs.ConPricingGame + elif s == envs.DisPricingGame.__name__: + return envs.DisPricingGame + else: + return None + + +def train(inputs): + """ traines one agent against the adversary, if the expected payoff of new agent is greater than expected payoff of NE, returns acceptable=true and the new strategy and payoff to be added to the strategies and matrix.""" + id, seed, job_name, env, base_agent, alg, adv_mixed_strategy, lr, target_payoff, db = inputs + + gl.initialize() + + model_name = f"{job_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + acceptable = False + if base_agent is None: + number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + if alg is SAC: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0, seed=seed) + else: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, seed=seed) + else: + number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + base_agent_dir = f"{gl.MODELS_DIR}/{base_agent}" + if alg is SAC: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + else: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + + # https://stable-baselines3.readthedocs.io/en/master/guide/examples.html#id3 + # check to save and load replay buffer as well + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + model_strategy = Strategy(strategy_type=StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=env.action_step, memory=env.memory) + + iter_rows = [] + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=env, adversary=adv_mixed_strategy.strategies[strategy_index])) + + # adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands + iter_row = Iter_row(adv=env.adversary_strategy.name, agent_return=sum(env.profit[0]), adv_return=sum(env.profit[1]), rewards=str( + env.profit[0]), adv_rewards=str(env.profit[1]), actions=str(env.actions), prices=str(env.prices[0]), adv_prices=str(env.prices[1]), demands=str(env.demand_potential[0]), adv_demands=str(env.demand_potential[1])) + + iter_rows.append(iter_row) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + + acceptable = (expected_payoff > target_payoff) + # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time) + agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, env.costs[0], str( + adv_mixed_strategy), expected_payoff, target_payoff, str(alg), lr, env.memory, acceptable, env.action_step, seed, 1, running_time)) + # num_processes=1 because it just uses one process in training this agent + + if acceptable: + for row in iter_rows: + db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards, + row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands) + + return (id, acceptable, model_strategy.name, agent_payoffs, adv_payoffs, expected_payoff) + + +def train_processes(db, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory): + """ + trains multiple agents with multiprocessing against mixed_adversary. + """ + inputs = [] + seed = int(time.time()) + adv_strt = adv_mixed_strategy.copy_unload() + + base_agents = find_base_agents(db=db, alg=alg, memory=memory, cost=costs[0], mix_strt=adv_strt, size=num_procs) + + for p in range(num_procs): + env = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + input_proc = (p, seed+p, job_name, env, base_agents[p], alg, adv_strt, lr, target_payoff, db) + inputs.append(input_proc) + results = [] + + pool = mp.Pool(processes=num_procs) + + outputs = pool.imap_unordered(train, inputs) + for output in outputs: + id, acceptable, strategy_name, agent_payoffs, adv_payoffs, expected_payoff = output + # id,acceptable,strategy_name,agent_payoffs, adv_payoffs, expected_payoff= train(inputs[0]) + pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + model_strategy = Strategy(strategy_type=StrategyType.sb3_model, + model_or_func=alg, name=strategy_name, action_step=pricing_game.action_step, memory=memory) + # compute the payoff against all adv strategies, to be added to the matrix + if acceptable: + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + results.append((acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff, base_agents[id])) + pool.close() + pool.join() + return results diff --git a/DoubleOracle/src/columnprint.py b/DoubleOracle/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/DoubleOracle/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/DoubleOracle/src/environments.py b/DoubleOracle/src/environments.py new file mode 100644 index 0000000..d2e1ee3 --- /dev/null +++ b/DoubleOracle/src/environments.py @@ -0,0 +1,184 @@ +# In this env, in the state representation, the memory og both agent and adversary will be given. the length of memory is specified with variable memory + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl + +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__() + # gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + #memory of both players + self.memory=memory + # self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(2+2*memory,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, memory=None): + # [stage, our demand, our price memory, adv price memory] + + mem_len = memory if ( + memory is not None) else self.memory + + + stage_part = [stage] + self_mem=[] + adv_mem=[] + + if stage == 0: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + observation = stage_part+[self.demand_potential[player][self.stage]] + self_mem+ adv_mem + else: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + j = mem_len-1 + for i in range(stage-1, max(-1, stage-1-mem_len), -1): + adv_mem[j] = self.prices[1-player][i] + self_mem[j] = self.prices[player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player][self.stage]]+ self_mem+ adv_mem + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__(tuple_costs, adversary_mixed_strategy,memory) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + diff --git a/DoubleOracle/src/globals.py b/DoubleOracle/src/globals.py new file mode 100644 index 0000000..0090488 --- /dev/null +++ b/DoubleOracle/src/globals.py @@ -0,0 +1,73 @@ +import numpy as np + + +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, GAMMA, NUM_ACTIONS, REWARDS_DIVISION_CONST + global NUM_STOCHASTIC_ITER, NUM_MATRIX_ITER, N_EPISODES_BASE, N_EPISODES_LOAD, EPISODE_INCREASE_PORTION + # global REPLAY_BUFFER_SIZE, PROB_BREAK_LIMIT_LN, CONVERGE_BREAK, PRINT_STEP,NUM_ADV_HISTORY, LR,ACTION_STEP + # global BATCH_UPDATE_SIZE, BUFFER_PLAY_COEFFICIENT, NUM_PROCESS, NUM_MODEL_SAVE + global CON_ACTIONS_RANGE, MODELS_DIR, LOG_DIR, NUM_TRACE_EQUILIBRIA, GAMES_DIR, NUM_PROCESS + # global SPE_A, SPE_a, SPE_B, SPE_b, SPE_K, SPE_k, SPE_z, SPE_Y + + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE = 60 + # ACTION_STEP = 3 + + REWARDS_DIVISION_CONST = 1000 + + N_EPISODES_BASE = 2_50 + N_EPISODES_LOAD = 1_00 + NUM_STOCHASTIC_ITER = 2 + NUM_MATRIX_ITER = 2 + # NUM_STOCHASTIC_ITER = 100 + # NUM_MATRIX_ITER = 100 + # N_EPISODES_BASE = 2_000_000 + # N_EPISODES_LOAD = 800_000 + EPISODE_INCREASE_PORTION = 0.3 + + # NUM_EPISODES_RESET = NUM_EPISODES + + NUM_TRACE_EQUILIBRIA = 2 + # #HOW OFTEN THE MODEL SHOULD BE SAVED. + # NUM_MODEL_SAVE=3 + + NUM_PROCESS = 6 + + MODELS_DIR = "models" + LOG_DIR = "logs" + GAMES_DIR = "games" + + # SPE coefficients + + # SPE_a = [np.nan]*25 + # SPE_A = [np.nan]*25 + # SPE_b = [np.nan]*25 + # SPE_B = [np.nan]*25 + # SPE_k = [np.nan]*25 + # SPE_K = [np.nan]*25 + # SPE_z = [np.nan]*25 + # SPE_Y = [np.nan]*25 + + # SPE_a[24] = 0.5 + # SPE_A[24] = 0.25 + # SPE_b[24] = 132 + # SPE_B[24] = 68 + # SPE_k[24] = 0.5 + # SPE_K[24] = -0.5 + # SPE_Y[24] = 0.25 * GAMMA + + # for t in range(23, -1, -1): + # SPE_a[t] = (1-SPE_Y[t+1])/(2-SPE_Y[t+1]) + # SPE_z[t] = GAMMA*(0.75-0.5*SPE_a[t]) + # SPE_k[t] = (1-0.5*GAMMA*SPE_K[t+1])/(2-SPE_Y[t+1]) + # SPE_K[t] = -0.5 + SPE_z[t]*(SPE_K[t+1]-2*SPE_A[t+1]*SPE_k[t]) + # SPE_A[t] = 0.25 + SPE_z[t]*SPE_A[t+1]*(1-SPE_a[t]) + # SPE_b[t] = 132 - 0.25*GAMMA*SPE_B[t+1] + # SPE_B[t] = 68 + SPE_z[t]*SPE_B[t+1] + # SPE_Y[t] = 0.25*GAMMA + SPE_z[t]*(1-SPE_a[t])*SPE_Y[t+1] diff --git a/DoubleOracle/src/lemke.py b/DoubleOracle/src/lemke.py new file mode 100644 index 0000000..afb0921 --- /dev/null +++ b/DoubleOracle/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint as columnprint +import src.utils as utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0].out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s == "-v" or s == "-verbose": + verbose = True + elif s == "-s" or s == "-silent": + silent = True + elif s == "-z0": + z0 = True + elif s[0] == "-": + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + + + # creae LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, it): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout( "lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]* = + self.d = [0]*n + needfracs = n*n + 2*n + if len(words != needfacs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs," fr actions, got", len(words)-5) + exi t(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 == + s el f.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 == + s el f.q = utils.tovector(n,words,k) + k+=n + elif wo rds[k]=="d=": + k+=1 == + s el f.d = utils.tovector(n,words,k) + k+=n + else: + pintout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q = self.q + d = self.d + m = = columnprint.columnprint(n) + m = makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m. sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +classu: + # filling the tableau from the LCP instance Mqd + + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = []*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinan = 1 + self.lextested = [0]*(n+1) + self.lexcompa = isons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + == n = Mqd.q[i].denominator + else: + de == = Mq d.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif == ==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: == + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa" ) # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichv ar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = st r(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "----------------end of tableau-----------------" + return out + + def vartoa(self , v): # variable as as string w1..wn or z0..zn + if (v > sel f.n): + return "w"+str(v-self.n) +else: + return "z"+s tr(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is no nbasic + self.solution[i]=fractions.Fration(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n = + sol.sprint("basis=") + for i in rang e(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info "Cob asic variable", self.vartoa(v), + "shouldbe basic") + exit(1) + return + + def assertcobasi(self, v, info): # assert that v is cobasic + if (self .bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(sef, leave, enter): # leave, enter in VARS + self.ass ertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout(s) + returnt("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in ran ge(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobs[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return == + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + prntout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lex t[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.spr int(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave idicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecad == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as ther == is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j omitted from statistics: only one possible row + i eans no .in-ratio test needed for leaving varia + # T is basic, or equal to the entering variable. + j =going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+ 1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + == newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # comp are ratios via products + tmp1 = Anewcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][c] + # sgn =np.sign(tmp1- tmp2) + # if sgn==0: + if tmp1 == tm p2 : # new ratiois the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand f in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n ] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check i f z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in ra nge(self.n): + self.A[i][col] = - == lf.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, +vot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with poitive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in ran ge(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot 1; + flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binter ac t = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtai n lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flgs.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/DoubleOracle/src/utils.py b/DoubleOracle/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/DoubleOracle/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/.DS_Store b/learningAgents/.DS_Store new file mode 100644 index 0000000..1b04ac8 Binary files /dev/null and b/learningAgents/.DS_Store differ diff --git a/learningAgents/Double_oracle_multi_params/DO.ipynb b/learningAgents/Double_oracle_multi_params/DO.ipynb new file mode 100644 index 0000000..295fee9 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/DO.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "dea34fbb-ece9-4c29-9b1b-ef758f09668f", + "metadata": {}, + "outputs": [], + "source": [ + "import gymnasium as gym\n", + "from gymnasium import spaces\n", + "import numpy as np\n", + "from stable_baselines3 import SAC, PPO\n", + "from stable_baselines3.common.env_util import make_vec_env\n", + "from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv\n", + "import time\n", + "import sys\n", + "from src.environments import ConPricingGame\n", + "import src.globals as gl\n", + "import src.classes as cl" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3ca76fb0-453a-409b-ad83-b6d4196f62b8", + "metadata": {}, + "outputs": [], + "source": [ + "class Iter_row:\n", + " def __init__(self, adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands):\n", + " self.adv = adv\n", + " self.agent_return = agent_return\n", + " self.adv_return = adv_return\n", + " self.rewards = rewards\n", + " self.adv_rewards = adv_rewards\n", + " self.actions = actions\n", + " self.prices = prices\n", + " self.adv_prices = adv_prices\n", + " self.demands = demands\n", + " self.adv_demands = adv_demands" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd831764-040c-4580-a8a0-6fc9986b3b04", + "metadata": {}, + "outputs": [], + "source": [ + "def find_base_agent(db,alg, memory, cost, strategies, strategy_probs):\n", + " \"\"\" the startegies should be the same class of agents as we are training. if low cost then low-cost strategies should be given to find similar ones. The trained agents that are not even added will be considered \"\"\"\n", + " strats=strategies.copy()\n", + " probs=strategy_probs.copy()\n", + " for i in range(len(probs)-1):\n", + " for j in range(i+1,len(probs)):\n", + " if probs[i]< probs[j]:\n", + " strats[i],strats[j] = strats[j], strats[i]\n", + " probs[i],probs[j] = probs[j], probs[i]\n", + " for st in strats:\n", + " if st.type==cl.StrategyType.sb3_model and memory == st.memory and (alg is st.model) :\n", + " return st.name\n", + " query=f'SELECT name FROM {cl.DataBase.AGENTS_TABLE} WHERE cost={cost} and memory={memory} and alg=\\\"{str(alg)}\\\" ORDER BY id DESC'\n", + " db.cursor.execute(query)\n", + " tmp= db.cursor.fetchone()\n", + " if tmp is not None:\n", + " return tmp[0]\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "286f8903-6ec8-4c8e-8868-a7da4d67bf77", + "metadata": {}, + "outputs": [], + "source": [ + "def training(db,base_agent, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory):\n", + " \"\"\"\n", + " trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \\\n", + " returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix.\n", + " \"\"\"\n", + " \n", + "\n", + " acceptable = False\n", + "\n", + " pricing_game = env_class(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy, memory=memory)\n", + "\n", + " seed = int(time.time())\n", + "\n", + " model_name = f\"{job_name}-{str(seed)}\"\n", + " models_dir = f\"{gl.MODELS_DIR}/{model_name}\"\n", + "\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + "\n", + " # if not os.path.exists(models_dir):\n", + " # os.makedirs(models_dir)\n", + "\n", + " # if not os.path.exists(log_dir):\n", + " # os.makedirs(log_dir)\n", + "\n", + " # number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \\\n", + " # (adv_mixed_strategy.support_size-1)\n", + " train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy, memory=memory))\n", + " if base_agent is None:\n", + " number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " if alg is SAC:\n", + " model = alg('MlpPolicy', train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " else:\n", + " model = alg('MlpPolicy', train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA)\n", + " else:\n", + " number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " base_agent_dir = f\"{gl.MODELS_DIR}/{base_agent}\"\n", + " if alg is SAC:\n", + " model = alg.load(base_agent_dir, train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " else:\n", + " model = alg.load(base_agent_dir, train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA)\n", + "\n", + " start = time.time()\n", + " # for i in range(gl.NUM_MODEL_SAVE):\n", + " # tmp = (number_episodes/gl.NUM_MODEL_SAVE)\n", + " # model.learn(total_timesteps=tmp, reset_num_timesteps=False,\n", + " # tb_log_name=model_name)\n", + " # model.save(os.path.join(models_dir, str(tmp*(i+1))))\n", + " model.learn(total_timesteps=number_episodes, tb_log_name=model_name)\n", + " model.save(models_dir)\n", + " running_time = time.time() - start\n", + "\n", + " agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " expected_payoff = 0\n", + "\n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=model_name, action_step=pricing_game.action_step,memory=memory)\n", + " iter_rows = []\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] > 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " # returns = algorithm.play_trained_agent(adversary=(\n", + " # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter)\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " \n", + " #adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands\n", + " iter_row = Iter_row(adv=pricing_game.adversary_strategy.name, agent_return=sum(pricing_game.profit[0]), adv_return=sum(pricing_game.profit[1]), rewards=str(\n", + " pricing_game.profit[0]), adv_rewards=str(pricing_game.profit[1]), actions=str(pricing_game.actions),prices=str(pricing_game.prices[0]), adv_prices=str(pricing_game.prices[1]) ,demands=str(pricing_game.demand_potential[0]), adv_demands=str(pricing_game.demand_potential[1]))\n", + "\n", + " iter_rows.append(iter_row)\n", + "\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + " expected_payoff += (agent_payoffs[strategy_index]) * \\\n", + " (adv_mixed_strategy.strategy_probs[strategy_index])\n", + "\n", + " acceptable = (expected_payoff > target_payoff)\n", + " # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time)\n", + " agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, costs[0], str(\n", + " adv_mixed_strategy), expected_payoff, target_payoff, str(alg),lr, memory, acceptable, pricing_game.action_step, seed, num_procs, running_time))\n", + "\n", + " if expected_payoff > target_payoff:\n", + " acceptable = True\n", + " for row in iter_rows:\n", + " db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards,\n", + " row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands)\n", + " # compute the payoff against all adv strategies, to be added to the matrix\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] == 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + "\n", + " return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7392fe9-84d2-467d-b610-3936ca16878e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training low-cost player with base=NOV24-1700835982 ,alg=, lr=0.0003, memory=3\n", + "training low-cost player with base=NOV24-1700841665 ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=NOV24-1700835982 ,alg=, lr=0.0002, memory=3\n", + "training low-cost player with base=NOV24-1700841665 ,alg=, lr=0.0002, memory=12\n", + "training low-cost player with base=NOV24-1700860722 ,alg=, lr=0.0003, memory=3\n", + "training low-cost player with base=NOV24-1701105136 ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=NOV24-1700860722 ,alg=, lr=0.0002, memory=3\n", + "training low-cost player with base=NOV24-1701178979 ,alg=, lr=0.0002, memory=12\n", + "training high-cost player with base=NOV24-1700879879 ,alg=, lr=0.0003, memory=3\n", + "training high-cost player with base=NOV24-1701109759 ,alg=, lr=0.0003, memory=12\n", + "training high-cost player with base=NOV24-1700879879 ,alg=, lr=0.0002, memory=3\n", + "training high-cost player with base=NOV24-1701109759 ,alg=, lr=0.0002, memory=12\n" + ] + } + ], + "source": [ + "env_class = ConPricingGame\n", + "gl.initialize()\n", + "\n", + "num_rounds = 20\n", + "\n", + "job_name = \"NOV24\"\n", + "db_name = job_name+\".db\"\n", + "db = cl.DataBase(db_name)\n", + "low_strts, high_strts=db.get_list_of_added_strategies()\n", + "cl.set_job_name(job_name)\n", + "# num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1])\n", + "num_procs = 15\n", + "\n", + "\n", + "\n", + "# changing params\n", + "lrs = [0.0003, 0.00016]\n", + "memories = [3, 12]\n", + "# memories_agents=[[None]*len(memories)]*2\n", + "algs = [SAC, PPO]\n", + "\n", + "equilibria = []\n", + "\n", + "cl.create_directories()\n", + "\n", + "strt1 = cl.Strategy(\n", + " cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")\n", + "strt2 = cl.Strategy(\n", + " cl.StrategyType.static, model_or_func=cl.const, name=\"const\", first_price=132)\n", + "strt3 = cl.Strategy(\n", + " cl.StrategyType.static, model_or_func=cl.guess, name=\"guess\", first_price=132)\n", + "# strt4 = cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.spe, name=\"spe\")\n", + "\n", + "bimatrix_game = cl.BimatrixGame(\n", + " low_cost_strategies=[strt1, strt2, strt3]+low_strts, high_cost_strategies=[strt1, strt2, strt3]+high_strts, env_class=env_class)\n", + "\n", + "bimatrix_game.reset_matrix()\n", + "bimatrix_game.fill_matrix()\n", + "\n", + "\n", + "\n", + "cl.prt(\"\\n\" + time.ctime(time.time())+\"\\n\"+(\"-\"*50)+\"\\n\")\n", + "\n", + "dictionaries = bimatrix_game.compute_equilibria()\n", + "\n", + "# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria()\n", + "for round in range(num_rounds):\n", + " cl.prt(f\"Round {round} of {num_rounds}\")\n", + " \n", + " added_low=0\n", + " added_high=0\n", + " # for equilibrium in dictionaries:\n", + " for equi_i in range(len(dictionaries)):\n", + " new_equi_low = 0\n", + " new_equi_high = 0\n", + " equi = dictionaries[equi_i]\n", + " low_prob_str = \", \".join(\n", + " map(\"{0:.2f}\".format, equi[\"low_cost_probs\"]))\n", + " high_prob_str = \", \".join(\n", + " map(\"{0:.2f}\".format, equi[\"high_cost_probs\"]))\n", + " cl.prt(\n", + " f'equi: [{low_prob_str}], [{high_prob_str}], {equi[\"low_cost_payoff\"]:.2f}, {equi[\"high_cost_payoff\"]:.2f}')\n", + " \n", + " # train a low-cost agent\n", + " high_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi[\"high_cost_probs\"]+([0]*added_high)) if added_high> 0 else equi[\"high_cost_probs\"]))\n", + " \n", + " base_agent=None\n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for mem_i,memory in enumerate(memories):\n", + " # base_strt=(high_mixed_strat.strategies[np.argmax(\n", + " # np.array(high_mixed_strat.strategy_probs))])\n", + " # if base_strt.type == cl.StrategyType.sb3_model:\n", + " # base_agent = base_strt.name\n", + " base_agent= find_base_agent(db=db,memory=memory, alg=alg, cost=gl.LOW_COST, strategies= bimatrix_game.low_strategies,strategy_probs=((equi[\"low_cost_probs\"]+([0]*added_low)) if added_low > 0 else equi[\"low_cost_probs\"])) \n", + " print(f'training low-cost player with base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(db=db,base_agent=base_agent, env_class=env_class, costs=[\n", + " gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi[\"low_cost_payoff\"], num_procs=num_procs, alg=alg, lr=lr, memory=memory)\n", + " if acceptable:\n", + " new_equi_low += 1\n", + " added_low+=1\n", + " \n", + " # update[int(i/2)] = True\n", + " bimatrix_game.low_strategies.append(agent_strategy)\n", + " bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs)\n", + " \n", + " # cl.prt(f\"low cost player {agent_strategy.name} added, trained with \", [\n", + " # equi[\"low_cost_probabilities\"], equi[\"high_cost_probabilities\"], equi[\"low_cost_payoff\"], equi[\"high_cost_payoff\"]])\n", + " cl.prt(\n", + " f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " # train a high-cost agent\n", + " low_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi[\"low_cost_probs\"]+([0]*added_low)) if added_low > 0 else equi[\"low_cost_probs\"]))\n", + " \n", + " base_agent=None\n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for memory in memories:\n", + " \n", + " # base_strt=(low_mixed_strat.strategies[np.argmax(\n", + " # np.array(low_mixed_strat.strategy_probs))])\n", + " # if base_strt.type == cl.StrategyType.sb3_model:\n", + " # base_agent = base_strt.name\n", + " base_agent= find_base_agent(db=db,cost=gl.HIGH_COST,memory=memory, strategies= bimatrix_game.high_strategies,strategy_probs=((equi[\"high_cost_probs\"]+([0]*added_high)) if added_high> 0 else equi[\"high_cost_probs\"]),alg=alg)\n", + " print(f'training high-cost player with base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(db=db,base_agent=base_agent, env_class=env_class, costs=[\n", + " gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi[\"high_cost_payoff\"], num_procs=num_procs, alg=alg, memory=memory, lr=lr)\n", + " if acceptable:\n", + " new_equi_high += 1\n", + " added_high+=1\n", + " bimatrix_game.high_strategies.append(agent_strategy)\n", + " bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs)\n", + " \n", + " cl.prt(\n", + " f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent}, alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " if new_equi_low>0 or new_equi_high>0:\n", + " equilibria.append(\n", + " [equi[\"low_cost_probs\"], equi[\"high_cost_probs\"], equi[\"low_cost_payoff\"], equi[\"high_cost_payoff\"]])\n", + " dictionaries = bimatrix_game.compute_equilibria()\n", + " \n", + " if added_low==0 and added_high==0:\n", + " gl.N_EPISODES_BASE *= 1.1\n", + " gl.N_EPISODES_LOAD *= 1.1\n", + " else:\n", + " dictionaries = bimatrix_game.compute_equilibria()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef372678-7225-48bc-8c31-2fad59bcc7c0", + "metadata": {}, + "outputs": [], + "source": [ + "# env=ConPricingGame(tuple_costs=[57,71], adversary_mixed_strategy= (cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")).to_mixed_strategy(), memory=3)\n", + "\n", + "# policy = (PPO.load(\"models/\"+\"NOV24-1700860722\", env=env)).predict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b98de76c-95c6-4052-b30b-4b63e49f1604", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "venv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/Double_oracle_multi_params/src/bimatrix.py b/learningAgents/Double_oracle_multi_params/src/bimatrix.py new file mode 100644 index 0000000..870b57e --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils as utils +import src.columnprint as columnprint +import src.lemke as lemke +import src.randomstart as randomstart +import random # random.seed +import src.classes as cl + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + cl.prt("\n all equilibria: \n") + for eq in sorted_trset: + cl.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/Double_oracle_multi_params/src/classes.py b/learningAgents/Double_oracle_multi_params/src/classes.py new file mode 100644 index 0000000..ba74416 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/classes.py @@ -0,0 +1,532 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +# from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix as bimatrix +import time +import os +import sqlite3 as sql +from collections import namedtuple +from stable_baselines3 import SAC, PPO +from copy import copy + + +class DataBase(): + + AgentRow = namedtuple( + "AgentRow", "name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, alg, lr, memory, added, action_step, seed, num_process, running_time") + + AGENTS_TABLE = "trained_agents" + ITERS_TABLE = "agents_iters" + AGENTS_COLS = "id integer PRIMARY key AUTOINCREMENT,name text NOT NULL,base_agent text DEFAULT NULL,n_ep integer NOT NULL,cost integer NOT NULL,mixed_adv text NOT NULL,expected_payoff real,payoff_treshhold real,alg text NOT NULL,lr real NOT NULL,memory integer NOT NULL, action_step integer DEFAULT NULL,seed integer,num_procs integer DEFAULT 1,running_time integer, added integer,time text" + ITERS_COLS = "id integer PRIMARY key AUTOINCREMENT,agent_id integer NOT NULL,adv text NOT NULL,agent_return text,adv_return text,agent_rewards text,adv_rewards text,actions text,agent_prices text,adv_prices text, agent_demands text,adv_demands text" + + def __init__(self, name="data.db") -> None: + self.db_name = name + self.reset() + + def reset(self): + self.connection = sql.connect(self.db_name) + self.cursor = self.connection.cursor() + self.cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.AGENTS_TABLE}({self.AGENTS_COLS});') + self.cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.ITERS_TABLE}({self.ITERS_COLS});') + + # def insert_new_agent(self, name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, lr, memory, added, action_step=None, seed=0, num_process=1, running_time=0): + def insert_new_agent(self, row): + """ + adds a new agent to db and returns the id + row: AgentRow named tuple + """ + query = f'INSERT INTO {self.AGENTS_TABLE} VALUES (NULL,\'{row.name}\',' + ('NULL' if (row.base_agent is None) else f'\'{row.base_agent}\'') + \ + f',{row.num_ep},{row.cost},\'{row.mixed_adv_txt}\',{row.expected_payoff},{row.payoff_treshhold},\"{row.alg}\",{row.lr},{row.memory},{("NULL" if row.action_step is None else row.action_step)},{row.seed},{row.num_process},{row.running_time},{int(row.added)},\'{ time.ctime(time.time())}\')' + # print(query) + self.cursor.execute(query) + self.connection.commit() + return self.cursor.lastrowid + + def insert_new_iteration(self, agent_id, adv_txt, agent_return, adv_return, agent_rewards_txt, adv_rewards_txt, actions_txt, agent_prices_txt, adv_prices_txt, + agent_demands_txt, adv_demands_txt): + """ + adds a new iteration to db and returns the id + """ + query = f'INSERT INTO {self.ITERS_TABLE} VALUES (NULL,{agent_id},\'{adv_txt}\',{agent_return},{adv_return},\'{agent_rewards_txt}\',\'{adv_rewards_txt}\',\ + \'{actions_txt}\',\'{agent_prices_txt}\',\'{adv_prices_txt}\',\'{agent_demands_txt}\',\'{adv_demands_txt}\')' + # print(query) + self.cursor.execute(query) + self.connection.commit() + return self.cursor.lastrowid + + def get_list_of_added_strategies(self): + """ returns two lists of low_cost and high_cost strategies """ + low_q= f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.LOW_COST})" + high_q= f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.HIGH_COST})" + low_lst=[] + high_lst=[] + self.cursor.execute(low_q) + low_all=self.cursor.fetchall() + for tup in low_all: + if tup[1]==str(SAC): + model=SAC + elif tup[1]== str(PPO): + model=PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [],[] + + low_lst.append(Strategy(strategy_type=StrategyType.sb3_model,model_or_func=model,name=tup[0],memory=tup[2],action_step=tup[3])) + + self.cursor.execute(high_q) + high_all=self.cursor.fetchall() + for tup in high_all: + if tup[1]==str(SAC): + model=SAC + elif tup[1]== str(PPO): + model=PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [],[] + + high_lst.append(Strategy(strategy_type=StrategyType.sb3_model,model_or_func=model,name=tup[0],memory=tup[2],action_step=tup[3])) + return low_lst, high_lst + + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + strt_L = self.low_strategies[low_index] + strt_H = self.high_strategies[high_index] + strt_L.reset() + strt_H.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=strt_H.to_mixed_strategy(), memory=strt_L.memory) + payoffs = [strt_L.play_against(env, strt_H) + for _ in range(gl.NUM_MATRIX_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"game_{job_name}.txt", "w") as out: + out.write(output) + + output += "\nlow-cost strategies: \n" + for strt in self.low_strategies: + output += f" {strt.name} " + output += "\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output += f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can be models trained with sb3. + """ + type = None + env = None + name = None + memory = None + policy = None + model = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, memory=0, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.memory = memory + + self.action_step = action_step + + if strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.sb3_model: + if self.policy is None: + if env.memory != self.memory: + env_adv=(env.__class__)(tuple_costs=env.costs, adversary_mixed_strategy=env.adversary_mixed_strategy, memory=self.memory) + self.policy = (self.model.load(self.dir, env=env_adv)).predict + else: + self.policy = (self.model.load(self.dir, env=env)).predict + state = env.get_state( + stage=env.stage, player=player, memory=self.memory) + action, _ = self.policy(state) + # compute price for co model and disc model + price = (env.myopic(player)-action[0]) if (self.action_step is None) else ( + env.myopic(player)-(self.action_step*action)) + + if player == 0: + env.actions[env.stage] = (action[0] if ( + self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy = adversary.to_mixed_strategy() + + state, _ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size = support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def spe(env, player, firstprice=0): + """ + returns the subgame perfect equilibrium price + """ + t = env.stage + P = gl.SPE_a[t]*(env.demand_potential[player][t]-200) + gl.SPE_b[t] + gl.SPE_k[t]*(env.costs[player]-64) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt', 'a') as file: + file.write("\n"+string) + + +# def write_to_excel(file_name, new_row): +# """ +# row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time +# """ + +# path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + +# wb = load_workbook(path) +# sheet = wb.active +# row = 2 +# col = 1 +# sheet.insert_rows(idx=row) + +# for i in range(len(new_row)): +# sheet.cell(row=row, column=col+i).value = new_row[i] +# wb.save(path) + + +# def write_results(new_row): +# write_to_excel(f'results_{job_name}.xlsx', new_row) + + +# def write_agents(new_row): +# # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ +# # gamma seed num_procs running_time date + +# write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.GAMES_DIR): + os.makedirs(gl.GAMES_DIR) + + +def set_job_name(name): + global job_name + job_name = name diff --git a/learningAgents/Double_oracle_multi_params/src/columnprint.py b/learningAgents/Double_oracle_multi_params/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/Double_oracle_multi_params/src/doubleoracle.py b/learningAgents/Double_oracle_multi_params/src/doubleoracle.py new file mode 100644 index 0000000..453a56e --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/doubleoracle.py @@ -0,0 +1,13 @@ +from enum import Enum +import numpy as np +import classes as cl + +class DoubleOracle(): + """ + this class is the data structure to represent the double oracle which is a bimatrix game with low-cost and high-cost strategies are trained and added to it based on the Nash equilibrium. + + """ + def __init__(self): + cl.create_directories() + + diff --git a/learningAgents/Double_oracle_multi_params/src/environments.py b/learningAgents/Double_oracle_multi_params/src/environments.py new file mode 100644 index 0000000..81abd92 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/environments.py @@ -0,0 +1,183 @@ +# In this env, in the state representation, the memory og both agent and adversary will be given. the length of memory is specified with variable memory + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl +import src.classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + #memory of both players + self.memory=memory + # self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(2+2*memory,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, memory=None): + # [stage, our demand, our price memory, adv price memory] + + mem_len = memory if ( + memory is not None) else self.memory + + + stage_part = [stage] + self_mem=[] + adv_mem=[] + + if stage == 0: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + observation = stage_part+[self.demand_potential[player][self.stage]] + self_mem+ adv_mem + else: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + j = mem_len-1 + for i in range(stage-1, max(-1, stage-1-mem_len), -1): + adv_mem[j] = self.prices[1-player][i] + self_mem[j] = self.prices[player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player][self.stage]]+ self_mem+ adv_mem + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__(tuple_costs, adversary_mixed_strategy,memory) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/Double_oracle_multi_params/src/globals.py b/learningAgents/Double_oracle_multi_params/src/globals.py new file mode 100644 index 0000000..839f8fc --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/globals.py @@ -0,0 +1,69 @@ +import numpy as np + + +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, GAMMA, NUM_ACTIONS, REWARDS_DIVISION_CONST + global NUM_STOCHASTIC_ITER, NUM_MATRIX_ITER, N_EPISODES_BASE, N_EPISODES_LOAD, EPISODE_INCREASE_PORTION + # global REPLAY_BUFFER_SIZE, PROB_BREAK_LIMIT_LN, CONVERGE_BREAK, PRINT_STEP,NUM_ADV_HISTORY, LR,ACTION_STEP + # global BATCH_UPDATE_SIZE, BUFFER_PLAY_COEFFICIENT, NUM_PROCESS, NUM_MODEL_SAVE + global CON_ACTIONS_RANGE, MODELS_DIR, LOG_DIR, NUM_TRACE_EQUILIBRIA, GAMES_DIR, NUM_PROCESS + global SPE_A, SPE_a, SPE_B, SPE_b, SPE_K, SPE_k, SPE_z, SPE_Y + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE = 60 + # ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 20 + NUM_MATRIX_ITER = 100 + REWARDS_DIVISION_CONST = 1000 + + # N_EPISODES_BASE = 2_50 + # N_EPISODES_LOAD = 1_00 + N_EPISODES_BASE = 2_000_000 + N_EPISODES_LOAD = 800_000 + EPISODE_INCREASE_PORTION = 0.3 + + # NUM_EPISODES_RESET = NUM_EPISODES + + NUM_TRACE_EQUILIBRIA = 2 + # #HOW OFTEN THE MODEL SHOULD BE SAVED. + # NUM_MODEL_SAVE=3 + + NUM_PROCESS = 6 + + MODELS_DIR = "models" + LOG_DIR = "logs" + GAMES_DIR = "games" + + # SPE coefficients + + SPE_a = [np.nan]*25 + SPE_A = [np.nan]*25 + SPE_b = [np.nan]*25 + SPE_B = [np.nan]*25 + SPE_k = [np.nan]*25 + SPE_K = [np.nan]*25 + SPE_z = [np.nan]*25 + SPE_Y = [np.nan]*25 + + SPE_a[24] = 0.5 + SPE_A[24] = 0.25 + SPE_b[24] = 132 + SPE_B[24] = 68 + SPE_k[24] = 0.5 + SPE_K[24] = -0.5 + SPE_Y[24] = 0.25 * GAMMA + + for t in range(23, -1, -1): + SPE_a[t] = (1-SPE_Y[t+1])/(2-SPE_Y[t+1]) + SPE_z[t] = GAMMA*(0.75-0.5*SPE_a[t]) + SPE_k[t] = (1-0.5*GAMMA*SPE_K[t+1])/(2-SPE_Y[t+1]) + SPE_K[t] = -0.5 + SPE_z[t]*(SPE_K[t+1]-2*SPE_A[t+1]*SPE_k[t]) + SPE_A[t] = 0.25 + SPE_z[t]*SPE_A[t+1]*(1-SPE_a[t]) + SPE_b[t] = 132 - 0.25*GAMMA*SPE_B[t+1] + SPE_B[t] = 68 + SPE_z[t]*SPE_B[t+1] + SPE_Y[t] = 0.25*GAMMA + SPE_z[t]*(1-SPE_a[t])*SPE_Y[t+1] diff --git a/learningAgents/Double_oracle_multi_params/src/lemke.py b/learningAgents/Double_oracle_multi_params/src/lemke.py new file mode 100644 index 0000000..afb0921 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint as columnprint +import src.utils as utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0].out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s == "-v" or s == "-verbose": + verbose = True + elif s == "-s" or s == "-silent": + silent = True + elif s == "-z0": + z0 = True + elif s[0] == "-": + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + + + # creae LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, it): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout( "lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]* = + self.d = [0]*n + needfracs = n*n + 2*n + if len(words != needfacs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs," fr actions, got", len(words)-5) + exi t(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 == + s el f.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 == + s el f.q = utils.tovector(n,words,k) + k+=n + elif wo rds[k]=="d=": + k+=1 == + s el f.d = utils.tovector(n,words,k) + k+=n + else: + pintout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q = self.q + d = self.d + m = = columnprint.columnprint(n) + m = makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m. sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +classu: + # filling the tableau from the LCP instance Mqd + + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = []*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinan = 1 + self.lextested = [0]*(n+1) + self.lexcompa = isons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + == n = Mqd.q[i].denominator + else: + de == = Mq d.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif == ==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: == + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa" ) # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichv ar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = st r(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "----------------end of tableau-----------------" + return out + + def vartoa(self , v): # variable as as string w1..wn or z0..zn + if (v > sel f.n): + return "w"+str(v-self.n) +else: + return "z"+s tr(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is no nbasic + self.solution[i]=fractions.Fration(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n = + sol.sprint("basis=") + for i in rang e(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info "Cob asic variable", self.vartoa(v), + "shouldbe basic") + exit(1) + return + + def assertcobasi(self, v, info): # assert that v is cobasic + if (self .bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(sef, leave, enter): # leave, enter in VARS + self.ass ertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout(s) + returnt("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in ran ge(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobs[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return == + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + prntout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lex t[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.spr int(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave idicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecad == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as ther == is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j omitted from statistics: only one possible row + i eans no .in-ratio test needed for leaving varia + # T is basic, or equal to the entering variable. + j =going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+ 1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + == newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # comp are ratios via products + tmp1 = Anewcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][c] + # sgn =np.sign(tmp1- tmp2) + # if sgn==0: + if tmp1 == tm p2 : # new ratiois the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand f in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n ] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check i f z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in ra nge(self.n): + self.A[i][col] = - == lf.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, +vot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with poitive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in ran ge(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot 1; + flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binter ac t = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtai n lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flgs.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/Double_oracle_multi_params/src/utils.py b/learningAgents/Double_oracle_multi_params/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/Double_oracle_multi_params/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/extend_game/changes/DO.ipynb b/learningAgents/extend_game/changes/DO.ipynb new file mode 100644 index 0000000..893135e --- /dev/null +++ b/learningAgents/extend_game/changes/DO.ipynb @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2905d491-8924-44ef-9521-e76a35dce019", + "metadata": {}, + "outputs": [], + "source": [ + "# added SPE to the base strategies at first, then deleted" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dea34fbb-ece9-4c29-9b1b-ef758f09668f", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "from stable_baselines3 import SAC, PPO\n", + "# from stable_baselines3.common.env_util import make_vec_env\n", + "# from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv\n", + "import time\n", + "import sys\n", + "from src.environments import ConPricingGame\n", + "import src.globals as gl\n", + "import src.classes as cl\n", + "import multiprocessing as mp" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fd831764-040c-4580-a8a0-6fc9986b3b04", + "metadata": {}, + "outputs": [], + "source": [ + "def train(inputs):\n", + " \"\"\" traines one agent against the adversary, if the expected payoff of new agent is greater than expected payoff of NE, returns acceptable=true and the new strategy and payoff to be added to the strategies and matrix.\"\"\"\n", + " id,seed, job_name,env, base_agent, alg, adv_mixed_strategy,lr,target_payoff,db=inputs\n", + " \n", + " gl.initialize()\n", + " model_name = f\"{job_name}-{str(seed)}\"\n", + " models_dir = f\"{gl.MODELS_DIR}/{model_name}\"\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + " \n", + " acceptable = False\n", + " if base_agent is None:\n", + " number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " if alg is SAC:\n", + " model = alg('MlpPolicy', env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0, seed=seed)\n", + " else:\n", + " model = alg('MlpPolicy', env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA,seed=seed)\n", + " else:\n", + " number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " base_agent_dir = f\"{gl.MODELS_DIR}/{base_agent}\"\n", + " if alg is SAC:\n", + " model = alg.load(base_agent_dir, env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " else:\n", + " model = alg.load(base_agent_dir, env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA)\n", + " start = time.time()\n", + " # for i in range(gl.NUM_MODEL_SAVE):\n", + " # tmp = (number_episodes/gl.NUM_MODEL_SAVE)\n", + " # model.learn(total_timesteps=tmp, reset_num_timesteps=False,\n", + " # tb_log_name=model_name)\n", + " # model.save(os.path.join(models_dir, str(tmp*(i+1))))\n", + " \n", + " # https://stable-baselines3.readthedocs.io/en/master/guide/examples.html#id3\n", + " #check to save and load replay buffer as well\n", + " model.learn(total_timesteps=number_episodes, tb_log_name=model_name)\n", + " model.save(models_dir)\n", + " running_time = time.time() - start\n", + " \n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=model_name, action_step=env.action_step,memory=env.memory)\n", + " \n", + " iter_rows = []\n", + " agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " expected_payoff = 0\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] > 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " # returns = algorithm.play_trained_agent(adversary=(\n", + " # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter)\n", + " payoffs.append(model_strategy.play_against(\n", + " env=env, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " \n", + " #adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands\n", + " iter_row = cl.Iter_row(adv=env.adversary_strategy.name, agent_return=sum(env.profit[0]), adv_return=sum(env.profit[1]), rewards=str(\n", + " env.profit[0]), adv_rewards=str(env.profit[1]), actions=str(env.actions),prices=str(env.prices[0]), adv_prices=str(env.prices[1]) ,demands=str(env.demand_potential[0]), adv_demands=str(env.demand_potential[1]))\n", + "\n", + " iter_rows.append(iter_row)\n", + "\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + " expected_payoff += (agent_payoffs[strategy_index]) * \\\n", + " (adv_mixed_strategy.strategy_probs[strategy_index])\n", + "\n", + " acceptable=(expected_payoff > target_payoff)\n", + " # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time)\n", + " agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, env.costs[0], str(\n", + " adv_mixed_strategy), expected_payoff, target_payoff, str(alg),lr, env.memory, acceptable, env.action_step, seed, 1, running_time))\n", + " #num_processes=1 because it just uses one process in training this agent\n", + "\n", + " if acceptable:\n", + " for row in iter_rows:\n", + " db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards,\n", + " row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands)\n", + " \n", + " return (id,acceptable,model_strategy.name,agent_payoffs, adv_payoffs, expected_payoff)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "286f8903-6ec8-4c8e-8868-a7da4d67bf77", + "metadata": {}, + "outputs": [], + "source": [ + "def train_processes(db, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory):\n", + " \"\"\"\n", + " trains multiple agents with multiprocessing against mixed_adversary. \n", + " \"\"\"\n", + " inputs=[]\n", + " seed = int(time.time())\n", + " adv_strt= adv_mixed_strategy.copy_unload()\n", + " \n", + " base_agents= cl.find_base_agents(db=db,alg=alg,memory=memory,cost=costs[0],mix_strt=adv_strt,size=num_procs)\n", + " \n", + " for p in range(num_procs):\n", + " env = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory)\n", + " input_proc=(p,seed+p, job_name,env, base_agents[p],alg, adv_strt,lr,target_payoff,db)\n", + " inputs.append(input_proc)\n", + " results=[]\n", + " # with cf.ProcessPoolExecutor() as executor:\n", + " # # Submit all the tasks to the executor and get the future objects\n", + " # futures = [executor.submit(train, input_proc) for input_proc in inputs]\n", + " # for future in cf.as_completed(futures):\n", + " # res=future.result()\n", + " pool = mp.Pool(processes=num_procs)\n", + " \n", + " outputs=pool.imap_unordered(train,inputs)\n", + " for output in outputs:\n", + " id,acceptable,strategy_name,agent_payoffs, adv_payoffs, expected_payoff=output\n", + " # id,acceptable,model_strategy,agent_payoffs, adv_payoffs, expected_payoff= train(inputs[0])\n", + " pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory)\n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=strategy_name, action_step=pricing_game.action_step,memory=memory)\n", + " # compute the payoff against all adv strategies, to be added to the matrix\n", + " if acceptable:\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] == 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + " results.append((acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff, base_agents[id]))\n", + " pool.close()\n", + " pool.join()\n", + " return results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f7392fe9-84d2-467d-b610-3936ca16878e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training low-cost agents with alg=, lr=0.0003, memory=12\n", + "training low-cost agents with alg=, lr=0.0003, memory=18\n", + "training low-cost agents with alg=, lr=0.0002, memory=12\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Observation spaces do not match: Box(0.0, 400.0, (38,), float32) != Box(0.0, 400.0, (26,), float32)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [9]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 85\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m mem_i,memory \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(memories):\n\u001b[0;32m 87\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtraining low-cost agents with alg=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mstr\u001b[39m(alg)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, lr=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlr\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, memory=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmemory\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m---> 89\u001b[0m results\u001b[38;5;241m=\u001b[39m \u001b[43mtrain_processes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menv_class\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43menv_class\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcosts\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mgl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mLOW_COST\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mHIGH_COST\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[0;32m 90\u001b[0m \u001b[43m \u001b[49m\u001b[43madv_mixed_strategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhigh_mixed_strat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_payoff\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mequi\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlow_cost_payoff\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[0;32m 91\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_procs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_procs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malg\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43malg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemory\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemory\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 92\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[0;32m 93\u001b[0m acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff,base_agent_name \u001b[38;5;241m=\u001b[39m result\n", + "Input \u001b[1;32mIn [8]\u001b[0m, in \u001b[0;36mtrain_processes\u001b[1;34m(db, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory)\u001b[0m\n\u001b[0;32m 15\u001b[0m results\u001b[38;5;241m=\u001b[39m[]\n\u001b[0;32m 16\u001b[0m \u001b[38;5;66;03m# with cf.ProcessPoolExecutor() as executor:\u001b[39;00m\n\u001b[0;32m 17\u001b[0m \u001b[38;5;66;03m# Submit all the tasks to the executor and get the future objects\u001b[39;00m\n\u001b[0;32m 18\u001b[0m \u001b[38;5;66;03m# futures = [executor.submit(train, input) for input_proc in inputs]\u001b[39;00m\n\u001b[0;32m 19\u001b[0m \u001b[38;5;66;03m# for future in cf.as_completed(futures):\u001b[39;00m\n\u001b[0;32m 20\u001b[0m \u001b[38;5;66;03m# id,acceptable,model_strategy,agent_payoffs, adv_payoffs, expected_payoff=future.result()\u001b[39;00m\n\u001b[1;32m---> 21\u001b[0m \u001b[38;5;28mid\u001b[39m,acceptable,model_strategy,agent_payoffs, adv_payoffs, expected_payoff\u001b[38;5;241m=\u001b[39m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 22\u001b[0m pricing_game \u001b[38;5;241m=\u001b[39m env_class(tuple_costs\u001b[38;5;241m=\u001b[39mcosts, adversary_mixed_strategy\u001b[38;5;241m=\u001b[39madv_strt, memory\u001b[38;5;241m=\u001b[39mmemory)\n\u001b[0;32m 23\u001b[0m \u001b[38;5;66;03m# compute the payoff against all adv strategies, to be added to the matrix\u001b[39;00m\n", + "Input \u001b[1;32mIn [7]\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(inputs)\u001b[0m\n\u001b[0;32m 21\u001b[0m base_agent_dir \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mgl\u001b[38;5;241m.\u001b[39mMODELS_DIR\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbase_agent\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 22\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m alg \u001b[38;5;129;01mis\u001b[39;00m SAC:\n\u001b[1;32m---> 23\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43malg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbase_agent_dir\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlearning_rate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 24\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtensorboard_log\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlog_dir\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mGAMMA\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_entropy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 25\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 26\u001b[0m model \u001b[38;5;241m=\u001b[39m alg\u001b[38;5;241m.\u001b[39mload(base_agent_dir, env, learning_rate\u001b[38;5;241m=\u001b[39mlr,\n\u001b[0;32m 27\u001b[0m verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, tensorboard_log\u001b[38;5;241m=\u001b[39mlog_dir, gamma\u001b[38;5;241m=\u001b[39mgl\u001b[38;5;241m.\u001b[39mGAMMA)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\stable_baselines3\\common\\base_class.py:716\u001b[0m, in \u001b[0;36mBaseAlgorithm.load\u001b[1;34m(cls, path, env, device, custom_objects, print_system_info, force_reset, **kwargs)\u001b[0m\n\u001b[0;32m 714\u001b[0m env \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_wrap_env(env, data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mverbose\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[0;32m 715\u001b[0m \u001b[38;5;66;03m# Check if given env is valid\u001b[39;00m\n\u001b[1;32m--> 716\u001b[0m \u001b[43mcheck_for_correct_spaces\u001b[49m\u001b[43m(\u001b[49m\u001b[43menv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mobservation_space\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43maction_space\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 717\u001b[0m \u001b[38;5;66;03m# Discard `_last_obs`, this will force the env to reset before training\u001b[39;00m\n\u001b[0;32m 718\u001b[0m \u001b[38;5;66;03m# See issue https://github.com/DLR-RM/stable-baselines3/issues/597\u001b[39;00m\n\u001b[0;32m 719\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m force_reset \u001b[38;5;129;01mand\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\stable_baselines3\\common\\utils.py:229\u001b[0m, in \u001b[0;36mcheck_for_correct_spaces\u001b[1;34m(env, observation_space, action_space)\u001b[0m\n\u001b[0;32m 217\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 218\u001b[0m \u001b[38;5;124;03mChecks that the environment has same spaces as provided ones. Used by BaseAlgorithm to check if\u001b[39;00m\n\u001b[0;32m 219\u001b[0m \u001b[38;5;124;03mspaces match after loading the model with given env.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 226\u001b[0m \u001b[38;5;124;03m:param action_space: Action space to check against\u001b[39;00m\n\u001b[0;32m 227\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 228\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m observation_space \u001b[38;5;241m!=\u001b[39m env\u001b[38;5;241m.\u001b[39mobservation_space:\n\u001b[1;32m--> 229\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mObservation spaces do not match: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobservation_space\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m != \u001b[39m\u001b[38;5;132;01m{\u001b[39;00menv\u001b[38;5;241m.\u001b[39mobservation_space\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 230\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m action_space \u001b[38;5;241m!=\u001b[39m env\u001b[38;5;241m.\u001b[39maction_space:\n\u001b[0;32m 231\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAction spaces do not match: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00maction_space\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m != \u001b[39m\u001b[38;5;132;01m{\u001b[39;00menv\u001b[38;5;241m.\u001b[39maction_space\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[1;31mValueError\u001b[0m: Observation spaces do not match: Box(0.0, 400.0, (38,), float32) != Box(0.0, 400.0, (26,), float32)" + ] + } + ], + "source": [ + "if __name__==\"__main__\":\n", + " env_class = ConPricingGame\n", + " gl.initialize()\n", + "\n", + " num_rounds = 3\n", + "\n", + " job_name = \"rnd_Mar11\"\n", + " db_name = job_name+\".db\"\n", + " db = cl.DataBase(db_name)\n", + " low_strts, high_strts=db.get_list_of_added_strategies()\n", + " cl.set_job_name(job_name)\n", + " # num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1])\n", + " num_procs = 6\n", + "\n", + "\n", + "\n", + " # changing params\n", + " lrs = [0.0003, 0.00016]\n", + " memories = [12,18]\n", + " # memories_agents=[[None]*len(memories)]*2\n", + " algs = [SAC]\n", + "\n", + " equilibria = []\n", + "\n", + " cl.create_directories()\n", + "\n", + " # strt1 = cl.Strategy(\n", + " # cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")\n", + " # strt2 = cl.Strategy(\n", + " # cl.StrategyType.static, model_or_func=cl.const, name=\"const\", first_price=132)\n", + " # strt3 = cl.Strategy(\n", + " # cl.StrategyType.static, model_or_func=cl.guess, name=\"guess\", first_price=132)\n", + " # strt4 = cl.Strategy(\n", + " # cl.StrategyType.static, model_or_func=cl.spe, name=\"spe\")\n", + "\n", + " train_env = env_class(tuple_costs=None, adversary_mixed_strategy=None, memory=12)\n", + " model_name=\"rnd_start\"\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + " model = SAC('MlpPolicy', train_env,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " # model.learn(total_timesteps=1, tb_log_name=model_name)\n", + " model.save(f\"{gl.MODELS_DIR}/{model_name}\")\n", + "\n", + " strt_rnd= cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=SAC, name=model_name, action_step=None,memory=12)\n", + "\n", + " bimatrix_game = cl.BimatrixGame(\n", + " low_cost_strategies=[strt_rnd]+low_strts, high_cost_strategies=[strt_rnd]+high_strts, env_class=env_class)\n", + "\n", + " bimatrix_game.reset_matrix()\n", + " bimatrix_game.fill_matrix()\n", + "\n", + "\n", + "\n", + " cl.prt(\"\\n\" + time.ctime(time.time())+\"\\n\"+(\"-\"*50)+\"\\n\")\n", + "\n", + " dictionaries = bimatrix_game.compute_equilibria()\n", + " game_size=bimatrix_game.size()\n", + "\n", + " # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria()\n", + " for round in range(num_rounds):\n", + " cl.prt(f\"Round {round} of {num_rounds}\")\n", + " \n", + " added_low=0\n", + " added_high=0\n", + " # for equilibrium in dictionaries:\n", + " for equi_i in range(len(dictionaries)):\n", + " new_equi_low = 0\n", + " new_equi_high = 0\n", + " equi = dictionaries[equi_i]\n", + " # low_prob_str = \", \".join(\n", + " # map(\"{0:.2f}\".format, equi[\"low_cost_probs\"]))\n", + " # high_prob_str = \", \".join(\n", + " # map(\"{0:.2f}\".format, equi[\"high_cost_probs\"]))\n", + " cl.prt(\n", + " f'equi: {str(equi[\"low_cost_support\"])}, {str(equi[\"high_cost_support\"])}\\n payoffs= {equi[\"low_cost_payoff\"]:.2f}, {equi[\"high_cost_payoff\"]:.2f}')\n", + " \n", + " # train a low-cost agent\n", + " high_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi[\"high_cost_probs\"]+([0]*added_high)) if \n", + " added_high> 0 else equi[\"high_cost_probs\"]))\n", + " \n", + " \n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for mem_i,memory in enumerate(memories):\n", + " \n", + " print(f'training low-cost agents with alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " results= train_processes(db=db, env_class=env_class, costs=[gl.LOW_COST, gl.HIGH_COST], \n", + " adv_mixed_strategy=high_mixed_strat, target_payoff=equi[\"low_cost_payoff\"], \n", + " num_procs=num_procs, alg=alg, lr=lr, memory=memory)\n", + " for result in results:\n", + " acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff,base_agent_name = result\n", + " if acceptable:\n", + " new_equi_low += 1\n", + " added_low+=1\n", + " bimatrix_game.low_strategies.append(agent_strategy)\n", + " bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs)\n", + " cl.prt(\n", + " f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " # train a high-cost agent\n", + " low_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.low_strategies, probablities_lst=\n", + " ((equi[\"low_cost_probs\"]+([0]*added_low)) if added_low > 0 else equi[\"low_cost_probs\"]))\n", + " \n", + " \n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for memory in memories:\n", + " print(f'training high-cost player with alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " results= train_processes(db=db, env_class=env_class, costs=[ gl.HIGH_COST,gl.LOW_COST],\n", + " adv_mixed_strategy=low_mixed_strat, target_payoff=equi[\"high_cost_payoff\"],\n", + " num_procs=num_procs, alg=alg, lr=lr, memory=memory)\n", + " for result in results:\n", + " acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff,base_agent_name = result \n", + " if acceptable:\n", + " new_equi_high += 1\n", + " added_high+=1\n", + " bimatrix_game.high_strategies.append(agent_strategy)\n", + " bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs)\n", + " \n", + " cl.prt(\n", + " f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name}, alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " if new_equi_high>0:\n", + " high_mixed_strat.strategy_probs+=[0]*new_equi_high\n", + " \n", + " # if new_equi_low>0 or new_equi_high>0:\n", + " # equilibria.append(\n", + " # [equi[\"low_cost_probs\"], equi[\"high_cost_probs\"], equi[\"low_cost_payoff\"], equi[\"high_cost_payoff\"]])\n", + " #to do: add the equilibria to the db\n", + " db.insert_new_equi(game_size=game_size, low_strategy_txt=str(low_mixed_strat),high_strategy_txt=str(high_mixed_strat), low_payoff=equi[\"low_cost_payoff\"], high_payoff=equi[\"high_cost_payoff\"], low_new_num=new_equi_low, high_new_num=new_equi_high)\n", + " \n", + " \n", + " if added_low==0 and added_high==0:\n", + " gl.N_EPISODES_BASE *= 1.1\n", + " gl.N_EPISODES_LOAD *= 1.1\n", + " else:\n", + " dictionaries = bimatrix_game.compute_equilibria()\n", + " game_size=bimatrix_game.size()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef372678-7225-48bc-8c31-2fad59bcc7c0", + "metadata": {}, + "outputs": [], + "source": [ + "# env=ConPricingGame(tuple_costs=[57,71], adversary_mixed_strategy= (cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")).to_mixed_strategy(), memory=3)\n", + "\n", + "# policy = (PPO.load(\"models/\"+\"NOV24-1700860722\", env=env)).predict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b98de76c-95c6-4052-b30b-4b63e49f1604", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/extend_game/changes/DO.py b/learningAgents/extend_game/changes/DO.py new file mode 100644 index 0000000..d9843ed --- /dev/null +++ b/learningAgents/extend_game/changes/DO.py @@ -0,0 +1,155 @@ + +import numpy as np +from stable_baselines3 import SAC, PPO +import time +from src.environments import ConPricingGame +import src.globals as gl +import src.classes as cl +import os + +def initial_matrix(env_class,random=False): + if not random: + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + # strt4 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.spe, name="spe") + init_low=[strt1, strt2, strt3] + init_high=[strt1, strt2, strt3] + else: + model_name=f"rndstart_{job_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + model_dir=f"{gl.MODELS_DIR}/{model_name}" + if not os.path.exists(f"{model_dir}.zip"): + train_env = env_class(tuple_costs=None, adversary_mixed_strategy=None, memory=12) + model = SAC('MlpPolicy', train_env, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + model.save(model_dir) + + strt_rnd= cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name=model_name, action_step=None,memory=12) + + init_low=[strt_rnd] + init_high=[strt_rnd] + + + low_strts, high_strts = db.get_list_of_added_strategies() + return cl.BimatrixGame( + low_cost_strategies=init_low+low_strts, high_cost_strategies=init_high+high_strts, env_class=env_class) + + +if __name__ == "__main__": + + gl.initialize() + + env_class = ConPricingGame + + num_rounds = 3 + num_procs = 3 + start_random=True + job_name = "Mar21" + + db_name = job_name+".db" + db = cl.DataBase(db_name) + cl.set_job_name(job_name) + cl.create_directories() + equilibria = [] + + # params + lrs = [0.0003, 0.00016] + memories = [12, 18] + algs = [SAC] + + start_game=initial_matrix(env_class=env_class, random=start_random) + + bimatrix_game = cl.load_latest_game(game_data_name=f"game_{job_name}", new_game=start_game) + + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + + dictionaries = bimatrix_game.compute_equilibria() + game_size = bimatrix_game.size() + + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + + added_low = 0 + added_high = 0 + # for equilibrium in dictionaries: + for equi_i in range(len(dictionaries)): + new_equi_low = 0 + new_equi_high = 0 + equi = dictionaries[equi_i] + # low_prob_str = ", ".join( + # map("{0:.2f}".format, equi["low_cost_probs"])) + # high_prob_str = ", ".join( + # map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: {str(equi["low_cost_support"])}, {str(equi["high_cost_support"])}\n payoffs= {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi["high_cost_probs"]+([0]*added_high)) if + added_high > 0 else equi["high_cost_probs"])) + + for alg in algs: + for lr in lrs: + for mem_i, memory in enumerate(memories): + + print(f'training low-cost agents with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + results = cl.train_processes(db=db, env_class=env_class, costs=[gl.LOW_COST, gl.HIGH_COST], + adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff, base_agent_name = result + if acceptable: + new_equi_low += 1 + added_low += 1 + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+([0]*added_low)) if added_low > 0 else equi["low_cost_probs"])) + + for alg in algs: + for lr in lrs: + for memory in memories: + print(f'training high-cost player with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + results = cl.train_processes(db=db, env_class=env_class, costs=[gl.HIGH_COST, gl.LOW_COST], + adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff, base_agent_name = result + if acceptable: + new_equi_high += 1 + added_high += 1 + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name}, alg={str(alg)}, lr={lr:.4f}, memory={memory}') + if new_equi_high > 0: + high_mixed_strat.strategy_probs += [0]*new_equi_high + + # if new_equi_low>0 or new_equi_high>0: + # equilibria.append( + # [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + # to do: add the equilibria to the db + db.insert_new_equi(game_size=game_size, low_strategy_txt=str(low_mixed_strat), high_strategy_txt=str( + high_mixed_strat), low_payoff=equi["low_cost_payoff"], high_payoff=equi["high_cost_payoff"], low_new_num=new_equi_low, high_new_num=new_equi_high) + + if added_low == 0 and added_high == 0: + gl.N_EPISODES_BASE *= 1.1 + gl.N_EPISODES_LOAD *= 1.1 + else: + dictionaries = bimatrix_game.compute_equilibria() + game_size = bimatrix_game.size() + dictionaries = bimatrix_game.compute_equilibria() \ No newline at end of file diff --git a/learningAgents/extend_game/changes/DO_old.py b/learningAgents/extend_game/changes/DO_old.py new file mode 100644 index 0000000..e3b89ce --- /dev/null +++ b/learningAgents/extend_game/changes/DO_old.py @@ -0,0 +1,282 @@ + +import numpy as np +from stable_baselines3 import SAC, PPO +# from stable_baselines3.common.env_util import make_vec_env +# from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys +from src.environments import ConPricingGame +import src.globals as gl +import src.classes as cl +import multiprocessing as mp + +def train(inputs): + """ traines one agent against the adversary, if the expected payoff of new agent is greater than expected payoff of NE, returns acceptable=true and the new strategy and payoff to be added to the strategies and matrix.""" + id,seed, job_name,env, base_agent, alg, adv_mixed_strategy,lr,target_payoff,db=inputs + + gl.initialize() + model_name = f"{job_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + acceptable = False + if base_agent is None: + number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + if alg is SAC: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0, seed=seed) + else: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA,seed=seed) + else: + number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + base_agent_dir = f"{gl.MODELS_DIR}/{base_agent}" + if alg is SAC: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + else: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + + # https://stable-baselines3.readthedocs.io/en/master/guide/examples.html#id3 + #check to save and load replay buffer as well + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=env.action_step,memory=env.memory) + + iter_rows = [] + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=env, adversary=adv_mixed_strategy.strategies[strategy_index])) + + #adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands + iter_row = cl.Iter_row(adv=env.adversary_strategy.name, agent_return=sum(env.profit[0]), adv_return=sum(env.profit[1]), rewards=str( + env.profit[0]), adv_rewards=str(env.profit[1]), actions=str(env.actions),prices=str(env.prices[0]), adv_prices=str(env.prices[1]) ,demands=str(env.demand_potential[0]), adv_demands=str(env.demand_potential[1])) + + iter_rows.append(iter_row) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + + acceptable=(expected_payoff > target_payoff) + # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time) + agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, env.costs[0], str( + adv_mixed_strategy), expected_payoff, target_payoff, str(alg),lr, env.memory, acceptable, env.action_step, seed, 1, running_time)) + #num_processes=1 because it just uses one process in training this agent + + if acceptable: + for row in iter_rows: + db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards, + row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands) + + return (id,acceptable,model_strategy.name,agent_payoffs, adv_payoffs, expected_payoff) + +def train_processes(db, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory): + """ + trains multiple agents with multiprocessing against mixed_adversary. + """ + inputs=[] + seed = int(time.time()) + adv_strt= adv_mixed_strategy.copy_unload() + + base_agents= cl.find_base_agents(db=db,alg=alg,memory=memory,cost=costs[0],mix_strt=adv_strt,size=num_procs) + + for p in range(num_procs): + env = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + input_proc=(p,seed+p, job_name,env, base_agents[p],alg, adv_strt,lr,target_payoff,db) + inputs.append(input_proc) + results=[] + # with cf.ProcessPoolExecutor() as executor: + # # Submit all the tasks to the executor and get the future objects + # futures = [executor.submit(train, input_proc) for input_proc in inputs] + # for future in cf.as_completed(futures): + # res=future.result() + pool = mp.Pool(processes=num_procs) + + outputs=pool.imap_unordered(train,inputs) + for output in outputs: + id,acceptable,strategy_name,agent_payoffs, adv_payoffs, expected_payoff=output + # id,acceptable,model_strategy,agent_payoffs, adv_payoffs, expected_payoff= train(inputs[0]) + pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=strategy_name, action_step=pricing_game.action_step,memory=memory) + # compute the payoff against all adv strategies, to be added to the matrix + if acceptable: + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + results.append((acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff, base_agents[id])) + pool.close() + pool.join() + return results + + +if __name__=="__main__": + env_class = ConPricingGame + gl.initialize() + + num_rounds = 3 + + job_name = "rnd_Mar11" + db_name = job_name+".db" + db = cl.DataBase(db_name) + low_strts, high_strts=db.get_list_of_added_strategies() + cl.set_job_name(job_name) + # num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + num_procs = 6 + + + + # changing params + lrs = [0.0003, 0.00016] + memories = [12,18] + # memories_agents=[[None]*len(memories)]*2 + algs = [SAC] + + equilibria = [] + + cl.create_directories() + + # strt1 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + # strt2 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + # strt3 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + # strt4 = cl.Strategy( + # cl.StrategyType.static, model_or_func=cl.spe, name="spe") + + train_env = env_class(tuple_costs=None, adversary_mixed_strategy=None, memory=12) + model_name="rnd_start" + log_dir = f"{gl.LOG_DIR}/{model_name}" + model = SAC('MlpPolicy', train_env, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + # model.learn(total_timesteps=1, tb_log_name=model_name) + model.save(f"{gl.MODELS_DIR}/{model_name}") + + strt_rnd= cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name=model_name, action_step=None,memory=12) + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt_rnd]+low_strts, high_cost_strategies=[strt_rnd]+high_strts, env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + + + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + + dictionaries = bimatrix_game.compute_equilibria() + game_size=bimatrix_game.size() + + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + + added_low=0 + added_high=0 + # for equilibrium in dictionaries: + for equi_i in range(len(dictionaries)): + new_equi_low = 0 + new_equi_high = 0 + equi = dictionaries[equi_i] + # low_prob_str = ", ".join( + # map("{0:.2f}".format, equi["low_cost_probs"])) + # high_prob_str = ", ".join( + # map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: {str(equi["low_cost_support"])}, {str(equi["high_cost_support"])}\n payoffs= {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi["high_cost_probs"]+([0]*added_high)) if + added_high> 0 else equi["high_cost_probs"])) + + + for alg in algs: + for lr in lrs: + for mem_i,memory in enumerate(memories): + + print(f'training low-cost agents with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + results= train_processes(db=db, env_class=env_class, costs=[gl.LOW_COST, gl.HIGH_COST], + adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff,base_agent_name = result + if acceptable: + new_equi_low += 1 + added_low+=1 + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst= + ((equi["low_cost_probs"]+([0]*added_low)) if added_low > 0 else equi["low_cost_probs"])) + + + for alg in algs: + for lr in lrs: + for memory in memories: + print(f'training high-cost player with alg={str(alg)}, lr={lr:.4f}, memory={memory}') + results= train_processes(db=db, env_class=env_class, costs=[ gl.HIGH_COST,gl.LOW_COST], + adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], + num_procs=num_procs, alg=alg, lr=lr, memory=memory) + for result in results: + acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff,base_agent_name = result + if acceptable: + new_equi_high += 1 + added_high+=1 + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent_name}, alg={str(alg)}, lr={lr:.4f}, memory={memory}') + if new_equi_high>0: + high_mixed_strat.strategy_probs+=[0]*new_equi_high + + # if new_equi_low>0 or new_equi_high>0: + # equilibria.append( + # [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + #to do: add the equilibria to the db + db.insert_new_equi(game_size=game_size, low_strategy_txt=str(low_mixed_strat),high_strategy_txt=str(high_mixed_strat), low_payoff=equi["low_cost_payoff"], high_payoff=equi["high_cost_payoff"], low_new_num=new_equi_low, high_new_num=new_equi_high) + + + if added_low==0 and added_high==0: + gl.N_EPISODES_BASE *= 1.1 + gl.N_EPISODES_LOAD *= 1.1 + else: + dictionaries = bimatrix_game.compute_equilibria() + game_size=bimatrix_game.size() \ No newline at end of file diff --git a/learningAgents/extend_game/changes/practice.py b/learningAgents/extend_game/changes/practice.py new file mode 100644 index 0000000..4038430 --- /dev/null +++ b/learningAgents/extend_game/changes/practice.py @@ -0,0 +1,4 @@ +import src.classes as cl + +A,B=cl.read_matrices_from_file("game_rnd_Feb5.txt") +print (f"A:\n{A}\n B:\n{B}") \ No newline at end of file diff --git a/learningAgents/extend_game/changes/src/bimatrix.py b/learningAgents/extend_game/changes/src/bimatrix.py new file mode 100644 index 0000000..870b57e --- /dev/null +++ b/learningAgents/extend_game/changes/src/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils as utils +import src.columnprint as columnprint +import src.lemke as lemke +import src.randomstart as randomstart +import random # random.seed +import src.classes as cl + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + cl.prt("\n all equilibria: \n") + for eq in sorted_trset: + cl.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/extend_game/changes/src/classes.py b/learningAgents/extend_game/changes/src/classes.py new file mode 100644 index 0000000..cca0ff6 --- /dev/null +++ b/learningAgents/extend_game/changes/src/classes.py @@ -0,0 +1,907 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +# from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix as bimatrix +import time +import os +import sqlite3 as sql +from collections import namedtuple +from stable_baselines3 import SAC, PPO +import copy +import pickle +import src.environments as envs +import multiprocessing as mp + + +class Iter_row: + def __init__(self, adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands): + self.adv = adv + self.agent_return = agent_return + self.adv_return = adv_return + self.rewards = rewards + self.adv_rewards = adv_rewards + self.actions = actions + self.prices = prices + self.adv_prices = adv_prices + self.demands = demands + self.adv_demands = adv_demands + + +class DataBase(): + + AgentRow = namedtuple( + "AgentRow", "name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, alg, lr, memory, added, action_step, seed, num_process, running_time") + + AGENTS_TABLE = "trained_agents" + ITERS_TABLE = "agents_iters" + EQUI_TABLE = "game_equilibria" + AGENTS_COLS = "id integer PRIMARY key AUTOINCREMENT,name text NOT NULL,base_agent text DEFAULT NULL,n_ep integer NOT NULL,cost integer NOT NULL,mixed_adv text NOT NULL,expected_payoff real,payoff_treshhold real,alg text NOT NULL,lr real NOT NULL,memory integer NOT NULL, action_step integer DEFAULT NULL,seed integer,num_procs integer DEFAULT 1,running_time integer, added integer,time text" + ITERS_COLS = "id integer PRIMARY key AUTOINCREMENT,agent_id integer NOT NULL,adv text NOT NULL,agent_return text,adv_return text,agent_rewards text,adv_rewards text,actions text,agent_prices text,adv_prices text, agent_demands text,adv_demands text" + EQUI_COLS = "id integer PRIMARY key AUTOINCREMENT,game_size text NOT NULL,low_strategy text NOT NULL,high_strategy NOT NULL,low_payoff real NOT NULL,high_payoff real NOT NULL, num_new_low real DEFAULT 0, num_new_high real DEFAULT 0,time text" + + def __init__(self, name="data.db") -> None: + self.db_name = name + self.reset() + + def reset(self): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.AGENTS_TABLE}({self.AGENTS_COLS});') + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.ITERS_TABLE}({self.ITERS_COLS});') + cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.EQUI_TABLE}({self.EQUI_COLS});') + connection.close() + + # def insert_new_agent(self, name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, lr, memory, added, action_step=None, seed=0, num_process=1, running_time=0): + def execute_insert_query(self, query): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute(query) + connection.commit() + last_id = cursor.lastrowid + connection.close() + return last_id + + def execute_select_query(self, query, fetch_one=False): + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + cursor.execute(query) + if fetch_one: + result = cursor.fetchone() + else: + result = cursor.fetchall() + return result + + def insert_new_agent(self, row): + """ + adds a new agent to db and returns the id + row: AgentRow named tuple + """ + query = f'INSERT INTO {self.AGENTS_TABLE} VALUES (NULL,\'{row.name}\',' + ('NULL' if (row.base_agent is None) else f'\'{row.base_agent}\'') + \ + f',{row.num_ep},{row.cost},\'{row.mixed_adv_txt}\',{row.expected_payoff},{row.payoff_treshhold},\"{row.alg}\",{row.lr},{row.memory},{("NULL" if row.action_step is None else row.action_step)},{row.seed},{row.num_process},{row.running_time},{int(row.added)},\'{ time.ctime(time.time())}\')' + # print(query) + return self.execute_insert_query(query=query) + + def insert_new_iteration(self, agent_id, adv_txt, agent_return, adv_return, agent_rewards_txt, adv_rewards_txt, actions_txt, agent_prices_txt, adv_prices_txt, + agent_demands_txt, adv_demands_txt): + """ + adds a new iteration to db and returns the id + """ + query = f'INSERT INTO {self.ITERS_TABLE} VALUES (NULL,{agent_id},\'{adv_txt}\',{agent_return},{adv_return},\'{agent_rewards_txt}\',\'{adv_rewards_txt}\',\ + \'{actions_txt}\',\'{agent_prices_txt}\',\'{adv_prices_txt}\',\'{agent_demands_txt}\',\'{adv_demands_txt}\')' + # print(query) + return self.execute_insert_query(query=query) + + def insert_new_equi(self, game_size, low_strategy_txt, high_strategy_txt, low_payoff, high_payoff, low_new_num, high_new_num): + """ + adds a new equilibrium to db and returns the id + """ + EQUI_COLS = "id integer PRIMARY key AUTOINCREMENT,game_size text NOT NULL,low_strategy text NOT NULL,high_strategy NOT NULL,low_payoff real NOT NULL,high_payoff real NOT NULL,low_new real DEFAULT 0,high_new real DEFAULT 0,time text" + query = f'INSERT INTO {self.EQUI_TABLE} VALUES (NULL,\'{str(game_size)}\',\'{low_strategy_txt}\',\'{high_strategy_txt}\',{low_payoff},{high_payoff},{low_new_num},{high_new_num}, \'{ time.ctime(time.time())}\')' + # print(query) + return self.execute_insert_query(query=query) + + def get_list_of_added_strategies(self): + """ returns two lists of low_cost and high_cost strategies """ + low_q = f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.LOW_COST})" + high_q = f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.HIGH_COST})" + low_lst = [] + high_lst = [] + + connection = sql.connect(self.db_name, timeout=10) + cursor = connection.cursor() + + cursor.execute(low_q) + low_all = cursor.fetchall() + for tup in low_all: + if tup[1] == str(SAC): + model = SAC + elif tup[1] == str(PPO): + model = PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [], [] + + low_lst.append(Strategy(strategy_type=StrategyType.sb3_model, model_or_func=model, + name=tup[0], memory=tup[2], action_step=tup[3])) + + cursor.execute(high_q) + high_all = cursor.fetchall() + for tup in high_all: + if tup[1] == str(SAC): + model = SAC + elif tup[1] == str(PPO): + model = PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [], [] + + high_lst.append(Strategy(strategy_type=StrategyType.sb3_model, model_or_func=model, + name=tup[0], memory=tup[2], action_step=tup[3])) + connection.close() + return low_lst, high_lst + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def size(self): + return (len(self.low_strategies), len(self.high_strategies)) + + def to_dict(self): + return { + 'low_strategies': [strt.to_dict() for strt in self.low_strategies], + 'high_strategies': [strt.to_dict() for strt in self.high_strategies], + 'env_class': self.env_class.__name__, + 'matrix_A': self.matrix_A, + 'matrix_B': self.matrix_B + } + + @classmethod + def from_dict(cls, data_dict): + + env_class = str_to_envclass(data_dict['env_class']) + low_strategies = [Strategy.from_dict(strt_data) for strt_data in data_dict['low_strategies']] + high_strategies = [Strategy.from_dict(strt_data) for strt_data in data_dict['high_strategies']] + + obj = cls(low_cost_strategies=low_strategies, high_cost_strategies=high_strategies, env_class=env_class) + obj.matrix_A = data_dict['matrix_A'] + obj.matrix_B = data_dict['matrix_B'] + return obj + + def save_game(self, file_name): + with open(f"{file_name}.pickle", "wb") as file: + pickle.dump(self.to_dict(), file) + + def load_game(file_name): + name = f"{file_name}.pickle" + if os.path.exists(name): + with open(name, "rb") as file: + instance_data = pickle.load(file) + return BimatrixGame.from_dict(instance_data) + else: + return None + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + strt_L = self.low_strategies[low_index] + strt_H = self.high_strategies[high_index] + strt_L.reset() + strt_H.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=strt_H.to_mixed_strategy(), memory=strt_L.memory) + payoffs = [strt_L.play_against(env, strt_H) + for _ in range(gl.NUM_MATRIX_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + game_name = f"game_{job_name}" + + self.save_game(game_name) + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"{game_name}.txt", "w") as out: + out.write(output) + + output += "\nlow-cost strategies: \n" + for strt in self.low_strategies: + output += f" {strt.name} " + output += "\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output += f" {strt.name} " + + with open(f"games/game_{job_name}_{int(time.time())}.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff, + "low_cost_support": low_cost_support, + "high_cost_support": high_cost_support + } + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can be models trained with sb3. + """ + type = None + env = None + name = None + memory = None + policy = None + model = None + first_price = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, memory=0, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.memory = memory + + self.action_step = action_step + + if strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def __str__(self) -> str: + return f"{self.name}:{self.memory},{self.action_step}" + + def reset(self): + pass + + def to_dict(self): + return { + 'type': self.type, + 'name': self.name, + 'model_or_func': (self.model if self.type == StrategyType.sb3_model else self.policy), + 'first_price': self.first_price, + 'memory': self.memory, + 'action_step': self.action_step + } + + @classmethod + def from_dict(cls, data_dict): + return cls(strategy_type=data_dict['type'], model_or_func=data_dict['model_or_func'], name=data_dict['name'], first_price=data_dict['first_price'], memory=data_dict['memory'], action_step=data_dict['action_step']) + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.sb3_model: + if self.policy is None: + if env.memory != self.memory: + env_new = (env.__class__)(tuple_costs=env.costs, + adversary_mixed_strategy=env.adversary_mixed_strategy, memory=self.memory) + # env_new shouldn't it be multi level? + self.policy = (self.model.load(self.dir, env=env_new)).predict + else: + self.policy = (self.model.load(self.dir, env=env)).predict + state = env.get_state( + stage=env.stage, player=player, memory=self.memory) + action, _ = self.policy(state) + # compute price for co model and disc model + price = (env.myopic(player)-action[0]) if (self.action_step is None) else ( + env.myopic(player)-(self.action_step*action)) + + if player == 0: + env.actions[env.stage] = (action[0] if ( + self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy = adversary.to_mixed_strategy() + + state, _ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size = support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + if len(self.strategies) != len(self.strategy_probs): + print(len(self.strategies)) + print(self.strategy_probs) + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + def reduce(self): + """ only keeps the strategies with positive probablity, returns a new mixed strategy""" + strts = [] + probs = [] + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + strts.append(self.strategies[i]) + probs.append(self.strategy_probs[i]) + return MixedStrategy(strategies_lst=strts, probablities_lst=probs) + + def copy_unload(self): + """a copy of strategies with models not loaded, returns a mixed strategy """ + strts = [] + probs = [] + for i in range(len(self.strategies)): + strt = copy.deepcopy(self.strategies[i]) + if self.strategies[i].type == StrategyType.sb3_model: + strt.policy = None + strts.append(strt) + probs.append(self.strategy_probs[i]) + + return MixedStrategy(strategies_lst=strts, probablities_lst=probs) + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def spe(env, player, firstprice=0): + """ + returns the subgame perfect equilibrium price + """ + t = env.stage + P = gl.SPE_a[t]*(env.demand_potential[player][t]-200) + gl.SPE_b[t] + gl.SPE_k[t]*(env.costs[player]-64) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt', 'a') as file: + file.write("\n"+string) + + +# def write_to_excel(file_name, new_row): +# """ +# row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time +# """ + +# path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + +# wb = load_workbook(path) +# sheet = wb.active +# row = 2 +# col = 1 +# sheet.insert_rows(idx=row) + +# for i in range(len(new_row)): +# sheet.cell(row=row, column=col+i).value = new_row[i] +# wb.save(path) + + +# def write_results(new_row): +# write_to_excel(f'results_{job_name}.xlsx', new_row) + + +# def write_agents(new_row): +# # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ +# # gamma seed num_procs running_time date + +# write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.GAMES_DIR): + os.makedirs(gl.GAMES_DIR) + + +def set_job_name(name): + global job_name + job_name = name + + +def find_base_agents(db, alg, memory, cost, mix_strt, size): + """ the startegies should be the same class of agents as we are training. if low cost then low-cost strategies should be given to find similar ones. The trained agents that are not even added will be considered """ + strats = copy.deepcopy(mix_strt.strategies) + probs = copy.deepcopy(mix_strt.strategy_probs) + cands = [None] + cand_w = [1.00] + for i in range(len(probs)-1): + for j in range(i+1, len(probs)): + if probs[i] < probs[j]: + strats[i], strats[j] = strats[j], strats[i] + probs[i], probs[j] = probs[j], probs[i] + for st in strats: + if st.type == StrategyType.sb3_model and memory == st.memory and (alg is st.model): + cands.append(st.name) + cand_w.append(2.00) + + query = f'SELECT name FROM {DataBase.AGENTS_TABLE} WHERE cost={cost} and memory={memory} and alg=\"{str(alg)}\" ORDER BY id DESC LIMIT {(size-len(cands))}' + + tmps = db.execute_select_query(query=query) + if tmps is not None: + for tmp in tmps: + cands.append(tmp[0]) + cand_w.append(1.00) + cand_w = np.array(cand_w) + cand_w /= sum(cand_w) + agents = np.random.choice(np.array(cands), size, replace=True, p=cand_w) + return agents + + +def read_matrices_from_file(file_name): + lines = [*open(file=file_name)] + size = tuple(int(num) for num in lines[0].split()) + matrix_A = np.zeros(size) + matrix_B = np.zeros(size) + + for i in range(2, 2+size[0]): + matrix_A[i-2] = [float(num) for num in lines[i].split()] + for i in range(3+size[0], 3+2*size[0]): + matrix_B[i-3-size[0]] = [float(num) for num in lines[i].split()] + + return matrix_A, matrix_B + + +def load_latest_game(game_data_name, new_game): + """ loads the game from game_data file and adds the extra strategies from new_game that were not saved in the data file and should be in the game""" + + old_game = BimatrixGame.load_game(game_data_name) + if old_game is None: # no data to load + new_game.reset_matrix() + new_game.fill_matrix() + return new_game + else: + new_lows = new_game.low_strategies + new_highs = new_game.high_strategies + + low_trained_i = 0 + while low_trained_i < len(old_game.low_strategies) and old_game.low_strategies[low_trained_i].type != StrategyType.sb3_model: + low_trained_i += 1 + + low_new_trained_i = 0 + while low_new_trained_i < len(new_lows) and new_lows[low_new_trained_i].type != StrategyType.sb3_model: + low_new_trained_i += 1 + + low_extra_start = len(old_game.low_strategies) - low_trained_i-1 + low_new_trained_i + # low_extra_start shows index of 1st low strategy that is not in the previous saved game, all strategies after this index should be added to the game + while low_extra_start >= 0 and (new_lows[low_extra_start].name != old_game.low_strategies[-1].name): + low_extra_start -= 1 + + for i in range(low_extra_start+1, len(new_lows)): + old_game.low_strategies.append(new_lows[i]) + n = len(old_game.high_strategies) + old_game.add_low_cost_row(np.zeros(n), np.zeros(n)) + for j in range(len(old_game.high_strategies)): + old_game.update_matrix_entry((len(old_game.low_strategies)-1), j) + + high_trained_i = 0 + while high_trained_i < len(old_game.high_strategies) and old_game.high_strategies[high_trained_i].type != StrategyType.sb3_model: + high_trained_i += 1 + + high_new_trained_i = 0 + while high_new_trained_i < len(new_highs) and new_highs[high_new_trained_i].type != StrategyType.sb3_model: + high_new_trained_i += 1 + + high_extra_start = len(old_game.high_strategies) - high_trained_i-1 + high_new_trained_i + # low_extra_start shows index of 1st low strategy that is not in the previous saved game, all strategies after this index should be added to the game + while high_extra_start >= 0 and (new_highs[high_extra_start].name != old_game.high_strategies[-1].name): + high_extra_start -= 1 + + for i in range(high_extra_start+1, len(new_highs)): + old_game.high_strategies.append(new_highs[i]) + n = len(old_game.low_strategies) + old_game.add_high_cost_col(np.zeros(n), np.zeros(n)) + for j in range(len(old_game.low_strategies)): + old_game.update_matrix_entry(j, (len(old_game.high_strategies)-1)) + + return old_game + + +def str_to_envclass(s): + if s == envs.ConPricingGame.__name__: + return envs.ConPricingGame + elif s == envs.DisPricingGame.__name__: + return envs.DisPricingGame + else: + return None + + +def train(inputs): + """ traines one agent against the adversary, if the expected payoff of new agent is greater than expected payoff of NE, returns acceptable=true and the new strategy and payoff to be added to the strategies and matrix.""" + id, seed, job_name, env, base_agent, alg, adv_mixed_strategy, lr, target_payoff, db = inputs + + gl.initialize() + + model_name = f"{job_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + acceptable = False + if base_agent is None: + number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + if alg is SAC: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0, seed=seed) + else: + model = alg('MlpPolicy', env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, seed=seed) + else: + number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1)) + base_agent_dir = f"{gl.MODELS_DIR}/{base_agent}" + if alg is SAC: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + else: + model = alg.load(base_agent_dir, env, learning_rate=lr, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + + # https://stable-baselines3.readthedocs.io/en/master/guide/examples.html#id3 + # check to save and load replay buffer as well + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + model_strategy = Strategy(strategy_type=StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=env.action_step, memory=env.memory) + + iter_rows = [] + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=env, adversary=adv_mixed_strategy.strategies[strategy_index])) + + # adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands + iter_row = Iter_row(adv=env.adversary_strategy.name, agent_return=sum(env.profit[0]), adv_return=sum(env.profit[1]), rewards=str( + env.profit[0]), adv_rewards=str(env.profit[1]), actions=str(env.actions), prices=str(env.prices[0]), adv_prices=str(env.prices[1]), demands=str(env.demand_potential[0]), adv_demands=str(env.demand_potential[1])) + + iter_rows.append(iter_row) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + + acceptable = (expected_payoff > target_payoff) + # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time) + agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, env.costs[0], str( + adv_mixed_strategy), expected_payoff, target_payoff, str(alg), lr, env.memory, acceptable, env.action_step, seed, 1, running_time)) + # num_processes=1 because it just uses one process in training this agent + + if acceptable: + for row in iter_rows: + db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards, + row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands) + + return (id, acceptable, model_strategy.name, agent_payoffs, adv_payoffs, expected_payoff) + + +def train_processes(db, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory): + """ + trains multiple agents with multiprocessing against mixed_adversary. + """ + inputs = [] + seed = int(time.time()) + adv_strt = adv_mixed_strategy.copy_unload() + + base_agents = find_base_agents(db=db, alg=alg, memory=memory, cost=costs[0], mix_strt=adv_strt, size=num_procs) + + for p in range(num_procs): + env = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + input_proc = (p, seed+p, job_name, env, base_agents[p], alg, adv_strt, lr, target_payoff, db) + inputs.append(input_proc) + results = [] + + pool = mp.Pool(processes=num_procs) + + outputs = pool.imap_unordered(train, inputs) + for output in outputs: + id, acceptable, strategy_name, agent_payoffs, adv_payoffs, expected_payoff = output + # id,acceptable,strategy_name,agent_payoffs, adv_payoffs, expected_payoff= train(inputs[0]) + pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_strt, memory=memory) + model_strategy = Strategy(strategy_type=StrategyType.sb3_model, + model_or_func=alg, name=strategy_name, action_step=pricing_game.action_step, memory=memory) + # compute the payoff against all adv strategies, to be added to the matrix + if acceptable: + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + results.append((acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff, base_agents[id])) + pool.close() + pool.join() + return results diff --git a/learningAgents/extend_game/changes/src/columnprint.py b/learningAgents/extend_game/changes/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/extend_game/changes/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/extend_game/changes/src/doubleoracle.py b/learningAgents/extend_game/changes/src/doubleoracle.py new file mode 100644 index 0000000..453a56e --- /dev/null +++ b/learningAgents/extend_game/changes/src/doubleoracle.py @@ -0,0 +1,13 @@ +from enum import Enum +import numpy as np +import classes as cl + +class DoubleOracle(): + """ + this class is the data structure to represent the double oracle which is a bimatrix game with low-cost and high-cost strategies are trained and added to it based on the Nash equilibrium. + + """ + def __init__(self): + cl.create_directories() + + diff --git a/learningAgents/extend_game/changes/src/environments.py b/learningAgents/extend_game/changes/src/environments.py new file mode 100644 index 0000000..d2e1ee3 --- /dev/null +++ b/learningAgents/extend_game/changes/src/environments.py @@ -0,0 +1,184 @@ +# In this env, in the state representation, the memory og both agent and adversary will be given. the length of memory is specified with variable memory + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl + +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__() + # gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + #memory of both players + self.memory=memory + # self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(2+2*memory,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, memory=None): + # [stage, our demand, our price memory, adv price memory] + + mem_len = memory if ( + memory is not None) else self.memory + + + stage_part = [stage] + self_mem=[] + adv_mem=[] + + if stage == 0: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + observation = stage_part+[self.demand_potential[player][self.stage]] + self_mem+ adv_mem + else: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + j = mem_len-1 + for i in range(stage-1, max(-1, stage-1-mem_len), -1): + adv_mem[j] = self.prices[1-player][i] + self_mem[j] = self.prices[player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player][self.stage]]+ self_mem+ adv_mem + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__(tuple_costs, adversary_mixed_strategy,memory) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + diff --git a/learningAgents/extend_game/changes/src/globals.py b/learningAgents/extend_game/changes/src/globals.py new file mode 100644 index 0000000..0090488 --- /dev/null +++ b/learningAgents/extend_game/changes/src/globals.py @@ -0,0 +1,73 @@ +import numpy as np + + +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, GAMMA, NUM_ACTIONS, REWARDS_DIVISION_CONST + global NUM_STOCHASTIC_ITER, NUM_MATRIX_ITER, N_EPISODES_BASE, N_EPISODES_LOAD, EPISODE_INCREASE_PORTION + # global REPLAY_BUFFER_SIZE, PROB_BREAK_LIMIT_LN, CONVERGE_BREAK, PRINT_STEP,NUM_ADV_HISTORY, LR,ACTION_STEP + # global BATCH_UPDATE_SIZE, BUFFER_PLAY_COEFFICIENT, NUM_PROCESS, NUM_MODEL_SAVE + global CON_ACTIONS_RANGE, MODELS_DIR, LOG_DIR, NUM_TRACE_EQUILIBRIA, GAMES_DIR, NUM_PROCESS + # global SPE_A, SPE_a, SPE_B, SPE_b, SPE_K, SPE_k, SPE_z, SPE_Y + + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE = 60 + # ACTION_STEP = 3 + + REWARDS_DIVISION_CONST = 1000 + + N_EPISODES_BASE = 2_50 + N_EPISODES_LOAD = 1_00 + NUM_STOCHASTIC_ITER = 2 + NUM_MATRIX_ITER = 2 + # NUM_STOCHASTIC_ITER = 100 + # NUM_MATRIX_ITER = 100 + # N_EPISODES_BASE = 2_000_000 + # N_EPISODES_LOAD = 800_000 + EPISODE_INCREASE_PORTION = 0.3 + + # NUM_EPISODES_RESET = NUM_EPISODES + + NUM_TRACE_EQUILIBRIA = 2 + # #HOW OFTEN THE MODEL SHOULD BE SAVED. + # NUM_MODEL_SAVE=3 + + NUM_PROCESS = 6 + + MODELS_DIR = "models" + LOG_DIR = "logs" + GAMES_DIR = "games" + + # SPE coefficients + + # SPE_a = [np.nan]*25 + # SPE_A = [np.nan]*25 + # SPE_b = [np.nan]*25 + # SPE_B = [np.nan]*25 + # SPE_k = [np.nan]*25 + # SPE_K = [np.nan]*25 + # SPE_z = [np.nan]*25 + # SPE_Y = [np.nan]*25 + + # SPE_a[24] = 0.5 + # SPE_A[24] = 0.25 + # SPE_b[24] = 132 + # SPE_B[24] = 68 + # SPE_k[24] = 0.5 + # SPE_K[24] = -0.5 + # SPE_Y[24] = 0.25 * GAMMA + + # for t in range(23, -1, -1): + # SPE_a[t] = (1-SPE_Y[t+1])/(2-SPE_Y[t+1]) + # SPE_z[t] = GAMMA*(0.75-0.5*SPE_a[t]) + # SPE_k[t] = (1-0.5*GAMMA*SPE_K[t+1])/(2-SPE_Y[t+1]) + # SPE_K[t] = -0.5 + SPE_z[t]*(SPE_K[t+1]-2*SPE_A[t+1]*SPE_k[t]) + # SPE_A[t] = 0.25 + SPE_z[t]*SPE_A[t+1]*(1-SPE_a[t]) + # SPE_b[t] = 132 - 0.25*GAMMA*SPE_B[t+1] + # SPE_B[t] = 68 + SPE_z[t]*SPE_B[t+1] + # SPE_Y[t] = 0.25*GAMMA + SPE_z[t]*(1-SPE_a[t])*SPE_Y[t+1] diff --git a/learningAgents/extend_game/changes/src/lemke.py b/learningAgents/extend_game/changes/src/lemke.py new file mode 100644 index 0000000..afb0921 --- /dev/null +++ b/learningAgents/extend_game/changes/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint as columnprint +import src.utils as utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0].out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s == "-v" or s == "-verbose": + verbose = True + elif s == "-s" or s == "-silent": + silent = True + elif s == "-z0": + z0 = True + elif s[0] == "-": + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + + + # creae LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, it): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout( "lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]* = + self.d = [0]*n + needfracs = n*n + 2*n + if len(words != needfacs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs," fr actions, got", len(words)-5) + exi t(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 == + s el f.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 == + s el f.q = utils.tovector(n,words,k) + k+=n + elif wo rds[k]=="d=": + k+=1 == + s el f.d = utils.tovector(n,words,k) + k+=n + else: + pintout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q = self.q + d = self.d + m = = columnprint.columnprint(n) + m = makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m. sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +classu: + # filling the tableau from the LCP instance Mqd + + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = []*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinan = 1 + self.lextested = [0]*(n+1) + self.lexcompa = isons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + == n = Mqd.q[i].denominator + else: + de == = Mq d.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif == ==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: == + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa" ) # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichv ar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = st r(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "----------------end of tableau-----------------" + return out + + def vartoa(self , v): # variable as as string w1..wn or z0..zn + if (v > sel f.n): + return "w"+str(v-self.n) +else: + return "z"+s tr(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is no nbasic + self.solution[i]=fractions.Fration(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n = + sol.sprint("basis=") + for i in rang e(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info "Cob asic variable", self.vartoa(v), + "shouldbe basic") + exit(1) + return + + def assertcobasi(self, v, info): # assert that v is cobasic + if (self .bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(sef, leave, enter): # leave, enter in VARS + self.ass ertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout(s) + returnt("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in ran ge(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobs[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return == + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + prntout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lex t[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.spr int(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave idicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecad == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as ther == is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j omitted from statistics: only one possible row + i eans no .in-ratio test needed for leaving varia + # T is basic, or equal to the entering variable. + j =going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+ 1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + == newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # comp are ratios via products + tmp1 = Anewcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][c] + # sgn =np.sign(tmp1- tmp2) + # if sgn==0: + if tmp1 == tm p2 : # new ratiois the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand f in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n ] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check i f z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in ra nge(self.n): + self.A[i][col] = - == lf.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, +vot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with poitive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in ran ge(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot 1; + flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binter ac t = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtai n lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flgs.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/extend_game/changes/src/utils.py b/learningAgents/extend_game/changes/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/extend_game/changes/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/extend_game/src_last/DO.ipynb b/learningAgents/extend_game/src_last/DO.ipynb new file mode 100644 index 0000000..4bf0ed9 --- /dev/null +++ b/learningAgents/extend_game/src_last/DO.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2905d491-8924-44ef-9521-e76a35dce019", + "metadata": {}, + "outputs": [], + "source": [ + "# added SPE to the base strategies at first, then deleted" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dea34fbb-ece9-4c29-9b1b-ef758f09668f", + "metadata": {}, + "outputs": [], + "source": [ + "import gymnasium as gym\n", + "from gymnasium import spaces\n", + "import numpy as np\n", + "from stable_baselines3 import SAC, PPO\n", + "from stable_baselines3.common.env_util import make_vec_env\n", + "from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv\n", + "import time\n", + "import sys\n", + "from src.environments import ConPricingGame\n", + "import src.globals as gl\n", + "import src.classes as cl" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3ca76fb0-453a-409b-ad83-b6d4196f62b8", + "metadata": {}, + "outputs": [], + "source": [ + "class Iter_row:\n", + " def __init__(self, adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands):\n", + " self.adv = adv\n", + " self.agent_return = agent_return\n", + " self.adv_return = adv_return\n", + " self.rewards = rewards\n", + " self.adv_rewards = adv_rewards\n", + " self.actions = actions\n", + " self.prices = prices\n", + " self.adv_prices = adv_prices\n", + " self.demands = demands\n", + " self.adv_demands = adv_demands" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd831764-040c-4580-a8a0-6fc9986b3b04", + "metadata": {}, + "outputs": [], + "source": [ + "def find_base_agent(db,alg, memory, cost, strategies, strategy_probs):\n", + " \"\"\" the startegies should be the same class of agents as we are training. if low cost then low-cost strategies should be given to find similar ones. The trained agents that are not even added will be considered \"\"\"\n", + " strats=strategies.copy()\n", + " probs=strategy_probs.copy()\n", + " for i in range(len(probs)-1):\n", + " for j in range(i+1,len(probs)):\n", + " if probs[i]< probs[j]:\n", + " strats[i],strats[j] = strats[j], strats[i]\n", + " probs[i],probs[j] = probs[j], probs[i]\n", + " for st in strats:\n", + " if st.type==cl.StrategyType.sb3_model and memory == st.memory and (alg is st.model) :\n", + " return st.name\n", + " query=f'SELECT name FROM {cl.DataBase.AGENTS_TABLE} WHERE cost={cost} and memory={memory} and alg=\\\"{str(alg)}\\\" ORDER BY id DESC'\n", + " db.cursor.execute(query)\n", + " tmp= db.cursor.fetchone()\n", + " if tmp is not None:\n", + " return tmp[0]\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "286f8903-6ec8-4c8e-8868-a7da4d67bf77", + "metadata": {}, + "outputs": [], + "source": [ + "def training(db,base_agent, env_class, costs, adv_mixed_strategy, target_payoff, num_procs, alg, lr, memory):\n", + " \"\"\"\n", + " trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \\\n", + " returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix.\n", + " \"\"\"\n", + " \n", + "\n", + " acceptable = False\n", + "\n", + " pricing_game = env_class(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy, memory=memory)\n", + "\n", + " seed = int(time.time())\n", + "\n", + " model_name = f\"{job_name}-{str(seed)}\"\n", + " models_dir = f\"{gl.MODELS_DIR}/{model_name}\"\n", + "\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + "\n", + " # if not os.path.exists(models_dir):\n", + " # os.makedirs(models_dir)\n", + "\n", + " # if not os.path.exists(log_dir):\n", + " # os.makedirs(log_dir)\n", + "\n", + " # number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \\\n", + " # (adv_mixed_strategy.support_size-1)\n", + " # train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict(\n", + " # tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy, memory=memory))\n", + "\n", + " train_env = env_class(tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy, memory=memory)\n", + " seed=0\n", + " if base_agent is None:\n", + " number_episodes = gl.N_EPISODES_BASE * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " if alg is SAC:\n", + " model = alg('MlpPolicy', train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " else:\n", + " model = alg('MlpPolicy', train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA)\n", + " else:\n", + " number_episodes = gl.N_EPISODES_LOAD * (1 + gl.EPISODE_INCREASE_PORTION * (adv_mixed_strategy.support_size-1))\n", + " base_agent_dir = f\"{gl.MODELS_DIR}/{base_agent}\"\n", + " if alg is SAC:\n", + " model = alg.load(base_agent_dir, train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + " else:\n", + " model = alg.load(base_agent_dir, train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA)\n", + "\n", + " start = time.time()\n", + " # for i in range(gl.NUM_MODEL_SAVE):\n", + " # tmp = (number_episodes/gl.NUM_MODEL_SAVE)\n", + " # model.learn(total_timesteps=tmp, reset_num_timesteps=False,\n", + " # tb_log_name=model_name)\n", + " # model.save(os.path.join(models_dir, str(tmp*(i+1))))\n", + " model.learn(total_timesteps=number_episodes, tb_log_name=model_name)\n", + " model.save(models_dir)\n", + " running_time = time.time() - start\n", + "\n", + " agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies))\n", + " expected_payoff = 0\n", + "\n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=model_name, action_step=pricing_game.action_step,memory=memory)\n", + " iter_rows = []\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] > 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " # returns = algorithm.play_trained_agent(adversary=(\n", + " # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter)\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " \n", + " #adv, agent_return, adv_return, rewards, adv_rewards, actions, prices, adv_prices, demands, adv_demands\n", + " iter_row = Iter_row(adv=pricing_game.adversary_strategy.name, agent_return=sum(pricing_game.profit[0]), adv_return=sum(pricing_game.profit[1]), rewards=str(\n", + " pricing_game.profit[0]), adv_rewards=str(pricing_game.profit[1]), actions=str(pricing_game.actions),prices=str(pricing_game.prices[0]), adv_prices=str(pricing_game.prices[1]) ,demands=str(pricing_game.demand_potential[0]), adv_demands=str(pricing_game.demand_potential[1]))\n", + "\n", + " iter_rows.append(iter_row)\n", + "\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + " expected_payoff += (agent_payoffs[strategy_index]) * \\\n", + " (adv_mixed_strategy.strategy_probs[strategy_index])\n", + "\n", + " acceptable = (expected_payoff > target_payoff)\n", + " # agent_id=db.insert_new_agent(model_name,number_episodes,costs[0], str(adv_mixed_strategy), expected_payoff,target_payoff, lr,memory, acceptable, pricing_game.action_step, seed,num_procs,running_time)\n", + " agent_id = db.insert_new_agent(db.AgentRow(model_name, base_agent, number_episodes, costs[0], str(\n", + " adv_mixed_strategy), expected_payoff, target_payoff, str(alg),lr, memory, acceptable, pricing_game.action_step, seed, num_procs, running_time))\n", + "\n", + " if expected_payoff > target_payoff:\n", + " acceptable = True\n", + " for row in iter_rows:\n", + " db.insert_new_iteration(agent_id, row.adv, row.agent_return, row.adv_return, row.rewards,\n", + " row.adv_rewards, row.actions, row.prices, row.adv_prices, row.demands, row.adv_demands)\n", + " # compute the payoff against all adv strategies, to be added to the matrix\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] == 0:\n", + " payoffs = []\n", + " for _ in range(gl.NUM_STOCHASTIC_ITER):\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " mean_payoffs = np.array(payoffs).mean(axis=0)\n", + "\n", + " agent_payoffs[strategy_index] = mean_payoffs[0]\n", + " adv_payoffs[strategy_index] = mean_payoffs[1]\n", + "\n", + " return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7392fe9-84d2-467d-b610-3936ca16878e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training low-cost player with base=rnd_start ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=None ,alg=, lr=0.0003, memory=18\n", + "training low-cost player with base=rnd_start ,alg=, lr=0.0002, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707144365 ,alg=, lr=0.0002, memory=18\n", + "training low-cost player with base=None ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=None ,alg=, lr=0.0003, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707205022 ,alg=, lr=0.0002, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707206605 ,alg=, lr=0.0002, memory=18\n", + "training high-cost player with base=rnd_start ,alg=, lr=0.0003, memory=12\n", + "training high-cost player with base=None ,alg=, lr=0.0003, memory=18\n", + "training high-cost player with base=rnd_start ,alg=, lr=0.0002, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707221671 ,alg=, lr=0.0002, memory=18\n", + "training high-cost player with base=None ,alg=, lr=0.0003, memory=12\n", + "training high-cost player with base=None ,alg=, lr=0.0003, memory=18\n", + "training high-cost player with base=rnd_Feb5-1707278881 ,alg=, lr=0.0002, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707280464 ,alg=, lr=0.0002, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707131275 ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707144365 ,alg=, lr=0.0003, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707131275 ,alg=, lr=0.0002, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707144365 ,alg=, lr=0.0002, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707208214 ,alg=, lr=0.0003, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707208848 ,alg=, lr=0.0003, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707340780 ,alg=, lr=0.0002, memory=12\n", + "training low-cost player with base=rnd_Feb5-1707341412 ,alg=, lr=0.0002, memory=18\n", + "training high-cost player with base=rnd_Feb5-1707209491 ,alg=, lr=0.0003, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707221671 ,alg=, lr=0.0003, memory=18\n", + "training high-cost player with base=rnd_Feb5-1707209491 ,alg=, lr=0.0002, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707221671 ,alg=, lr=0.0002, memory=18\n", + "training high-cost player with base=rnd_Feb5-1707278881 ,alg=, lr=0.0003, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707280464 ,alg=, lr=0.0003, memory=18\n", + "training high-cost player with base=rnd_Feb5-1707278881 ,alg=, lr=0.0002, memory=12\n", + "training high-cost player with base=rnd_Feb5-1707280464 ,alg=, lr=0.0002, memory=18\n", + "training low-cost player with base=rnd_Feb5-1707131275 ,alg=, lr=0.0003, memory=12\n" + ] + } + ], + "source": [ + "env_class = ConPricingGame\n", + "gl.initialize()\n", + "\n", + "num_rounds = 50\n", + "\n", + "job_name = \"rnd_Feb5\"\n", + "db_name = job_name+\".db\"\n", + "db = cl.DataBase(db_name)\n", + "low_strts, high_strts=db.get_list_of_added_strategies()\n", + "cl.set_job_name(job_name)\n", + "# num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1])\n", + "num_procs = 7\n", + "\n", + "\n", + "\n", + "# changing params\n", + "lrs = [0.0003, 0.00016]\n", + "memories = [12,18]\n", + "# memories_agents=[[None]*len(memories)]*2\n", + "algs = [SAC,PPO]\n", + "\n", + "equilibria = []\n", + "\n", + "cl.create_directories()\n", + "\n", + "# strt1 = cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")\n", + "# strt2 = cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.const, name=\"const\", first_price=132)\n", + "# strt3 = cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.guess, name=\"guess\", first_price=132)\n", + "# strt4 = cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.spe, name=\"spe\")\n", + "\n", + "train_env = env_class(tuple_costs=None, adversary_mixed_strategy=None, memory=12)\n", + "model_name=\"rnd_start\"\n", + "log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + "model = SAC('MlpPolicy', train_env,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + "# model.learn(total_timesteps=1, tb_log_name=model_name)\n", + "model.save(f\"{gl.MODELS_DIR}/{model_name}\")\n", + "\n", + "strt_rnd= cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=SAC, name=model_name, action_step=None,memory=12)\n", + "\n", + "bimatrix_game = cl.BimatrixGame(\n", + " low_cost_strategies=[strt_rnd]+low_strts, high_cost_strategies=[strt_rnd]+high_strts, env_class=env_class)\n", + "\n", + "bimatrix_game.reset_matrix()\n", + "bimatrix_game.fill_matrix()\n", + "\n", + "\n", + "\n", + "cl.prt(\"\\n\" + time.ctime(time.time())+\"\\n\"+(\"-\"*50)+\"\\n\")\n", + "\n", + "dictionaries = bimatrix_game.compute_equilibria()\n", + "\n", + "# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria()\n", + "for round in range(num_rounds):\n", + " cl.prt(f\"Round {round} of {num_rounds}\")\n", + " \n", + " added_low=0\n", + " added_high=0\n", + " # for equilibrium in dictionaries:\n", + " for equi_i in range(len(dictionaries)):\n", + " new_equi_low = 0\n", + " new_equi_high = 0\n", + " equi = dictionaries[equi_i]\n", + " # low_prob_str = \", \".join(\n", + " # map(\"{0:.2f}\".format, equi[\"low_cost_probs\"]))\n", + " # high_prob_str = \", \".join(\n", + " # map(\"{0:.2f}\".format, equi[\"high_cost_probs\"]))\n", + " cl.prt(\n", + " f'equi: {str(equi[\"low_cost_support\"])}, {str(equi[\"high_cost_support\"])}\\n payoffs= {equi[\"low_cost_payoff\"]:.2f}, {equi[\"high_cost_payoff\"]:.2f}')\n", + " \n", + " # train a low-cost agent\n", + " high_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.high_strategies, probablities_lst=((equi[\"high_cost_probs\"]+([0]*added_high)) if added_high> 0 else equi[\"high_cost_probs\"]))\n", + " \n", + " base_agent=None\n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for mem_i,memory in enumerate(memories):\n", + " # base_strt=(high_mixed_strat.strategies[np.argmax(\n", + " # np.array(high_mixed_strat.strategy_probs))])\n", + " # if base_strt.type == cl.StrategyType.sb3_model:\n", + " # base_agent = base_strt.name\n", + " base_agent= find_base_agent(db=db,memory=memory, alg=alg, cost=gl.LOW_COST, strategies= bimatrix_game.low_strategies,strategy_probs=((equi[\"low_cost_probs\"]+([0]*added_low)) if added_low > 0 else equi[\"low_cost_probs\"])) \n", + " print(f'training low-cost player with base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(db=db,base_agent=base_agent, env_class=env_class, costs=[\n", + " gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi[\"low_cost_payoff\"], num_procs=num_procs, alg=alg, lr=lr, memory=memory)\n", + " if acceptable:\n", + " new_equi_low += 1\n", + " added_low+=1\n", + " \n", + " # update[int(i/2)] = True\n", + " bimatrix_game.low_strategies.append(agent_strategy)\n", + " bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs)\n", + " \n", + " # cl.prt(f\"low cost player {agent_strategy.name} added, trained with \", [\n", + " # equi[\"low_cost_probabilities\"], equi[\"high_cost_probabilities\"], equi[\"low_cost_payoff\"], equi[\"high_cost_payoff\"]])\n", + " cl.prt(\n", + " f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " # train a high-cost agent\n", + " low_mixed_strat = cl.MixedStrategy(\n", + " strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi[\"low_cost_probs\"]+([0]*added_low)) if added_low > 0 else equi[\"low_cost_probs\"]))\n", + " \n", + " base_agent=None\n", + " for alg in algs:\n", + " for lr in lrs:\n", + " for memory in memories:\n", + " \n", + " # base_strt=(low_mixed_strat.strategies[np.argmax(\n", + " # np.array(low_mixed_strat.strategy_probs))])\n", + " # if base_strt.type == cl.StrategyType.sb3_model:\n", + " # base_agent = base_strt.name\n", + " base_agent= find_base_agent(db=db,cost=gl.HIGH_COST,memory=memory, strategies= bimatrix_game.high_strategies,strategy_probs=((equi[\"high_cost_probs\"]+([0]*added_high)) if added_high> 0 else equi[\"high_cost_probs\"]),alg=alg)\n", + " print(f'training high-cost player with base={base_agent} ,alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(db=db,base_agent=base_agent, env_class=env_class, costs=[\n", + " gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi[\"high_cost_payoff\"], num_procs=num_procs, alg=alg, memory=memory, lr=lr)\n", + " if acceptable:\n", + " new_equi_high += 1\n", + " added_high+=1\n", + " bimatrix_game.high_strategies.append(agent_strategy)\n", + " bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs)\n", + " \n", + " cl.prt(\n", + " f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, base={base_agent}, alg={str(alg)}, lr={lr:.4f}, memory={memory}')\n", + " \n", + " if new_equi_low>0 or new_equi_high>0:\n", + " equilibria.append(\n", + " [equi[\"low_cost_probs\"], equi[\"high_cost_probs\"], equi[\"low_cost_payoff\"], equi[\"high_cost_payoff\"]])\n", + " \n", + " \n", + " if added_low==0 and added_high==0:\n", + " gl.N_EPISODES_BASE *= 1.1\n", + " gl.N_EPISODES_LOAD *= 1.1\n", + " else:\n", + " dictionaries = bimatrix_game.compute_equilibria()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef372678-7225-48bc-8c31-2fad59bcc7c0", + "metadata": {}, + "outputs": [], + "source": [ + "# env=ConPricingGame(tuple_costs=[57,71], adversary_mixed_strategy= (cl.Strategy(\n", + "# cl.StrategyType.static, model_or_func=cl.myopic, name=\"myopic\")).to_mixed_strategy(), memory=3)\n", + "\n", + "# policy = (PPO.load(\"models/\"+\"NOV24-1700860722\", env=env)).predict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b98de76c-95c6-4052-b30b-4b63e49f1604", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "condaenv2", + "language": "python", + "name": "condaenv2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/extend_game/src_last/bimatrix.py b/learningAgents/extend_game/src_last/bimatrix.py new file mode 100644 index 0000000..870b57e --- /dev/null +++ b/learningAgents/extend_game/src_last/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils as utils +import src.columnprint as columnprint +import src.lemke as lemke +import src.randomstart as randomstart +import random # random.seed +import src.classes as cl + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + cl.prt("\n all equilibria: \n") + for eq in sorted_trset: + cl.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/extend_game/src_last/classes.py b/learningAgents/extend_game/src_last/classes.py new file mode 100644 index 0000000..d7a4ea1 --- /dev/null +++ b/learningAgents/extend_game/src_last/classes.py @@ -0,0 +1,535 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +# from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix as bimatrix +import time +import os +import sqlite3 as sql +from collections import namedtuple +from stable_baselines3 import SAC, PPO +from copy import copy + + +class DataBase(): + + AgentRow = namedtuple( + "AgentRow", "name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, alg, lr, memory, added, action_step, seed, num_process, running_time") + + AGENTS_TABLE = "trained_agents" + ITERS_TABLE = "agents_iters" + AGENTS_COLS = "id integer PRIMARY key AUTOINCREMENT,name text NOT NULL,base_agent text DEFAULT NULL,n_ep integer NOT NULL,cost integer NOT NULL,mixed_adv text NOT NULL,expected_payoff real,payoff_treshhold real,alg text NOT NULL,lr real NOT NULL,memory integer NOT NULL, action_step integer DEFAULT NULL,seed integer,num_procs integer DEFAULT 1,running_time integer, added integer,time text" + ITERS_COLS = "id integer PRIMARY key AUTOINCREMENT,agent_id integer NOT NULL,adv text NOT NULL,agent_return text,adv_return text,agent_rewards text,adv_rewards text,actions text,agent_prices text,adv_prices text, agent_demands text,adv_demands text" + + def __init__(self, name="data.db") -> None: + self.db_name = name + self.reset() + + def reset(self): + self.connection = sql.connect(self.db_name,timeout=10) + self.cursor = self.connection.cursor() + self.cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.AGENTS_TABLE}({self.AGENTS_COLS});') + self.cursor.execute( + f'CREATE TABLE IF NOT EXISTS {self.ITERS_TABLE}({self.ITERS_COLS});') + + # def insert_new_agent(self, name, base_agent, num_ep, cost, mixed_adv_txt, expected_payoff, payoff_treshhold, lr, memory, added, action_step=None, seed=0, num_process=1, running_time=0): + def insert_new_agent(self, row): + """ + adds a new agent to db and returns the id + row: AgentRow named tuple + """ + query = f'INSERT INTO {self.AGENTS_TABLE} VALUES (NULL,\'{row.name}\',' + ('NULL' if (row.base_agent is None) else f'\'{row.base_agent}\'') + \ + f',{row.num_ep},{row.cost},\'{row.mixed_adv_txt}\',{row.expected_payoff},{row.payoff_treshhold},\"{row.alg}\",{row.lr},{row.memory},{("NULL" if row.action_step is None else row.action_step)},{row.seed},{row.num_process},{row.running_time},{int(row.added)},\'{ time.ctime(time.time())}\')' + # print(query) + self.cursor.execute(query) + self.connection.commit() + return self.cursor.lastrowid + + def insert_new_iteration(self, agent_id, adv_txt, agent_return, adv_return, agent_rewards_txt, adv_rewards_txt, actions_txt, agent_prices_txt, adv_prices_txt, + agent_demands_txt, adv_demands_txt): + """ + adds a new iteration to db and returns the id + """ + query = f'INSERT INTO {self.ITERS_TABLE} VALUES (NULL,{agent_id},\'{adv_txt}\',{agent_return},{adv_return},\'{agent_rewards_txt}\',\'{adv_rewards_txt}\',\ + \'{actions_txt}\',\'{agent_prices_txt}\',\'{adv_prices_txt}\',\'{agent_demands_txt}\',\'{adv_demands_txt}\')' + # print(query) + self.cursor.execute(query) + self.connection.commit() + return self.cursor.lastrowid + + def get_list_of_added_strategies(self): + """ returns two lists of low_cost and high_cost strategies """ + low_q= f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.LOW_COST})" + high_q= f"SELECT name, alg, memory, action_step FROM {self.AGENTS_TABLE} WHERE (added=1 and cost={gl.HIGH_COST})" + low_lst=[] + high_lst=[] + self.cursor.execute(low_q) + low_all=self.cursor.fetchall() + for tup in low_all: + if tup[1]==str(SAC): + model=SAC + elif tup[1]== str(PPO): + model=PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [],[] + + low_lst.append(Strategy(strategy_type=StrategyType.sb3_model,model_or_func=model,name=tup[0],memory=tup[2],action_step=tup[3])) + + self.cursor.execute(high_q) + high_all=self.cursor.fetchall() + for tup in high_all: + if tup[1]==str(SAC): + model=SAC + elif tup[1]== str(PPO): + model=PPO + else: + print("ERROR in loading strategies from db: model not recognised!") + return [],[] + + high_lst.append(Strategy(strategy_type=StrategyType.sb3_model,model_or_func=model,name=tup[0],memory=tup[2],action_step=tup[3])) + return low_lst, high_lst + + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + strt_L = self.low_strategies[low_index] + strt_H = self.high_strategies[high_index] + strt_L.reset() + strt_H.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=strt_H.to_mixed_strategy(), memory=strt_L.memory) + payoffs = [strt_L.play_against(env, strt_H) + for _ in range(gl.NUM_MATRIX_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"game_{job_name}.txt", "w") as out: + out.write(output) + + output += "\nlow-cost strategies: \n" + for strt in self.low_strategies: + output += f" {strt.name} " + output += "\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output += f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff, + "low_cost_support": low_cost_support, + "high_cost_support": high_cost_support + } + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can be models trained with sb3. + """ + type = None + env = None + name = None + memory = None + policy = None + model = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, memory=0, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.memory = memory + + self.action_step = action_step + + if strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.sb3_model: + if self.policy is None: + if env.memory != self.memory: + env_adv=(env.__class__)(tuple_costs=env.costs, adversary_mixed_strategy=env.adversary_mixed_strategy, memory=self.memory) + self.policy = (self.model.load(self.dir, env=env_adv)).predict + else: + self.policy = (self.model.load(self.dir, env=env)).predict + state = env.get_state( + stage=env.stage, player=player, memory=self.memory) + action, _ = self.policy(state) + # compute price for co model and disc model + price = (env.myopic(player)-action[0]) if (self.action_step is None) else ( + env.myopic(player)-(self.action_step*action)) + + if player == 0: + env.actions[env.stage] = (action[0] if ( + self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy = adversary.to_mixed_strategy() + + state, _ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size = support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def spe(env, player, firstprice=0): + """ + returns the subgame perfect equilibrium price + """ + t = env.stage + P = gl.SPE_a[t]*(env.demand_potential[player][t]-200) + gl.SPE_b[t] + gl.SPE_k[t]*(env.costs[player]-64) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt', 'a') as file: + file.write("\n"+string) + + +# def write_to_excel(file_name, new_row): +# """ +# row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time +# """ + +# path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + +# wb = load_workbook(path) +# sheet = wb.active +# row = 2 +# col = 1 +# sheet.insert_rows(idx=row) + +# for i in range(len(new_row)): +# sheet.cell(row=row, column=col+i).value = new_row[i] +# wb.save(path) + + +# def write_results(new_row): +# write_to_excel(f'results_{job_name}.xlsx', new_row) + + +# def write_agents(new_row): +# # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ +# # gamma seed num_procs running_time date + +# write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.GAMES_DIR): + os.makedirs(gl.GAMES_DIR) + + +def set_job_name(name): + global job_name + job_name = name diff --git a/learningAgents/extend_game/src_last/columnprint.py b/learningAgents/extend_game/src_last/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/extend_game/src_last/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/extend_game/src_last/doubleoracle.py b/learningAgents/extend_game/src_last/doubleoracle.py new file mode 100644 index 0000000..453a56e --- /dev/null +++ b/learningAgents/extend_game/src_last/doubleoracle.py @@ -0,0 +1,13 @@ +from enum import Enum +import numpy as np +import classes as cl + +class DoubleOracle(): + """ + this class is the data structure to represent the double oracle which is a bimatrix game with low-cost and high-cost strategies are trained and added to it based on the Nash equilibrium. + + """ + def __init__(self): + cl.create_directories() + + diff --git a/learningAgents/extend_game/src_last/environments.py b/learningAgents/extend_game/src_last/environments.py new file mode 100644 index 0000000..81abd92 --- /dev/null +++ b/learningAgents/extend_game/src_last/environments.py @@ -0,0 +1,183 @@ +# In this env, in the state representation, the memory og both agent and adversary will be given. the length of memory is specified with variable memory + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl +import src.classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + #memory of both players + self.memory=memory + # self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(2+2*memory,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, memory=None): + # [stage, our demand, our price memory, adv price memory] + + mem_len = memory if ( + memory is not None) else self.memory + + + stage_part = [stage] + self_mem=[] + adv_mem=[] + + if stage == 0: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + observation = stage_part+[self.demand_potential[player][self.stage]] + self_mem+ adv_mem + else: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + j = mem_len-1 + for i in range(stage-1, max(-1, stage-1-mem_len), -1): + adv_mem[j] = self.prices[1-player][i] + self_mem[j] = self.prices[player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player][self.stage]]+ self_mem+ adv_mem + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__(tuple_costs, adversary_mixed_strategy,memory) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/extend_game/src_last/globals.py b/learningAgents/extend_game/src_last/globals.py new file mode 100644 index 0000000..625366e --- /dev/null +++ b/learningAgents/extend_game/src_last/globals.py @@ -0,0 +1,69 @@ +import numpy as np + + +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, GAMMA, NUM_ACTIONS, REWARDS_DIVISION_CONST + global NUM_STOCHASTIC_ITER, NUM_MATRIX_ITER, N_EPISODES_BASE, N_EPISODES_LOAD, EPISODE_INCREASE_PORTION + # global REPLAY_BUFFER_SIZE, PROB_BREAK_LIMIT_LN, CONVERGE_BREAK, PRINT_STEP,NUM_ADV_HISTORY, LR,ACTION_STEP + # global BATCH_UPDATE_SIZE, BUFFER_PLAY_COEFFICIENT, NUM_PROCESS, NUM_MODEL_SAVE + global CON_ACTIONS_RANGE, MODELS_DIR, LOG_DIR, NUM_TRACE_EQUILIBRIA, GAMES_DIR, NUM_PROCESS + global SPE_A, SPE_a, SPE_B, SPE_b, SPE_K, SPE_k, SPE_z, SPE_Y + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE = 60 + # ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 100 + NUM_MATRIX_ITER = 100 + REWARDS_DIVISION_CONST = 1000 + + # N_EPISODES_BASE = 2_50 + # N_EPISODES_LOAD = 1_00 + N_EPISODES_BASE = 2_000_000 + N_EPISODES_LOAD = 800_000 + EPISODE_INCREASE_PORTION = 0.3 + + # NUM_EPISODES_RESET = NUM_EPISODES + + NUM_TRACE_EQUILIBRIA = 2 + # #HOW OFTEN THE MODEL SHOULD BE SAVED. + # NUM_MODEL_SAVE=3 + + NUM_PROCESS = 6 + + MODELS_DIR = "models" + LOG_DIR = "logs" + GAMES_DIR = "games" + + # SPE coefficients + + SPE_a = [np.nan]*25 + SPE_A = [np.nan]*25 + SPE_b = [np.nan]*25 + SPE_B = [np.nan]*25 + SPE_k = [np.nan]*25 + SPE_K = [np.nan]*25 + SPE_z = [np.nan]*25 + SPE_Y = [np.nan]*25 + + SPE_a[24] = 0.5 + SPE_A[24] = 0.25 + SPE_b[24] = 132 + SPE_B[24] = 68 + SPE_k[24] = 0.5 + SPE_K[24] = -0.5 + SPE_Y[24] = 0.25 * GAMMA + + for t in range(23, -1, -1): + SPE_a[t] = (1-SPE_Y[t+1])/(2-SPE_Y[t+1]) + SPE_z[t] = GAMMA*(0.75-0.5*SPE_a[t]) + SPE_k[t] = (1-0.5*GAMMA*SPE_K[t+1])/(2-SPE_Y[t+1]) + SPE_K[t] = -0.5 + SPE_z[t]*(SPE_K[t+1]-2*SPE_A[t+1]*SPE_k[t]) + SPE_A[t] = 0.25 + SPE_z[t]*SPE_A[t+1]*(1-SPE_a[t]) + SPE_b[t] = 132 - 0.25*GAMMA*SPE_B[t+1] + SPE_B[t] = 68 + SPE_z[t]*SPE_B[t+1] + SPE_Y[t] = 0.25*GAMMA + SPE_z[t]*(1-SPE_a[t])*SPE_Y[t+1] diff --git a/learningAgents/extend_game/src_last/lemke.py b/learningAgents/extend_game/src_last/lemke.py new file mode 100644 index 0000000..afb0921 --- /dev/null +++ b/learningAgents/extend_game/src_last/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint as columnprint +import src.utils as utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0].out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s == "-v" or s == "-verbose": + verbose = True + elif s == "-s" or s == "-silent": + silent = True + elif s == "-z0": + z0 = True + elif s[0] == "-": + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + + + # creae LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, it): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout( "lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]* = + self.d = [0]*n + needfracs = n*n + 2*n + if len(words != needfacs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs," fr actions, got", len(words)-5) + exi t(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 == + s el f.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 == + s el f.q = utils.tovector(n,words,k) + k+=n + elif wo rds[k]=="d=": + k+=1 == + s el f.d = utils.tovector(n,words,k) + k+=n + else: + pintout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q = self.q + d = self.d + m = = columnprint.columnprint(n) + m = makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m. sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +classu: + # filling the tableau from the LCP instance Mqd + + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = []*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinan = 1 + self.lextested = [0]*(n+1) + self.lexcompa = isons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + == n = Mqd.q[i].denominator + else: + de == = Mq d.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif == ==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: == + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa" ) # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichv ar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = st r(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "----------------end of tableau-----------------" + return out + + def vartoa(self , v): # variable as as string w1..wn or z0..zn + if (v > sel f.n): + return "w"+str(v-self.n) +else: + return "z"+s tr(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is no nbasic + self.solution[i]=fractions.Fration(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n = + sol.sprint("basis=") + for i in rang e(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info "Cob asic variable", self.vartoa(v), + "shouldbe basic") + exit(1) + return + + def assertcobasi(self, v, info): # assert that v is cobasic + if (self .bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(sef, leave, enter): # leave, enter in VARS + self.ass ertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout(s) + returnt("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in ran ge(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobs[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return == + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + prntout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lex t[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.spr int(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave idicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecad == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as ther == is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j omitted from statistics: only one possible row + i eans no .in-ratio test needed for leaving varia + # T is basic, or equal to the entering variable. + j =going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+ 1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + == newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # comp are ratios via products + tmp1 = Anewcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][c] + # sgn =np.sign(tmp1- tmp2) + # if sgn==0: + if tmp1 == tm p2 : # new ratiois the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand f in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n ] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check i f z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in ra nge(self.n): + self.A[i][col] = - == lf.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, +vot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with poitive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in ran ge(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot 1; + flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binter ac t = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtai n lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flgs.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/extend_game/src_last/utils.py b/learningAgents/extend_game/src_last/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/extend_game/src_last/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt new file mode 100644 index 0000000..721ab64 Binary files /dev/null and b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0001 lr.pt b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0001 lr.pt new file mode 100644 index 0000000..5278906 Binary files /dev/null and b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0001 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 5000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 5000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt new file mode 100644 index 0000000..30497cf Binary files /dev/null and b/learningAgents/naive_policy_gradient/ActorCritic/NNs/ep 5000000, myopic-0.3-constant_95-0.3-guess_132-0.3-, 2 hist, 0.0001 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/ActorCritic/environmentModel.py b/learningAgents/naive_policy_gradient/ActorCritic/environmentModel.py new file mode 100644 index 0000000..f689859 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/environmentModel.py @@ -0,0 +1,287 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T), [0]*(self.T)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player, t): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player, self.stage) + + def const(self, player, price): # constant price strategy + """ + Adversary follows Constant strategy + """ + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return price + + def imit(self, player, firstprice): # price imitator strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return self.prices[1-player][self.stage-1] + + def fight(self, player, firstprice): # simplified fighting strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (self.totalDemand-self.costs[player] + + self.costs[1-player])/2 + + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return self.prices[player][self.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getself.demandPotential to Asp + P = self.prices[1-player][self.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (self.totalDemand+self.costs[0]+self.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + def fight_lb(self, player, firstprice): + P = self.fight(player, firstprice) + # never price less than production cost + P = max(P, self.costs[player]) + return P + + # sophisticated fighting strategy, compare fight() + # estimate *sales* of opponent as their target + + def guess(self, player, firstprice): # predictive fighting strategy + if self.stage == 0: + self.aspireDemand = [(self.totalDemand+ self.costs[1]-self.costs[0] ), (self.totalDemand+ self.costs[0]-self.costs[1] )] # aspiration level + self.aspirePrice = (self.totalDemand+self.costs[0]+self.costs[1])/4 + self.saleGuess= [self.aspireDemand[0]-self.aspirePrice,self.aspireDemand[1]-self.aspirePrice ] # first guess opponent sales as in monopoly ( sale= demand-price) + + return firstprice + + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + + + + D = self.demandPotential[player][self.stage] + Asp = self.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = self.monopolyPrice(player, self.stage) + pcurrent = self.prices[player][self.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = self.demandPotential[1 - + player][self.stage-1] - self.prices[1-player][self.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * self.saleGuess[player] + (1-alpha)*prevsales + # update + self.saleGuess[player] = newsalesguess + guessoppPrice = self.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, adversaryProbs, advHistoryNum=3) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + + self.rewardFunction = self.profits + + # [stage, agent's demand potential, agent's last price, history of adversary's prices] + self.initState = [ + 0, totalDemand/2, ((totalDemand/2) + tupleCosts[0])/2] + ([0]*advHistoryNum) + self.episodesMemory = list() + self.done = False + self.adversaryProbs = adversaryProbs + # number of previous adversary's action we consider in the state + self.advHistoryNum = advHistoryNum + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return torch.tensor(self.initState, dtype=torch.float32), reward, self.done + + def resetAdversary(self): + adversaryDist = Categorical(self.adversaryProbs) + adversaryInd = (adversaryDist.sample()).item() + self.adversaryMode = AdversaryModes(adversaryInd) + # print(self.adversaryMode) + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + if self.adversaryMode == AdversaryModes.constant_132: + return self.const(player=1, price=132) + elif self.adversaryMode == AdversaryModes.constant_95: + return self.const(player=1, price=95) + elif self.adversaryMode == AdversaryModes.imitation_128: + return self.imit(player=1, firstprice=128) + elif self.adversaryMode == AdversaryModes.imitation_132: + return self.imit(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_100: + return self.fight(player=1, firstprice=100) + elif self.adversaryMode == AdversaryModes.fight_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_lb_125: + return self.fight_lb(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_132: + return self.fight(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_lb_132: + return self.fight_lb(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.guess_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.guess_132: + return self.fight(player=1, firstprice=132) + else: + return self.myopic(player=1) + + def step(self, state, action): + """ + Transition Function. + Parameters: + - action: Price + - state: tupple in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + adversaryAction = self.adversaryChoosePrice() + myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [self.myopic() - action, adversaryAction]) + + done = (self.stage == self.T-1) + + + if not done: + newState = [self.stage+1, self.demandPotential[0] + [self.stage + 1], self.prices[0][self.stage]] + else: + newState = [self.stage+1, 0, self.prices[0] + [self.stage]] + + if(self.advHistoryNum>0): + advHistory = [0]*self.advHistoryNum + j = self.advHistoryNum-1 + for i in range(self.stage, max(-1, self.stage-self.advHistoryNum), -1): + advHistory[j] = self.prices[1][i] + j -= 1 + + newState+= advHistory + + + reward = self.rewardFunction() + self.stage = self.stage + 1 + + return torch.tensor(newState, dtype=torch.float32), reward, done + + +class AdversaryModes(Enum): + myopic = 0 + constant_132 = 1 + constant_95 = 2 + imitation_132 = 3 + imitation_128 = 4 + fight_132 = 5 + fight_lb_132 = 6 + fight_125 = 7 + fight_lb_125 = 8 + fight_100 = 9 + guess_132 = 10 + guess_125 = 11 diff --git a/learningAgents/naive_policy_gradient/ActorCritic/learningActorCritic.py b/learningAgents/naive_policy_gradient/ActorCritic/learningActorCritic.py new file mode 100644 index 0000000..0830444 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/learningActorCritic.py @@ -0,0 +1,219 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + + self.returns = [] + self.loss = [] + # self.returns = np.zeros((numberIterations, numberEpisodes)) + # self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def savePolicy(self): + pass + + def solver(self, print_step=10_000, prob_break_limit_ln=-0.001,clc=0.1): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + + self.returns.append([]) + self.loss.append([]) + + for episode in range(self.numberEpisodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst = [] + value_lst=[] + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs, value = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + value_lst.append(value) + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*30) + # print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + discReturns = (self.returnsComputation(rewards, episodeMemory))/10_000 + + + + actor_loss = - (torch.sum((discReturns-(torch.stack(value_lst)).detach())*action_logprobs)) / \ + len(episodeMemory) + critic_loss= torch.sum(torch.pow(torch.stack(value_lst)-discReturns,2)) + + loss = actor_loss + clc*critic_loss + + shouldBreak = torch.all((action_logprobs > + prob_break_limit_ln)) + + + if (episode % print_step == 0) or shouldBreak: + print("-"*50) + print(episode, " adversary: ", self.env.adversaryMode) + print(" actions: ", actions) + + print("loss= ", loss, " , actor= ", actor_loss," , critic= ", critic_loss, " , return= ", returns) + # print("states= ", states) + print("probs of actions: ", torch.exp(action_logprobs)) + print("shouldBreak:", shouldBreak.item()) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + + + self.optim.zero_grad() + + loss.backward() + self.optim.step() + + # sum of the our player's rewards rounds 0-25 + # self.returns[iteration][episode] = returns + # self.loss[iteration][episode] = loss + self.returns[iteration].append(returns) + self.loss[iteration].append(loss.item()) + + # all probs >0.999 means coverged? break + if shouldBreak: + # self.returns[iteration] = self.returns[iteration][0:episode] + # self.loss[iteration] = self.loss[iteration][0:episode] + break + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + plt.plot(self.returns[iteration]) + plt.show() + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + """ + return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normalizeState(self, state): + normalized = [0]*len(state) + normalized[0] = (state[0]+1)/(self.env.T) + for i in range(1, len(state)): + normalized[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalized) + + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.neuralNetwork(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + retu = retu + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + print(f"episode {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + plt.plot(returns) + plt.show() diff --git a/learningAgents/naive_policy_gradient/ActorCritic/learningAgentsBase.py b/learningAgents/naive_policy_gradient/ActorCritic/learningAgentsBase.py new file mode 100644 index 0000000..66613c3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/learningAgentsBase.py @@ -0,0 +1,225 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + + self.returns = [] + self.loss = [] + # self.returns = np.zeros((numberIterations, numberEpisodes)) + # self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def savePolicy(self): + pass + + def solver(self, print_step=10_000, prob_break_limit_ln=-0.001): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + self.meanStageValue = torch.zeros(self.env.T) + self.returns.append([]) + self.loss.append([]) + + for episode in range(self.numberEpisodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst = [] + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*30) + # print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + discReturns = self.returnsComputation(rewards, episodeMemory) + + if episode == 0: + self.meanStageValue = discReturns + + baseDiscReturns = discReturns-self.meanStageValue + + # is it a good idea? to get over the big weights in NN + baseDiscReturns /= 1000 + + loss = - (torch.sum(baseDiscReturns*action_logprobs)) / \ + len(episodeMemory) + + shouldBreak = torch.all((action_logprobs > ( + prob_break_limit_ln*torch.ones(self.env.T)))) + + + if (episode % print_step == 0) or shouldBreak: + print("-"*50) + print(episode, " adversary: ", self.env.adversaryMode) + print(" actions: ", actions) + + print("loss= ", loss, " , return= ", returns) + # print("states= ", states) + print("probs of actions: ", torch.exp(action_logprobs)) + print("shouldBreak:", shouldBreak.item()) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + print("baseDiscReturns/1000=", baseDiscReturns) + # print("discReturns=", discReturns) + print("meanStageValue= ", self.meanStageValue) + + if episode != 0: + self.meanStageValue = ( + (self.meanStageValue*episode)+discReturns)/(episode+1) + + self.optim.zero_grad() + loss.backward() + self.optim.step() + + # sum of the our player's rewards rounds 0-25 + # self.returns[iteration][episode] = returns + # self.loss[iteration][episode] = loss + self.returns[iteration].append(returns) + self.loss[iteration].append(loss.item()) + + # all probs >0.999 means coverged? break + if shouldBreak: + self.returns[iteration] = self.returns[iteration][0:episode] + self.loss[iteration] = self.loss[iteration][0:episode] + break + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + plt.plot(self.returns[iteration]) + plt.show() + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + """ + return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normalizeState(self, state): + normalized = [0]*len(state) + normalized[0] = (state[0]+1)/(self.env.T) + for i in range(1, len(state)): + normalized[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalized) + + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.neuralNetwork(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + retu = retu + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + print(f"episode {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + plt.plot(returns) + plt.show() diff --git a/learningAgents/naive_policy_gradient/ActorCritic/neuralNetwork.py b/learningAgents/naive_policy_gradient/ActorCritic/neuralNetwork.py new file mode 100644 index 0000000..23fd35b --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/neuralNetwork.py @@ -0,0 +1,80 @@ +import torch +import torch.nn as nn +from torch.nn import functional as F +import torch.multiprocessing as mp + + +class NNBase(): + + """ + Defines a three layer Neural Network that acts as the agent. The output is a tensor of probablities over actions. + + reset() function should be overwritten to define the policy and optimizer + """ + + save_path_format = './NNs/{name}.pt' + + def __init__(self, lr=.000001, num_input=3, num_actions=50, nn_dim=100) -> None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + self.nn_dim = nn_dim + + self.nn_name = f"nn, lr={self.lr}, actions={self.num_actions}" + + def reset(self): + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_dim), + nn.ReLU(), + nn.Linear(self.nn_dim, self.nn_dim), + nn.ReLU(), + nn.Linear(self.nn_dim, self.num_actions), + nn.Softmax(dim=0)) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim + + def save(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + return torch.save(self.policy.state_dict(), self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + self.policy.load_state_dict( + torch.load(self.save_path_format.format(name=self.nn_name))) + + +# class PlicyGradient(): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# return + + +class ActorCritic(nn.Module): + def __init__(self, num_input=3, num_actions=50, nn_dim=100): + super(ActorCritic, self).__init__() + self.l1 = nn.Linear(num_input,nn_dim) + self.l2 = nn.Linear(nn_dim,nn_dim) + self.actor_lin1 = nn.Linear(nn_dim,num_actions) + self.l3 = nn.Linear(nn_dim,nn_dim) + self.critic_lin1 = nn.Linear(nn_dim,1) + def forward(self,x): + x = F.normalize(x,dim=0) + y = F.relu(self.l1(x)) + y = F.relu(self.l2(y)) + actor = F.softmax(self.actor_lin1(y),dim=0) #C + c = F.relu(self.l3(y.detach())) + critic = F.relu(self.critic_lin1(c)) #D + return actor, critic #E + +class NeuralNetwork(NNBase): + def __init__(self,lr=.000001, num_input=3, num_actions=50, nn_dim=100): + super().__init__(lr=lr, num_input=num_input, num_actions=num_actions, nn_dim=nn_dim) + + def reset(self): + self.policy = ActorCritic(num_input=self.num_input, num_actions=self.num_actions, nn_dim=self.nn_dim) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] lr=10^-5.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] lr=10^-5.ipynb new file mode 100644 index 0000000..22de0ee --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] lr=10^-5.ipynb @@ -0,0 +1,314 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.3333, 0.0000, 0.3333, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.3333, 0.0000])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/3\n", + "adversaryProbs[2]=1/3\n", + "adversaryProbs[10]=1/3\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=2)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000, 0.0000, 0.0000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.00001)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=5_000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 1, 48, 19, 38, 38, 28, 14, 15, 16, 42, 8, 2, 40, 38, 20, 40, 17, 25,\n", + " 38, 20, 19, 36, 41, 10, 45])\n", + "loss= tensor(539.3247, grad_fn=) , actor= tensor(209.6115, grad_fn=) , critic= tensor(3297.1318, grad_fn=) , return= 83198.79199274778\n", + "probs of actions: tensor([0.0224, 0.0256, 0.0198, 0.0197, 0.0197, 0.0186, 0.0208, 0.0187, 0.0219,\n", + " 0.0183, 0.0189, 0.0173, 0.0178, 0.0196, 0.0201, 0.0178, 0.0230, 0.0217,\n", + " 0.0196, 0.0201, 0.0194, 0.0203, 0.0168, 0.0195, 0.0236],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 2, 38, 13, 4, 40, 20, 44, 23, 3, 1, 47, 49, 25, 24, 2, 22, 5, 27,\n", + " 9, 16, 40, 39, 18, 28, 21])\n", + "loss= tensor(27.6274, grad_fn=) , actor= tensor(-159.7304, grad_fn=) , critic= tensor(1873.5775, grad_fn=) , return= 26370.911056602232\n", + "probs of actions: tensor([0.0169, 0.0197, 0.0198, 0.0200, 0.0179, 0.0198, 0.0234, 0.0201, 0.0219,\n", + " 0.0196, 0.0215, 0.0222, 0.0220, 0.0196, 0.0178, 0.0184, 0.0192, 0.0211,\n", + " 0.0214, 0.0215, 0.0177, 0.0210, 0.0175, 0.0184, 0.0171],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 49, 13, 8, 46, 25, 14, 16, 10, 25, 14, 48, 12, 14, 44, 44, 31, 12,\n", + " 13, 13, 24, 1, 39, 46, 47])\n", + "loss= tensor(40.6222, grad_fn=) , actor= tensor(-159.3091, grad_fn=) , critic= tensor(1999.3126, grad_fn=) , return= 41509.8401016716\n", + "probs of actions: tensor([0.0198, 0.0208, 0.0198, 0.0182, 0.0198, 0.0221, 0.0221, 0.0224, 0.0201,\n", + " 0.0224, 0.0224, 0.0270, 0.0195, 0.0225, 0.0235, 0.0235, 0.0190, 0.0196,\n", + " 0.0198, 0.0198, 0.0201, 0.0189, 0.0207, 0.0205, 0.0213],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 44, 14, 17, 9, 20, 37, 48, 33, 18, 0, 27, 27, 22, 14, 36, 35, 12,\n", + " 4, 16, 16, 36, 24, 46, 15])\n", + "loss= tensor(580.8849, grad_fn=) , actor= tensor(185.3376, grad_fn=) , critic= tensor(3955.4736, grad_fn=) , return= 165886.84302047515\n", + "probs of actions: tensor([0.0181, 0.0225, 0.0214, 0.0242, 0.0214, 0.0199, 0.0175, 0.0259, 0.0217,\n", + " 0.0183, 0.0178, 0.0225, 0.0225, 0.0191, 0.0222, 0.0205, 0.0204, 0.0194,\n", + " 0.0181, 0.0225, 0.0225, 0.0206, 0.0202, 0.0207, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])\n", + "loss = pd.DataFrame(algorithm.loss[0],columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small NNBase.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small NNBase.ipynb new file mode 100644 index 0000000..b64866f --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small NNBase.ipynb @@ -0,0 +1,629 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgentsBase import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.3333, 0.0000, 0.3333, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.3333, 0.0000])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/3\n", + "adversaryProbs[2]=1/3\n", + "adversaryProbs[10]=1/3\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=2)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000, 0.0000, 0.0000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NNBase(num_input=3+game.advHistoryNum, lr=0.0001,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1_000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(-0., grad_fn=) , return= 15959.5087890625\n", + "probs of actions: tensor([0.2357, 0.2328, 0.2319], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0., 0., 0.])\n", + "meanStageValue= tensor([14377.2637, 10304.4590, 5517.9932])\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(-2.1665, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.3130, 0.3050, 0.2894], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([-1.9158, -2.1232, -1.4136])\n", + "meanStageValue= tensor([13415.2354, 9230.0996, 4786.7764])\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([2, 2, 1])\n", + "loss= tensor(-2.9947, grad_fn=) , return= 12482.8447265625\n", + "probs of actions: tensor([0.3125, 0.3158, 0.0586], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([-1.9781, -2.1983, -1.4630])\n", + "meanStageValue= tensor([13423.7500, 9239.8652, 4793.4043])\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(-0.2068, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.8715, 0.9049, 0.9094], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([-1.9472, -2.1614, -1.4396])\n", + "meanStageValue= tensor([13446.6455, 9268.2529, 4812.7852])\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(-0.0129, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.9890, 0.9948, 0.9962], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([-1.9573, -2.1754, -1.4489])\n", + "meanStageValue= tensor([13456.6973, 9282.2900, 4822.0190])\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.0022, grad_fn=) , return= 15959.5087890625\n", + "probs of actions: tensor([0.9955, 0.9984, 0.9989], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0.9134, 1.0167, 0.6924])\n", + "meanStageValue= tensor([13463.8506, 9287.7803, 4825.5815])\n", + "--------------------------------------------------\n", + "56372 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(-0.0010, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.9990, 0.9997, 0.9998], grad_fn=)\n", + "shouldBreak: True\n", + "baseDiscReturns/1000= tensor([-1.9687, -2.1845, -1.4547])\n", + "meanStageValue= tensor([13468.1221, 9291.3721, 4827.8555])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])\n", + "loss=pd.DataFrame(algorithm.loss[0],columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.0000200.0000
1184.7500215.2500
2173.3125226.6875
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.0000 200.0000\n", + "1 184.7500 215.2500\n", + "2 173.3125 226.6875" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 12547.415039\n", + "1 11465.649414\n", + "dtype: float64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05103.2500002520.000000
14071.0156252886.000000
23373.1494146059.649414
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5103.250000 2520.000000\n", + "1 4071.015625 2886.000000\n", + "2 3373.149414 6059.649414" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0125.5000095.00000
1117.8750095.00000
2112.15625148.84375
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 125.50000 95.00000\n", + "1 117.87500 95.00000\n", + "2 112.15625 148.84375" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small.ipynb new file mode 100644 index 0000000..1cb8c62 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10] small.ipynb @@ -0,0 +1,663 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.3333, 0.0000, 0.3333, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.3333, 0.0000])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/3\n", + "adversaryProbs[2]=1/3\n", + "adversaryProbs[10]=1/3\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=2)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000, 0.0000, 0.0000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "95" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0001,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.guess_132\n", + " actions: tensor([2, 1, 0])\n", + "loss= tensor(5.0887, grad_fn=) , actor= tensor(4.1567, grad_fn=) , critic= tensor(9.3190, grad_fn=) , return= 15843.2587890625\n", + "probs of actions: tensor([0.2302, 0.2265, 0.2546], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(0.4109, grad_fn=) , actor= tensor(0.2885, grad_fn=) , critic= tensor(1.2234, grad_fn=) , return= 15873.1494140625\n", + "probs of actions: tensor([0.2625, 0.2625, 0.2632], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 0, 2])\n", + "loss= tensor(0.1549, grad_fn=) , actor= tensor(0.0327, grad_fn=) , critic= tensor(1.2219, grad_fn=) , return= 15862.5556640625\n", + "probs of actions: tensor([0.4004, 0.1992, 0.2473], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.2224, grad_fn=) , actor= tensor(0.1014, grad_fn=) , critic= tensor(1.2105, grad_fn=) , return= 15959.5087890625\n", + "probs of actions: tensor([0.5764, 0.5914, 0.5902], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(1.1467, grad_fn=) , actor= tensor(1.0076, grad_fn=) , critic= tensor(1.3907, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.2267, 0.1983, 0.6700], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1523, grad_fn=) , actor= tensor(0.0250, grad_fn=) , critic= tensor(1.2735, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9296, 0.9488, 0.9511], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "60000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1035, grad_fn=) , actor= tensor(-0.0003, grad_fn=) , critic= tensor(1.0377, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.9864, 0.9904, 0.9901], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "70000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1201, grad_fn=) , actor= tensor(-0.0016, grad_fn=) , critic= tensor(1.2165, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.9945, 0.9960, 0.9957], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "80000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1247, grad_fn=) , actor= tensor(0.0018, grad_fn=) , critic= tensor(1.2293, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9882, 0.9901, 0.9893], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "90000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1235, grad_fn=) , actor= tensor(0.0005, grad_fn=) , critic= tensor(1.2305, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9936, 0.9938, 0.9926], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "100000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1219, grad_fn=) , actor= tensor(-9.5021e-05, grad_fn=) , critic= tensor(1.2196, grad_fn=) , return= 15959.5087890625\n", + "probs of actions: tensor([0.9928, 0.9918, 0.9892], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "110000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1240, grad_fn=) , actor= tensor(0.0002, grad_fn=) , critic= tensor(1.2384, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9893, 0.9890, 0.9863], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "120000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1147, grad_fn=) , actor= tensor(-0.0055, grad_fn=) , critic= tensor(1.2012, grad_fn=) , return= 15959.5087890625\n", + "probs of actions: tensor([0.9903, 0.9866, 0.9805], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "130000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1027, grad_fn=) , actor= tensor(-0.0040, grad_fn=) , critic= tensor(1.0666, grad_fn=) , return= 12547.4150390625\n", + "probs of actions: tensor([0.9957, 0.9935, 0.9891], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "137806 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.1205, grad_fn=) , actor= tensor(-0.0003, grad_fn=) , critic= tensor(1.2082, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9990], grad_fn=)\n", + "shouldBreak: True\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss[0],columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.0200.0
1205.0195.0
2207.5192.5
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.0 200.0\n", + "1 205.0 195.0\n", + "2 207.5 192.5" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16223.8125\n", + "1 11694.8125\n", + "dtype: float64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05103.25004160.2500
15467.00003844.0000
25653.56253690.5625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5103.2500 4160.2500\n", + "1 5467.0000 3844.0000\n", + "2 5653.5625 3690.5625" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0125.50135.50
1128.00133.00
2129.25131.75
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 125.50 135.50\n", + "1 128.00 133.00\n", + "2 129.25 131.75" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAD4CAYAAAD//dEpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAlQklEQVR4nO3deXxV9Z3/8dcHEpKwJGEJGAgQdmQTISJqVQQX3KnLDJQO1KUorjNO7UjtaDc6tbbD1HbEZUDRUdRiXSpq60gVx5/iRAVBwRIWJUIlArKDJPn8/rjfwE24SQ6XJCTyfj4e98G5n+/5nvM5Ibmf+z3fc+8xd0dERKQ2zY50AiIi0jSoYIiISCQqGCIiEokKhoiIRKKCISIikaQc6QSS1aFDB8/Pzz/SaYiINCnvvvvuF+6ek0zfJlsw8vPzKSwsPNJpiIg0KWb2SbJ9dUpKREQiUcEQEZFIVDBERCQSFQwREYlEBUNERCJRwRARkUhUMEREJJIm+zmMZO0tLaPfD1/e/zylmVFarq94bwoyUpvTJj2Fb4/szu8WFHHnRQPYuG0va77Yycie7dm9r4w26SnMemMNd102hNysdN5evYn01OacM/AYysudF5dt4Ix+Hfl82x7e+/RLPtm0k9c+LuHfLhlMi5RmbNrxFRMefJvffet4+h/ThpLtXzGgcyZZGan878ov6NOpNSnNjLdWb+KCIZ0pD787Dhgwf+kG0lKa4cCQvCxyszLYsHU37pDS3MBhb2k5memptElPYV95Oc3MMODlD//GoM5ZpKY0Y8++MtqkpfDK8s8Z078T+8rK6ZKdQbk7KzfuYNHqTbRrncaFQ3Jxj/Xt2CaN/rmZvLr8cz7dtIuPNmxjRI92fFVaTlpKMzq0SWPX3jJapaXQtmUqHTPT6ZydzmdbdlP85W72lZaTm5XBojWbYjlmpPLKR59zwxm96Z/bhpLteykvd5o1M5qZ8fKyv5GVkUqvnFbc9/oqCtduYe6Ukbyx8gvuenkFFwzJZelnW/nlpUMY1r0tyzdsY2DnLH7+4nKaGZwz8Bj+8y9F3DC6NzfNXcwlw7qQlZHK8d2yWb5hOy8u3cDpfXPo3r4VX+yI/T9/unkXw7q15aE313D+kFxG9+/Ijj2l5LVtSaesNMrKnZ17y9i2Zx/l5U6b9FRapDSjW7uWAGze+RWL1mzi0827WLd5N9v37OOFDzbQKTONM/p1pGjjDpqZMaBzJp2z09mxt4xPNu0kMz0VgAkjuvH26k10aJPGgNxMFv61hC5tM9i6ex/bdu/j8oKuLFjxOe7QskVzmpkx+801HJeXzcAuWbzy0edcc1pPPt28i2WfbeXBN1bzwKQCumRn0Kdja0rLnTn/by1f7trH7n1ltG/dgh17SslumcoxWRmcPziXXV+VkpbSnBYpDf9+35rq/TAKCgo8mQ/u5d82vx6yERFpONktU1l8x9lJ9TWzd929IJm+OiUlItLEfLlr3xHZrwqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiESigiEiIpGoYIiISCS1Fgwzm21mG81sWZX4jWb2sZl9aGa/jItPM7Oi0HZOXHy4mS0NbfeYmYV4mpk9GeKLzCy/Do9PRETqSJQRxsPA2PiAmZ0BXAwMcfeBwK9CfAAwHhgY+txrZs1Dt5nAFKBPeFRs8ypgi7v3BmYAdx3G8YiISD2ptWC4+0Jgc5XwVOAX7r43rLMxxC8GnnD3ve6+BigCRphZLpDp7m957LtIHgHGxfWZE5bnAWMqRh8iItJ4JDuH0Rc4NZxCet3MTgjxLsC6uPWKQ6xLWK4ar9TH3UuBrUD7RDs1sylmVmhmhSUlJUmmLiIiyUi2YKQAbYGRwK3AU2FUkGhk4DXEqaWtctD9AXcvcPeCnJycQ89aRESSlmzBKAb+4DHvAOVAhxDvGrdeHrA+xPMSxInvY2YpQBYHnwITEZEjLNmC8SwwGsDM+gItgC+A54Hx4cqnHsQmt99x9w3AdjMbGUYik4DnwraeByaH5cuABd5Uv3NdRORrrNYbKJnZXGAU0MHMioE7gdnA7HCp7VfA5PAi/6GZPQV8BJQC17t7WdjUVGJXXGUAL4UHwCzgUTMrIjayGF83hyYiInWp1oLh7hOqafp2NetPB6YniBcCgxLE9wCX15aHiIgcWfqkt4iIRKKCISIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiESigiEiIpGoYIiISCQqGCIiEokKhoiIRKKCISIikahgiIhIJCoYIiISSa0Fw8xmm9nGcHe9itiPzOwzM1scHueFeL6Z7Y6L3xfXZ7iZLTWzIjO7J9yqlXA71ydDfJGZ5dfDcYqIyGGKMsJ4GBibID7D3YeGx4tx8VVx8Wvj4jOBKcTu890nbptXAVvcvTcwA7jrUA9CRETqX60Fw90XErvXdtLMLBfIdPe3wr2/HwHGheaLgTlheR4wpmL0ISIijcfhzGHcYGYfhFNWbePiPczsfTN73cxODbEuQHHcOsUhVtG2DsDdS4GtQPtEOzSzKWZWaGaFJSUlh5G6iIgcqmQLxkygFzAU2AD8OsQ3AN3c/XjgFuBxM8sEEo0YPPxbU1vloPsD7l7g7gU5OTlJpi4iIslIqmC4++fuXubu5cCDwIgQ3+vum8Lyu8AqoC+xEUVe3CbygPVhuRjoCmBmKUAWh3kKTERE6l5SBSPMSVT4JrAsxHPMrHlY7klscnu1u28AtpvZyDA/MQl4LvR/Hpgcli8DFoR5DhERaURSalvBzOYCo4AOZlYM3AmMMrOhxE4drQWuCaufBvzEzEqBMuBad68YLUwldsVVBvBSeADMAh41syJiI4vxh3tQIiJS92otGO4+IUF4VjXrPg08XU1bITAoQXwPcHlteYiIyJGlT3qLiEgkKhgiIhKJCoaIiESigiEiIpGoYIiISCQqGCIiEokKhoiIRKKCISIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiESigiEiIpHUWjDMbLaZbTSzZXGxH5nZZ2a2ODzOi2ubZmZFZvaxmZ0TFx9uZktD2z3hVq2YWZqZPRnii8wsv46PUURE6kCUEcbDwNgE8RnuPjQ8XgQwswHEbrE6MPS5t+Ie38BMYAqx+3z3idvmVcAWd+8NzADuSvJYRESkHtVaMNx9IbF7bUdxMfCEu+919zVAETDCzHKBTHd/y90deAQYF9dnTlieB4ypGH2IiEjjcThzGDeY2QfhlFXbEOsCrItbpzjEuoTlqvFKfdy9FNgKtD+MvEREpB4kWzBmAr2AocAG4Nchnmhk4DXEa+pzEDObYmaFZlZYUlJySAmLiMjhSapguPvn7l7m7uXAg8CI0FQMdI1bNQ9YH+J5CeKV+phZCpBFNafA3P0Bdy9w94KcnJxkUhcRkSQlVTDCnESFbwIVV1A9D4wPVz71IDa5/Y67bwC2m9nIMD8xCXgurs/ksHwZsCDMc4iISCOSUtsKZjYXGAV0MLNi4E5glJkNJXbqaC1wDYC7f2hmTwEfAaXA9e5eFjY1ldgVVxnAS+EBMAt41MyKiI0sxtfBcYmISB2rtWC4+4QE4Vk1rD8dmJ4gXggMShDfA1xeWx4iInJk6ZPeIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiESigiEiIpGoYIiISCQqGCIiEokKhoiIRKKCISIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhJJrQXDzGab2UYzW5ag7Xtm5mbWITzPN7PdZrY4PO6LW3e4mS01syIzuyfc25tw/+8nQ3yRmeXX4fGJiEgdiTLCeBgYWzVoZl2Bs4BPqzStcveh4XFtXHwmMAXoEx4V27wK2OLuvYEZwF2HdAQiItIgai0Y7r4Q2JygaQbwfcBr24aZ5QKZ7v6WuzvwCDAuNF8MzAnL84AxFaMPERFpPJKawzCzi4DP3H1JguYeZva+mb1uZqeGWBegOG6d4hCraFsH4O6lwFagfTX7nWJmhWZWWFJSkkzqIiKSpJRD7WBmLYHbgbMTNG8Aurn7JjMbDjxrZgOBRCOGipFJTW2Vg+4PAA8AFBQU1DqyERGRunPIBQPoBfQAloQzR3nAe2Y2wt3/BuwFcPd3zWwV0JfYiCIvbht5wPqwXAx0BYrNLAXIIvEpMBGRpGSmNePGE9vSPTsVS/getelZvnx5je3p6enk5eWRmppaZ/s85ILh7kuBjhXPzWwtUODuX5hZDrDZ3cvMrCexye3V7r7ZzLab2UhgETAJ+G3YxPPAZOAt4DJgQZjnEBGpEzee2JZhvTqT0rINX5cp0mPzsqttc3c2bdpEcXExPXr0qLN9Rrmsdi6xF/N+ZlZsZlfVsPppwAdmtoTYBPa17l4xWpgK/BdQBKwCXgrxWUB7MysCbgFuS+pIRESq0T079WtVLGpjZrRv3549e/bU6XZrHWG4+4Ra2vPjlp8Gnq5mvUJgUIL4HuDy2vIQEUmWYUdNsahQH8erT3qLiEgkKhgiIo3Mgpfns+qvK450GgdRwRARaWT+8qf5rF75ccK20tLSBs7mgGQuqxURkUP0wh+e5PHZD1C67ysGHT+c26f/mlMGdGfildew8NU/kZaewW9mPca6T9bw2isvUbjoTR6851f8+v5H+NGtN3Lc8BEsLlzEiFNO47nfP87aVUWkpqaybds2hgwZwsqVK+v0EtpEVDBE5Kjy4BurWVOys0632SOnFd89tWe17atXfsyf/vgMc555mdTUVKb/4J958Znfs3vXTgYPK+DGf/lXZky/g6cff4QpN3+PUWedy2lnnsNZ51+8fxvbt21l9rz5AHy27lPmz5/PuHHjeOKJJ7j00kvrvViACoaISL1b9ObrLP9gCRMvGA3Anj17aNchh9QWLTj9zNj3sB47eChvv/Fatds458JL9i9fMuEfeOihmYwbN46HHnqIBx98sD7T308FQ0SOKjWNBOqLO1x4+Xhuvu3OSvE59/9u/+WvzZs3p6yG+YmMli33Lx9/wkj+/Uf/wuuvv05ZWRmDBh30iYV6oUlvEZF6duIpp/E/859n0xexL03dumUL64ur3hnigJatW7Nzx44atzlp0iQmTJjAFVdcUae51kQFQ0SknvXq25/rb72dqRMv4bKzTuGaid/ki42fV7v+2IsuYc79v+Xvxp7GurVrEq4zceJEtmzZwoQJNX62uk5ZU/3apoKCAi8sLDzkfvm3za+HbESkMXvwolw6dWv4U1H16a9v/w/PPfccjz76aLXrLF++nGOPPbZSzMzedfeCZPapOQwRkSbm3/71+/zfGwt48cUXG3S/KhgiIk3MtJ/+kiE1fFttfdEchoh87TlOUz39nqz6OF4VDBH52vvky32U7tp21BSNivthpKen1+l2dUpKRL72frtoCzcC3bO/+PrccW97Ro3tFXfcq0sqGCLytbdtbznTF2460mnUqbW/OL/B9xnljnuzzWyjmS1L0PY9M3Mz6xAXm2ZmRWb2sZmdExcfbmZLQ9s9Fj7eaGZpZvZkiC8ys/w6OjYREalDUeYwHgbGVg2aWVfgLODTuNgAYDwwMPS518yah+aZwBRi9/nuE7fNq4At7t4bmAHclcyBiIhI/aq1YLj7QmBzgqYZwPeB+Fmki4En3H2vu68hdv/uEWaWC2S6+1sem3V6BBgX12dOWJ4HjLGj7V6KIiJNQFJXSZnZRcBn7r6kSlMXYF3c8+IQ6xKWq8Yr9XH3UmAr0L6a/U4xs0IzKywpKUkmdRERSdIhFwwzawncDtyRqDlBzGuI19Tn4KD7A+5e4O4FOTk5UdIVEZE6kswIoxfQA1hiZmuBPOA9MzuG2Miha9y6ecD6EM9LECe+j5mlAFkkPgUmIiJH0CEXDHdf6u4d3T3f3fOJveAPc/e/Ac8D48OVTz2ITW6/4+4bgO1mNjLMT0wCngubfB6YHJYvAxb40fLpGhGRJiTKZbVzgbeAfmZWbGZXVbeuu38IPAV8BLwMXO/uZaF5KvBfxCbCVwEvhfgsoL2ZFQG3ALcleSwiIlKPav3gnrvX+GXrYZQR/3w6MD3BeoXAQbeFcvc9wOW15SEiIkeWvktKREQiUcEQEZFIVDBERCQSFQwREYlEBUNERCJRwRARkUhUMEREJBIVDBERiUQFQ0REIlHBEBGRSFQwREQkEhUMERGJRAVDREQiUcEQEZFIVDBERCQSFQwREYkkyh33ZpvZRjNbFhf7qZl9YGaLzezPZtY5xPPNbHeILzaz++L6DDezpWZWZGb3hFu1Em7n+mSILzKz/Ho4ThEROUxRRhgPA2OrxO529yHuPhR4Abgjrm2Vuw8Nj2vj4jOBKcTu890nbptXAVvcvTcwA7jrkI9CRETqXa0Fw90XApurxLbFPW0FeE3bMLNcINPd33J3Bx4BxoXmi4E5YXkeMKZi9CEiIo1H0nMYZjbdzNYBE6k8wuhhZu+b2etmdmqIdQGK49YpDrGKtnUA7l4KbAXaV7PPKWZWaGaFJSUlyaYuIiJJSLpguPvt7t4VeAy4IYQ3AN3c/XjgFuBxM8sEEo0YKkYlNbVV3ecD7l7g7gU5OTnJpi4iIkmoi6ukHgcuBXD3ve6+KSy/C6wC+hIbUeTF9ckD1oflYqArgJmlAFlUOQUmIiJHXlIFw8z6xD29CFgR4jlm1jws9yQ2ub3a3TcA281sZJifmAQ8F/o/D0wOy5cBC8I8h4iINCIpta1gZnOBUUAHMysG7gTOM7N+QDnwCVBxNdRpwE/MrBQoA65194rRwlRiV1xlAC+FB8As4FEzKyI2shh/+IclIiJ1rdaC4e4TEoRnVbPu08DT1bQVAoMSxPcAl9eWh4iIHFn6pLeIiESigiEiIpGoYIiISCQqGCIiEokKhoiIRKKCISIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiESigiEiIpGoYIiISCQqGCIiEkmtBcPMZpvZRjNbFhf7qZl9YGaLzezPZtY5rm2amRWZ2cdmdk5cfLiZLQ1t94RbtWJmaWb2ZIgvMrP8Oj5GERGpA1FGGA8DY6vE7nb3Ie4+FHgBuAPAzAYQu8XqwNDn3op7fAMzgSnE7vPdJ26bVwFb3L03MAO4K9mDERGR+lNrwXD3hcTutR0f2xb3tBXgYfli4Al33+vua4AiYISZ5QKZ7v6WuzvwCDAurs+csDwPGFMx+hARkcaj1nt6V8fMpgOTgK3AGSHcBXg7brXiENsXlqvGK/qsA3D3UjPbCrQHvkg2NxERqXtJT3q7++3u3hV4DLghhBONDLyGeE19DmJmU8ys0MwKS0pKDjVlERE5DHVxldTjwKVhuRjoGteWB6wP8bwE8Up9zCwFyKLKKbAK7v6Auxe4e0FOTk4dpC4iIlElVTDMrE/c04uAFWH5eWB8uPKpB7HJ7XfcfQOw3cxGhvmJScBzcX0mh+XLgAVhnkNERBqRWucwzGwuMAroYGbFwJ3AeWbWDygHPgGuBXD3D83sKeAjoBS43t3LwqamErviKgN4KTwAZgGPmlkRsZHF+Do5MhERqVO1Fgx3n5AgPKuG9acD0xPEC4FBCeJ7gMtry0NERI4sfdJbREQiUcEQEZFIVDBERCQSFQwREYlEBUNERCJRwRARkUhUMEREJBIVDBERiUQFQ0REIlHBEBGRSFQwREQkEhUMERGJRAVDREQiUcEQEZFIVDBERCQSFQwREYlEBUNERCKptWCY2Wwz22hmy+Jid5vZCjP7wMyeMbPsEM83s91mtjg87ovrM9zMlppZkZndE+7tTbj/95MhvsjM8uv+MEVE5HBFGWE8DIytEnsFGOTuQ4C/AtPi2la5+9DwuDYuPhOYAvQJj4ptXgVscffewAzgrkM+CpEjoP8xbSKt1yb9wJ2Qh+Rl1bhu1fbU5sb8m77BY1efeOgJNjI9c1o16P5+f+1JDbq/KH54/rGR1ps5cRgAHVq32B976eZTeXBSAQD/8fdD6zy3KGotGO6+ENhcJfZndy8NT98G8mrahpnlApnu/pa7O/AIMC40XwzMCcvzgDEVow+RIykjtTkf/OjsattH9esIwHdOzq9xO29NG7N/eUz/TvuX4wtOxzZpAIzs2b5S3zOP7cTAzlmc0rtD5LwbytNTD+0F+cWbTuXdH55Z63oDO2fuX37nB2NqWLN6mekpnJDfLqm+9enkXon/Hz/88TmVnp87OJfnbziFN28bvT92bG4mZw3oxNpfnM+447vUa57VqYs5jCuBl+Ke9zCz983sdTM7NcS6AMVx6xSHWEXbOoBQhLYClf9qAjObYmaFZlZYUlJSB6nL11XPDq0Y3T/2gn7+4NyktpHdMpXM9NT9z9ukpXD3ZUPITE9hyR1nc/OYPnx/bD9+eP6xzL/pG9w0ujcAN47uzWXD8zi5V3uemDKS1mkHRhjXnN6TmROHMf6Erjx0xQk8PfVkZk0u4OmpJ3PXpYNJaRZ7rzSsWzY/OK8/v7hkSI05njvoGDJSm5PfviXPXn8KJ/U8+E+nXasWCXrCGf1yGH9C1xq3P25o5/3LsyYXMC/uXfvw7u0YO/CYGvsDfO/svjx7/Smkpzanfes0fv7NwTWu37VtS+6dOIz5N32DjpnptElL4cLjOjO8e1vO6JdTad3nrj+Fvyuo/H512rn9+eON3wDg15cfV2nd2d8pOGh/x3fL5jfjh9Z6HNUZ3CWL47pmM/e7IxO2//GGbySM57dvyZ/+8TR+M34ordJSKhUHgCF52aSlNE86r/qQUvsq1TOz24FS4LEQ2gB0c/dNZjYceNbMBgKJRgxesZka2ioH3R8AHgAoKChIuI4cHUb1y+G1j6t/0zD/plO597UiFqzYSL9j2vCfE4eRf9v8SNte/pOxHHvHy1x5So9K8f65bbi8oCuXFxx4kb1uVKxIDOycxcDOWdxydr+E27zmtJ7cv3A16anNOXdwLueGIpablbF/nb9v1413P9nMva+t4scXDWJwldNTN47uzW8XFO1/vvYX5x+0nwknduOt1Zv2Px+R346fXzKYM//9dQD6dGzNK7ecXqnPLy4dsv9n84Pz+vPzF1cAsdMnV5/ak+Itu1m7aSdjju1EVff9w/D9y7c/s5THFn3KT8cNYnXJDh56c23CHL91Yjd+t2Al67fuAWIvuEs/28rUUb2Y+doqAM6LK/JLq7z7/uOS9dw4933enjaGY7LSOa5rNj+8YADX/fd7/PKyIXTOPvAzvXR4HvkdWjLrf9cwuEsWzZod/HLznZPzuei4ztz8xOL9sc5Z6azfuoc3bxtNl+yMg353umRn8NmXuwG4blSv/f+fiQzonEn/Y9qw4m/bAZh4YjceW/Qpr916BgD9wkizS3YGI3q0Y+Xn2yv1z26ZGvn0Z31LumCY2WTgAmBMOM2Eu+8F9obld81sFdCX2Igi/m1AHrA+LBcDXYFiM0sBsqhyCkykqhE92rFl1z6WrPtyf6x7+5Z8smkXABktmnNSz/b8dkERI3rUfGrioStO4IqH/g848CKc6IXucEw771imnVf7+evh3dtVu+9/Prsfm3Z+xeOLPq22/0XHdeamue9XivXu2LrW4+nTsTUrN+5gymm9+PmLK/jWid24+tSeAMybenKldavb1qh+HXls0accl5fFP4zszp0XDqx2f+UJ3u716xR7UTxrwMGFKd6Fx3XmwuM6V4plpqfy39XM8wzv3o7h3Q/8DrRq0ZydX5Xtf37x0Mqnd2Z/p4B/ffbDWJ6JEgXevG001z76Li9/+Lcac01k+jcHM72aUdZT1xx8mm/xHdWfFm1oSZ2SMrOxwL8AF7n7rrh4jpk1D8s9iU1ur3b3DcB2MxsZ5icmAc+Fbs8Dk8PyZcCCigIkUpN/PLNPpeevVnnnfHLvDiz/ydiD5gWuG9Wr0vPqXhQao4o3yHdcMKBOt/vSzafy15+dC8CKn47lZxcPOuRtnDWgEyt+OpYhedm1rusJTiL0zGnF8p+M5dLhNU6JHrbFd9b8Ajy6fyeahVdGvRJVVusIw8zmAqOADmZWDNxJ7KqoNOCVMD/9drgi6jTgJ2ZWCpQB17p7xWhhKrErrjKIzXlUzHvMAh41syJiI4vxdXJk8rWWmZ5KqxaVf31Tmh/8/iejxcHngNNTK8eaUL2gWbgepHmCUyuHI/5nV/Xncyii9q3uZ57o/6uupSb4Pamq4udcropRSa0Fw90nJAjPqmbdp4Gnq2krBA562+Lue4DLa8tDBGBQl0zGn9CNCSO60czgpjF9uOfVlXx7ZDcArj+jF4O7ZCfs+8SUkTy/ZD2TTurOB8VfctOYPtz7l1Wc2qcD087tT9uWiSeH5353JBMefJu7LzsuYXtDumF0b9Z/uYdLhlV/lcxvxg9lVclOVm3cwT+d1bcBs4vusatP5OwZC3nmupNplZbCPa+u5NjczNo71pFvndiN1SU7mHhi9/2x1ObG6X1jF0rcO3EYDy5cTdd2LQGYfFJ3zhpwDCU79vDZltjcxQ8vOBbHOSNcXAFw5Sk9OK1vB9Zt3sWiNZtpnZZCM4PfjD+e3/2liL6dWjfYMdYHa6pnfwoKCrywsPCQ+0Wd+JSGNXPisIMmDsvLnZ4/eJE7LxzAFVUmoEUkOWb2rrsffLlYBId1lZRIbV6/dRSn3/0aAL1yWrGqZGel9pomY5s1szqffBaR5KlgHGWW3Hk2KzZso0ObNMb8+vX9V8dE0bdTazJSm7OkeGu16zw4qYDvPhIb+f3le6Po3r4Vi+84i7Jyp33rNI3wRJqwo65gLPvxOfz21ZXcv3D1YW+rS3YGu/eVsXnnV4fU78pTejD7zTWR1z9rQCfapKfwh/c+A2KXj5aWOVt2fcU5A4/h9L45lJY7P5v/EX06tmbj9r1cfWpP7nhu2f6rPNq3asENo3uTlZHKieGqoT9cdzI92rfi6feK+dn85QDMu/Yk9uwrZ80XO1gXztXu+qqUvfvKuXVsP0rLnKcK19HMjA1b92AGjy/6lFvP6ceefWWM6d+Rx68+kY3b99KjQ+yrILLj5gbmXDmC7Xv2sfurMrq3b9ivihCRw3PUzWGIiBzNDmcOQ19vLiIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgkKhgiIhKJCoaIiETSZD+4Z2YlwCdJdu8AfFGH6dS3ppYvNL2clW/9Ur71L2rO3d09p/bVDtZkC8bhMLPCZD/peCQ0tXyh6eWsfOuX8q1/DZGzTkmJiEgkKhgiIhLJ0VowHjjSCRyippYvNL2clW/9Ur71r95zPirnMERE5NAdrSMMERE5RCoYIiISyVFXMMxsrJl9bGZFZnZbA+63q5n9xcyWm9mHZnZziLczs1fMbGX4t21cn2khz4/N7Jy4+HAzWxra7jEzC/E0M3syxBeZWX4d5N3czN43sxeaSL7ZZjbPzFaEn/VJjTlnM/un8PuwzMzmmll6Y8rXzGab2UYzWxYXa5D8zGxy2MdKM5t8GPneHX4fPjCzZ8wsu7HkW13OcW3fMzM3sw6NImd3P2oeQHNgFdATaAEsAQY00L5zgWFhuQ3wV2AA8EvgthC/DbgrLA8I+aUBPULezUPbO8BJgAEvAeeG+HXAfWF5PPBkHeR9C/A48EJ43tjznQNcHZZbANmNNWegC7AGyAjPnwK+05jyBU4DhgHL4mL1nh/QDlgd/m0bltsmme/ZQEpYvqsx5VtdziHeFfgTsQ8od2gMOTfYi3VjeIQf5p/ink8Dph2hXJ4DzgI+BnJDLBf4OFFu4RfnpLDOirj4BOD++HXCcgqxT33aYeSYB7wKjOZAwWjM+WYSewG2KvFGmTOxgrEu/MGmAC8Qe3FrVPkC+VR+Aa73/OLXCW33AxOSybdK2zeBxxpTvtXlDMwDjgPWcqBgHNGcj7ZTUhV/oBWKQ6xBhSHh8cAioJO7bwAI/3YMq1WXa5ewXDVeqY+7lwJbgfaHkep/AN8HyuNijTnfnkAJ8JDFTqP9l5m1aqw5u/tnwK+AT4ENwFZ3/3NjzTdOQ+RXX3+rVxJ7992o8zWzi4DP3H1JlaYjmvPRVjAsQaxBrys2s9bA08A/uvu2mlZNEPMa4jX1OWRmdgGw0d3fjdqlmn03SL5BCrGh/Ux3Px7YSeyUSXWO9M+4LXAxsVMLnYFWZvbtmrpUs++G/BnXpC7zq/O8zex2oBR47DD2Xe/5mllL4HbgjkTNSey/znI+2gpGMbHzghXygPUNtXMzSyVWLB5z9z+E8Odmlhvac4GNteRaHJarxiv1MbMUIAvYnGS6pwAXmdla4AlgtJn9dyPOt2J7xe6+KDyfR6yANNaczwTWuHuJu+8D/gCc3IjzrdAQ+dXp32qY0L0AmOjh/EsjzrcXsTcRS8LfXx7wnpkdc8RzTubca1N9EHsHujr8Z1RMeg9soH0b8AjwH1Xid1N5AvGXYXkglSe3VnNgcuv/gJEcmNw6L8Svp/Lk1lN1lPsoDsxhNOp8gTeAfmH5RyHfRpkzcCLwIdAy7GcOcGNjy5eD5zDqPT9i8zpriE3Gtg3L7ZLMdyzwEZBTZb1GkW+inKu0reXAHMYRzbneXygb2wM4j9gVSquA2xtwv98gNtz7AFgcHucRO5f4KrAy/Nsurs/tIc+PCVc8hHgBsCy0/Y4Dn9hPB34PFBG7YqJnHeU+igMFo1HnCwwFCsPP+dnwh9BocwZ+DKwI+3o0vBA0mnyBucTmV/YRe0d6VUPlR2y+oSg8rjiMfIuInatfHB73NZZ8q8u5SvtaQsE40jnrq0FERCSSo20OQ0REkqSCISIikahgiIhIJCoYIiISiQqGiIhEooIhIiKRqGCIiEgk/x89fernmA4tMgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10].ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10].ipynb new file mode 100644 index 0000000..5153004 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations [0,2,10].ipynb @@ -0,0 +1,1159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.3333, 0.0000, 0.3333, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.3333, 0.0000])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/3\n", + "adversaryProbs[2]=1/3\n", + "adversaryProbs[10]=1/3\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=2)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000, 0.0000, 0.0000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "95" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0001)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=5_000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 3, 0, 17, 11, 19, 24, 37, 33, 33, 26, 10, 19, 21, 17, 17, 27, 6, 41,\n", + " 25, 42, 49, 1, 41, 36, 16])\n", + "loss= tensor(717.2204, grad_fn=) , actor= tensor(243.0031, grad_fn=) , critic= tensor(4742.1733, grad_fn=) , return= 101950.55299710043\n", + "probs of actions: tensor([0.0208, 0.0219, 0.0233, 0.0165, 0.0234, 0.0201, 0.0211, 0.0220, 0.0220,\n", + " 0.0186, 0.0178, 0.0232, 0.0176, 0.0230, 0.0230, 0.0191, 0.0200, 0.0198,\n", + " 0.0177, 0.0208, 0.0175, 0.0194, 0.0199, 0.0183, 0.0213],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([38, 23, 14, 48, 2, 17, 37, 23, 13, 1, 30, 1, 26, 2, 46, 6, 8, 6,\n", + " 48, 6, 46, 32, 19, 0, 26])\n", + "loss= tensor(97.8313, grad_fn=) , actor= tensor(-209.1528, grad_fn=) , critic= tensor(3069.8416, grad_fn=) , return= 23488.4774284773\n", + "probs of actions: tensor([0.0215, 0.0235, 0.0185, 0.0159, 0.0181, 0.0272, 0.0212, 0.0228, 0.0178,\n", + " 0.0176, 0.0197, 0.0178, 0.0221, 0.0174, 0.0211, 0.0177, 0.0202, 0.0176,\n", + " 0.0153, 0.0178, 0.0211, 0.0226, 0.0253, 0.0189, 0.0221],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 8, 42, 21, 15, 47, 36, 5, 23, 33, 42, 27, 42, 19, 18, 30, 19, 18, 21,\n", + " 17, 16, 28, 46, 38, 17, 13])\n", + "loss= tensor(20.4730, grad_fn=) , actor= tensor(-45.3652, grad_fn=) , critic= tensor(658.3814, grad_fn=) , return= 86712.67142582132\n", + "probs of actions: tensor([0.0129, 0.0133, 0.0242, 0.0175, 0.0179, 0.0205, 0.0147, 0.0319, 0.0208,\n", + " 0.0137, 0.0144, 0.0137, 0.0405, 0.0329, 0.0241, 0.0403, 0.0331, 0.0238,\n", + " 0.0358, 0.0230, 0.0253, 0.0163, 0.0214, 0.0353, 0.0136],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([19, 37, 32, 31, 29, 37, 37, 38, 2, 19, 18, 24, 29, 37, 19, 38, 37, 35,\n", + " 19, 33, 35, 28, 21, 28, 30])\n", + "loss= tensor(26.8976, grad_fn=) , actor= tensor(-33.7222, grad_fn=) , critic= tensor(606.1981, grad_fn=) , return= 91237.81174905808\n", + "probs of actions: tensor([0.0918, 0.0756, 0.0594, 0.0578, 0.0576, 0.0810, 0.0808, 0.0305, 0.0017,\n", + " 0.0990, 0.0390, 0.0909, 0.0587, 0.0794, 0.0952, 0.0312, 0.0778, 0.0122,\n", + " 0.0937, 0.0137, 0.0124, 0.0534, 0.0166, 0.0530, 0.0315],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([46, 32, 45, 37, 32, 16, 24, 24, 28, 29, 24, 37, 24, 37, 24, 37, 24, 19,\n", + " 32, 29, 19, 24, 18, 32, 28])\n", + "loss= tensor(167.8423, grad_fn=) , actor= tensor(-139.0603, grad_fn=) , critic= tensor(3069.0261, grad_fn=) , return= 11534.49268968086\n", + "probs of actions: tensor([0.0019, 0.0294, 0.0082, 0.0551, 0.0287, 0.0283, 0.1407, 0.1368, 0.1367,\n", + " 0.0603, 0.1293, 0.0574, 0.1249, 0.0570, 0.1222, 0.0566, 0.1199, 0.1065,\n", + " 0.0326, 0.0602, 0.1040, 0.1165, 0.0641, 0.0331, 0.1064],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([22, 28, 28, 28, 28, 22, 28, 22, 19, 28, 28, 19, 28, 28, 19, 22, 19, 28,\n", + " 28, 19, 28, 19, 22, 24, 29])\n", + "loss= tensor(54.0024, grad_fn=) , actor= tensor(-36.5485, grad_fn=) , critic= tensor(905.5095, grad_fn=) , return= 86997.3188949405\n", + "probs of actions: tensor([0.2264, 0.4877, 0.5238, 0.5238, 0.5228, 0.2233, 0.5191, 0.2239, 0.1041,\n", + " 0.5075, 0.5009, 0.1072, 0.4922, 0.4846, 0.1104, 0.2266, 0.1122, 0.4647,\n", + " 0.4577, 0.1147, 0.4511, 0.1160, 0.2266, 0.0296, 0.0368],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "60000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 22, 22, 28, 28, 22, 22, 28, 19, 28, 28, 19, 22, 22, 28, 28, 28, 28,\n", + " 22, 28, 29, 28, 28, 22, 29])\n", + "loss= tensor(132.9879, grad_fn=) , actor= tensor(-46.8980, grad_fn=) , critic= tensor(1798.8589, grad_fn=) , return= 64518.7187109095\n", + "probs of actions: tensor([0.3462, 0.3919, 0.4008, 0.4046, 0.4072, 0.3953, 0.3935, 0.4094, 0.0822,\n", + " 0.4066, 0.4041, 0.0853, 0.3803, 0.3780, 0.3913, 0.3875, 0.3845, 0.3816,\n", + " 0.3703, 0.3764, 0.0732, 0.3698, 0.3673, 0.3635, 0.0758],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "70000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 28, 28, 28, 28, 28, 28, 28, 22, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 19, 28])\n", + "loss= tensor(307.6733, grad_fn=) , actor= tensor(9.7054, grad_fn=) , critic= tensor(2979.6790, grad_fn=) , return= 172204.06456676548\n", + "probs of actions: tensor([0.1205, 0.8189, 0.8587, 0.8589, 0.8592, 0.8594, 0.8595, 0.8594, 0.0728,\n", + " 0.8586, 0.8572, 0.8558, 0.8539, 0.8519, 0.8495, 0.8469, 0.8442, 0.8413,\n", + " 0.8384, 0.8353, 0.8323, 0.8291, 0.8260, 0.0193, 0.8205],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "80000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(332.7245, grad_fn=) , actor= tensor(0.1050, grad_fn=) , critic= tensor(3326.1946, grad_fn=) , return= 172603.3335190018\n", + "probs of actions: tensor([0.9910, 0.9955, 0.9978, 0.9979, 0.9979, 0.9979, 0.9979, 0.9979, 0.9979,\n", + " 0.9978, 0.9978, 0.9977, 0.9976, 0.9975, 0.9974, 0.9973, 0.9972, 0.9970,\n", + " 0.9969, 0.9967, 0.9965, 0.9964, 0.9962, 0.9960, 0.9958],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "90000 adversary: AdversaryModes.constant_95\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(62.1783, grad_fn=) , actor= tensor(-0.0641, grad_fn=) , critic= tensor(622.4248, grad_fn=) , return= 92270.95743178323\n", + "probs of actions: tensor([0.9854, 0.9918, 0.9957, 0.9959, 0.9960, 0.9961, 0.9961, 0.9960, 0.9959,\n", + " 0.9958, 0.9956, 0.9954, 0.9952, 0.9949, 0.9946, 0.9943, 0.9940, 0.9937,\n", + " 0.9933, 0.9930, 0.9926, 0.9922, 0.9918, 0.9914, 0.9910],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "100000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(164.2230, grad_fn=) , actor= tensor(-0.2165, grad_fn=) , critic= tensor(1644.3943, grad_fn=) , return= 67918.99934306632\n", + "probs of actions: tensor([0.9907, 0.9941, 0.9967, 0.9966, 0.9967, 0.9967, 0.9966, 0.9965, 0.9963,\n", + " 0.9961, 0.9958, 0.9955, 0.9953, 0.9950, 0.9946, 0.9943, 0.9939, 0.9936,\n", + " 0.9932, 0.9927, 0.9923, 0.9919, 0.9915, 0.9910, 0.9906],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "110000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 26, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(409.8947, grad_fn=) , actor= tensor(18.5458, grad_fn=) , critic= tensor(3913.4888, grad_fn=) , return= 172533.8413922184\n", + "probs of actions: tensor([9.6612e-01, 9.7801e-01, 9.8760e-01, 9.8784e-01, 9.8804e-01, 9.8817e-01,\n", + " 9.8822e-01, 9.8811e-01, 9.8791e-01, 9.8764e-01, 9.8728e-01, 9.8685e-01,\n", + " 9.8640e-01, 9.8588e-01, 1.5069e-04, 9.8472e-01, 9.8396e-01, 9.8326e-01,\n", + " 9.8248e-01, 9.8167e-01, 9.8082e-01, 9.7993e-01, 9.7901e-01, 9.7807e-01,\n", + " 9.7709e-01], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "120000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 28, 28, 44, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(77.8203, grad_fn=) , actor= tensor(0.3534, grad_fn=) , critic= tensor(774.6689, grad_fn=) , return= 68723.20956676225\n", + "probs of actions: tensor([9.6758e-01, 9.7788e-01, 9.8639e-01, 7.5353e-04, 9.8556e-01, 9.8645e-01,\n", + " 9.8631e-01, 9.8595e-01, 9.8540e-01, 9.8480e-01, 9.8400e-01, 9.8306e-01,\n", + " 9.8206e-01, 9.8098e-01, 9.7982e-01, 9.7861e-01, 9.7734e-01, 9.7604e-01,\n", + " 9.7469e-01, 9.7332e-01, 9.7192e-01, 9.7051e-01, 9.6908e-01, 9.6764e-01,\n", + " 9.6618e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "130000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 24, 28, 24, 28, 28, 28, 28, 28, 28, 28, 28, 28, 24, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(312.1692, grad_fn=) , actor= tensor(28.4435, grad_fn=) , critic= tensor(2837.2573, grad_fn=) , return= 172168.3461424557\n", + "probs of actions: tensor([0.9175, 0.9367, 0.9555, 0.0200, 0.9569, 0.0199, 0.9564, 0.9554, 0.9546,\n", + " 0.9535, 0.9523, 0.9511, 0.9497, 0.9482, 0.9466, 0.0240, 0.9435, 0.9412,\n", + " 0.9394, 0.9373, 0.9353, 0.9332, 0.9312, 0.9290, 0.9269],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "140000 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(128.4633, grad_fn=) , actor= tensor(-0.0592, grad_fn=) , critic= tensor(1285.2253, grad_fn=) , return= 67918.99934306632\n", + "probs of actions: tensor([0.9958, 0.9977, 0.9988, 0.9988, 0.9988, 0.9989, 0.9989, 0.9988, 0.9988,\n", + " 0.9987, 0.9986, 0.9986, 0.9985, 0.9983, 0.9982, 0.9981, 0.9980, 0.9978,\n", + " 0.9977, 0.9975, 0.9973, 0.9972, 0.9970, 0.9968, 0.9967],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "150000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(280.3754, grad_fn=) , actor= tensor(0.0324, grad_fn=) , critic= tensor(2803.4292, grad_fn=) , return= 172603.3335190018\n", + "probs of actions: tensor([0.9968, 0.9982, 0.9991, 0.9991, 0.9991, 0.9991, 0.9991, 0.9991, 0.9991,\n", + " 0.9991, 0.9991, 0.9990, 0.9990, 0.9989, 0.9989, 0.9988, 0.9988, 0.9987,\n", + " 0.9986, 0.9985, 0.9985, 0.9984, 0.9983, 0.9982, 0.9981],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "160000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 28, 44, 28, 28, 28, 28, 28, 28, 28, 28, 28, 44, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(321.1606, grad_fn=) , actor= tensor(29.0940, grad_fn=) , critic= tensor(2920.6660, grad_fn=) , return= 173377.01473396842\n", + "probs of actions: tensor([0.0308, 0.9302, 0.0214, 0.9503, 0.9524, 0.9522, 0.9518, 0.9511, 0.9502,\n", + " 0.9491, 0.9477, 0.9461, 0.0254, 0.9401, 0.9399, 0.9372, 0.9351, 0.9327,\n", + " 0.9302, 0.9276, 0.9249, 0.9221, 0.9193, 0.9163, 0.9134],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "170000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(352.2539, grad_fn=) , actor= tensor(0.1647, grad_fn=) , critic= tensor(3520.8921, grad_fn=) , return= 172603.3335190018\n", + "probs of actions: tensor([0.9899, 0.9940, 0.9966, 0.9967, 0.9967, 0.9967, 0.9967, 0.9966, 0.9966,\n", + " 0.9965, 0.9963, 0.9962, 0.9960, 0.9958, 0.9956, 0.9954, 0.9952, 0.9949,\n", + " 0.9947, 0.9944, 0.9941, 0.9938, 0.9935, 0.9931, 0.9928],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "178102 adversary: AdversaryModes.guess_132\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 28])\n", + "loss= tensor(88.8568, grad_fn=) , actor= tensor(-0.0114, grad_fn=) , critic= tensor(888.6818, grad_fn=) , return= 67918.99934306632\n", + "probs of actions: tensor([0.9990, 0.9995, 0.9998, 0.9998, 0.9998, 0.9998, 0.9998, 0.9998, 0.9997,\n", + " 0.9997, 0.9997, 0.9997, 0.9996, 0.9996, 0.9996, 0.9995, 0.9995, 0.9994,\n", + " 0.9994, 0.9993, 0.9993, 0.9992, 0.9992, 0.9991, 0.9991],\n", + " grad_fn=)\n", + "shouldBreak: True\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])\n", + "loss = pd.DataFrame(algorithm.loss[0],columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.000000200.000000
1215.750000184.250000
2203.062500196.937500
3193.546875206.453125
4186.410156213.589844
5181.057617218.942383
6177.043213222.956787
7174.032410225.967590
8171.774307228.225693
9170.080730229.919270
10168.810548231.189452
11167.857911232.142089
12167.143433232.856567
13166.607575233.392425
14166.205681233.794319
15165.904261234.095739
16165.678196234.321804
17165.508647234.491353
18165.381485234.618515
19165.286114234.713886
20165.214585234.785415
21165.160939234.839061
22165.120704234.879296
23165.090528234.909472
24165.067896234.932104
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.000000 200.000000\n", + "1 215.750000 184.250000\n", + "2 203.062500 196.937500\n", + "3 193.546875 206.453125\n", + "4 186.410156 213.589844\n", + "5 181.057617 218.942383\n", + "6 177.043213 222.956787\n", + "7 174.032410 225.967590\n", + "8 171.774307 228.225693\n", + "9 170.080730 229.919270\n", + "10 168.810548 231.189452\n", + "11 167.857911 232.142089\n", + "12 167.143433 232.856567\n", + "13 166.607575 233.392425\n", + "14 166.205681 233.794319\n", + "15 165.904261 234.095739\n", + "16 165.678196 234.321804\n", + "17 165.508647 234.491353\n", + "18 165.381485 234.618515\n", + "19 165.286114 234.713886\n", + "20 165.214585 234.785415\n", + "21 165.160939 234.839061\n", + "22 165.120704 234.879296\n", + "23 165.090528 234.909472\n", + "24 165.067896 234.932104" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAD4CAYAAAANbUbJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAtpUlEQVR4nO3deXxU9b3/8ddnZrJBAiEbSxJIIOwoIIGioOCC4FLQWhV7a7VoUS9ttdf2V237a21vube77a3XKoqKv4oLFQU3FK0gKLIWZA2EPYAkLIGEkGVmvr8/zgmEELLNTE5m5vN8POZxzvmeM3M+w+h7Tr7zPeeIMQallFKRzeV0AUoppUJPw14ppaKAhr1SSkUBDXullIoCGvZKKRUFPE4XAJCWlmZycnKcLkMppcLK2rVrjxhj0puzbbsI+5ycHNasWeN0GUopFVZEZG9zt9VuHKWUigIa9kopFQU07JVSKgq0iz77htTU1FBUVERlZaXTpTQqPj6erKwsYmJinC5FKaUuqN2GfVFREUlJSeTk5CAiTpfTIGMMR48epaioiNzcXKfLUUqpC2q33TiVlZWkpqa226AHEBFSU1Pb/V8fSinVbsMeaNdBXyscalRKqXbbjaOUUhgDfm+9h+/s1Pjsqb/Oct11/nO3Mfay8duvXbe93rpz2v3nt2PqbXeBdWfmTcPtGQNhyNdC/k+pYd+ERYsW8eCDD+Lz+bj33nt55JFHnC5JqeDy+6DmtP2oAG+lNa1t81WDt8qeVtaZr7Lnq8BbbU8rwVdjP6qt4PVVn23z2+0+u91f214/yO2H8Tv9rxNiYgW9hr2zfD4fM2bMYPHixWRlZTFy5EgmT57MoEGDnC5NRSu/H6pOQmUpVJVBVTlU24+qutPadafstjJrvjbQa06Dt06YB8IdC+448NSZumLsdo81dcXY6xPtdbWPWHC5rTaXx2pzua35M4/6yx4Ql9Uu7npT19nnnNNmL4urzrILRM5tr7sOAZfr7HzdbaTeMpzbfmZ7ufB8G3cBa9g3YtWqVeTl5dG7d28Apk6dyoIFCzTsVeCMgcoTcKoEyouh4qgV4KdL4fTxs/OV9nLtfOWJ5h3tuuMgtiPEJUJskjWN7wRJ3SCmA8TE29ME8CRY07qP2jZPPHji7Ee8Fc61y+44O6zb9U9/yhYWYf/Ltzaz5eDJoL7moB6d+MVXBze6zYEDB8jOzj6znJWVxcqVK4Nah4owVeVw8gCUH7ZCvDbMTxVDeUmdaYnV7dEQcUNCMsQnW9MOqZDS59y2+GQrvGMTIS7JniZa09hE6yhaqTrCIuyd0tD9eXX0TRQzxgruE0VwYp81Ld0PJ+xH6X7r6Ls+cUPHdEhMh44ZkD7AXs6wlhPToUOaFeIJXayw1v/OVJCFRdg3dQQeKllZWezfv//MclFRET169HCkFtVG/D4o3QdHdsCRAjiyHY7vtQO+6Pyj8dgkSM6GztmQ/RXonAWdsqwgrw3zhC7a1aEcFxZh75SRI0eyY8cOdu/eTWZmJq+88gpz5851uiwVDDWVcGwnlNiBXlJgBfzRHdaIklod0iAlF7pfDANugOSeVqB3zramCcmOvQWlWkLDvhEej4cnnniCiRMn4vP5mDZtGoMHO/NXhgpA2WE4sNZ6HN5kBXvp3jo/dIoV4un9ofc4SOtnzaf1gw4pjpauVLBo2Dfh+uuv5/rrr3e6DNVc1afg4Ho73NfAgXVWfzpYfefp/aH7ULj4NivM0/pBah7EdnC0bKVCTcNehS+/D4q3nhvsxVvOHrEn94KskTD6AcgcAd0u1lBXUUvDXoWXY7tgx4dQ+CHsWQ41p6z2+GQr0PtfD1n50OMSa5SLUgpoRtiLSDbwItAN8AOzjDF/EZH/BKbYbcXA3caYg/ZzHgXuAXzA940x74eofhXpqiusUC/8EAoXW2EPkNIbht0BWaOscE/prcMVlWpEc47svcDDxph1IpIErBWRxcDvjTH/F0BEvg/8HLhfRAYBU4HBQA/gQxHpZ4zxheYtqIhijDUqpjbc93xqDXf0JEDu5fCVByDvakjt43SlSoWVJsPeGHMIOGTPl4nIViDTGLOlzmYdgdozkKYArxhjqoDdIlIIjAJWBLVyFTl8NVD4Eez4wAr40n1We1o/GHmvFe69xlin+CulWqVFffYikgMMB1bayzOBbwEngCvtzTKBz+s8rchuq/9a04HpAD179mxh2SoiHN4M/3oJvngVKo5ATEdr6OOYhyDvGujSy+kKlYoYzQ57EUkEXgceMsacBDDG/BT4qd1H/13gF0BDHafnXXfAGDMLmAWQn59//nUJ2oFp06bx9ttvk5GRwaZNm5wuJzJUHION/4D1f4dDG6yrHfa/Dob9G/S5Sq/polSINOscbhGJwQr6l4wx8xvYZC5wiz1fBGTXWZcFHAykSKfcfffdLFq0yOkywp/PC9s/gNfugj/2h/d+ZA2PnPRbeLgAbv9/0H+SBr1SIdSc0TgCzAa2GmP+VKe9rzFmh704Gdhmzy8E5orIn7B+oO0LrApq1W3kiiuuYM+ePU6XEb5KtsP6l2DDK1D+pXX1xvx7YNg3rMsPKKXaTHO6ccYAdwIbRWS93fYT4B4R6Y819HIvcD+AMWaziLwGbMEayTMj4JE47z0CX24M6CXO0+0iuO43wX1NZR3Fb5wHa2ZD0WrrrNW+11oB30+P3pVySnNG4yyn4X74dxt5zkxgZgB1qXBTG/Kf/M4aC5/WHyb8J1x8OyR1dbo6paJeeJxBq0fg7ZffZ/3g+snv4Gih9RfT1LnWmax6kpNS7UZ4hL1qf/w+2DQflv7Wuixw1yFw+9+h/w167Xal2iH9v7IRd9xxB5deeikFBQVkZWUxe/Zsp0tyXu2R/JOXwvx7rRtE3/Yi3LcMBn5Vg16pdkqP7Bvx8ssvO11C++H3w5Y3rSP5km2QPhBufQEGTtGAVyoMaNirxvn9sHUBLPktlGy1fnj9+nMw6GYNeaXCiIa9urDje2DBd2HPMus6NbfMhsE3g8vtdGVKqRZq12FvjEHa+YgOY9rllR4C4/fD2ufgg5+DuODGP8Ml39KQVyqMtduwj4+P5+jRo6SmprbbwDfGcPToUeLjI+hqjKX7rKP53Uuh93iY/AQkZzf5NKVU+9Zuwz4rK4uioiJKSkqcLqVR8fHxZGVlOV1G4IyBdXPg/Z8BxjqaH3G3jpVXKkK027CPiYkhNzfX6TKiw4kiWPh92PkR5FwOU/5XLy+sVIRpt2Gv2oAx1oXKFj0Kfi9c/wfrQmU6ykapiKNhH61OHoK3vm/dHarXGOtoPkX/klIqUmnYRxtjrDtDvfd/wFttXVN+1HQ9mlcqwmnYR5PKE/DGA1DwDmSPhpue1Bt3KxUlNOyjxclD8NLXrUsdXPtrGP3vOm5eqSiiYR8NSrbD32+B08fgG69B3tVOV6SUamMa9pFu/yqYexu4PHD3O9BjmNMVKaUcoL/KRbKC92DOZEjoAvd8oEGvVBTTsI9Ua+fAK9+AjIEw7QNI6e10RUopBzUZ9iKSLSIfi8hWEdksIg/a7b8XkW0i8oWIvCEiyXWe86iIFIpIgYhMDGH9qj5jYMlvrDH0fa6Gu96CxHSnq1JKOaw5R/Ze4GFjzEBgNDBDRAYBi4EhxpiLge3AowD2uqnAYGAS8KSI6LCPtuDzwlsPwpL/hmH/Bne8DHGJTlellGoHmgx7Y8whY8w6e74M2ApkGmM+MMZ47c0+B2qvBjYFeMUYU2WM2Q0UAqOCX7o6R3UFvHandTGzyx+2zoh1xzhdlVKqnWjRaBwRyQGGAyvrrZoGvGrPZ2KFf60iu63+a00HpgP07NmzJWWo+iqOwdzboWi1dX2bUd9xuiKlVDvT7B9oRSQReB14yBhzsk77T7G6el6qbWrg6efd4cMYM8sYk2+MyU9P1z7lVivdB89NhEMb4LY5GvRKqQY168heRGKwgv4lY8z8Ou13ATcCV5uzt2wqAure7SILOBicctU5vtxknSzlPQ3fehN6XeZ0RUqpdqo5o3EEmA1sNcb8qU77JODHwGRjTEWdpywEpopInIjkAn2BVcEtW3F8L7w4xbpt4LcXadArpRrVnCP7McCdwEYRWW+3/QT4HyAOWGzfNvBzY8z9xpjNIvIasAWre2eGMcYX9MqjWeVJeHkq+Gtg2vuQlud0RUqpdq7JsDfGLKfhfvh3G3nOTGBmAHWpC/H74PV7oaQA7pyvQa+Uaha9Nk64Wfxz2PE+3Pi4dUNwpZRqBr1cQjhZOwdWPAFfuR/ypzldjVIqjGjYh4vdy+Cd/7AugXCt9pAppVpGwz4cHN1pnR2b0gdufR7c2vumlGoZDfv27nSpNfIGgW+8AvGdna5IKRWGoi7sq7w+Dp+sdLqM5vF5Yd7dcGw33P53vUyxUqrVoi7s//zhDq7+41LKKmucLqVpix6BXR9bI29yxjhdjVIqjEVd2C/ecpjyKi8fbD7sdCmNW/UMrH4GLvseXHKn09UopcJcVIV90fEKCovLAXhz/QGHq2nEzn/Cez+GftfBNb90uhqlVASIqrBfUlACwKTB3fi08AglZVUOV9SAku3w2t2QPgBueQZcet8XpVTgoi7ss7ok8IMJ/fAbePuLdnYxzopjMPc28MRaI2/ikpyuSCkVIaIm7Ku8Pj7beYTx/dPp3y2JAd2SWLC+HYW9txpe+xacPABT50Ky3tBFKRU8URP2a/Ycp6Lax/h+GQDcNDyT9ftL2Xv0lMOV2T6eCXuWweQnIFvv4qiUCq6oCfslBcXEul1clpcKwFeH9gBoH0f3X26Ez/4Kw++Eobc7XY1SKgJFTdgv3V7CqNwUOsRalxrITE5gVG4Kb64/wNmbbDnA74O3HoQOKTDhV87VoZSKaFER9gdLT7P9cDnj+p17r9spw3qwq+QUmw+evMAz28Dq2XBgLUz8byvwlVIqBKIi7GuHXI7vf27YXz+kOzFuYYFTY+5PHoSPfgV9roKLvu5MDUqpqBAlYV9MZnICeRmJ57R36RjLuH7pLNxwEJ/fga6c9/6PdWvBG/4I0tDNwJRSKjgiPuyrvX4+LTzCuP7pSAOBOmVYJodPVrFy99G2LWzbu7D1LRj3Y73AmVIq5CI+7NfsPcapah/j6/XX17pmYFc6xrpZ2JajcqrK4N0fQsZg69o3SikVYk2GvYhki8jHIrJVRDaLyIN2+632sl9E8us951ERKRSRAhGZGKrim2Pp9hJi3MJleWkNrk+IdTNxcDfe3XiIKq+vbYr650yrv/6rfwF3TNvsUykV1ZpzZO8FHjbGDARGAzNEZBCwCfga8Endje11U4HBwCTgSRFx7AIvSwtKGJmTQmLche/uNHlYD05Wes/8kBtSB9bBqqdh5D2QPTL0+1NKKZoR9saYQ8aYdfZ8GbAVyDTGbDXGFDTwlCnAK8aYKmPMbqAQcOSU0EMnTrPty7LzhlzWNzYvjdSOsaEflePzWmPqO2bA1T8P7b6UUqqOFvXZi0gOMBxY2chmmcD+OstFdlv915ouImtEZE1JSWiOqJeeGXKZ0eh2HreLGy/uzodbi0N7U5OVT8GXX8B1v9XbCyql2lSzw15EEoHXgYeMMY2dhdTQGMLzxjUaY2YZY/KNMfnp6Y0febfWkoISuneOp1/XxCa3nTwsk2qvn0WbvgxJLZTus65/028SDJoSmn0opdQFNCvsRSQGK+hfMsbMb2LzIiC7znIW0OYXoKnxWUMux19gyGV9l/RMJjslgYUbQlCqMfDODwGB6/+gY+qVUm2uOaNxBJgNbDXG/KkZr7kQmCoicSKSC/QFVgVWZsut3Xucsiov4/o13oVTS0SYMjSTTwuPUFwW5BuSb3kTdrwPV/4EkrOb3FwppYKtOUf2Y4A7gatEZL39uF5EbhaRIuBS4B0ReR/AGLMZeA3YAiwCZhhj2mhM41lLt5fgcQlj7KtcNsdNw3tYNzXZcCh4hVSesG4x2H0ofOX+4L2uUkq1wIXHI9qMMctpuB8e4I0LPGcmMDOAugK2pKCE/JwuJMU3fxx7XkYSg7p3YsGGg0wbmxucQj78JZwqgW+8Cu4m/7mVUiokIvIM2sMnK9l66GSzu3Dquml4DzbsL2X3kSDc1GT/KljznHVE32N44K+nlFKtFJFhv/QCV7lsjq8O7YEIgV8+wVdjjanvlAlX/jSw11JKqQBFZNgv2V5Mt07xDOjW8ht2d++cwKicFBYEelOTz/4HirfA9b+HuKaHfiqlVChFXNh7fX6W7TjCuH7NG3LZkJuGZ7LryCk2HWjlTU1OFMHS38HAr8KA61v3GkopFUQRF/br9pVSVultVRdOreuGdAvspiafPQF+L0z8r1bXoJRSwRRxYb90ezFulzCmb8NXuWyO5A6xjO+f0bqbmpw6CuvmwEW3QXLPVteglFLBFHFhv6SghBE9u9CpBUMuGzJlWA+Ky6pYuauFNzVZ9TTUVMDYhwLav1JKBVNEhX1xWSWbD55kXABdOLVqb2ryZku6cqrKYOXTMOBGSO8fcA1KKRUsERX2gQy5rC8+xs3EId14b9OXVNY08wTgtXOgshTG/iDg/SulVDBFVNgv2V5CRlIcg7p3Csrr3TQsk7JKL0sKipve2FsFK56AnMshK7/p7ZVSqg1FTNh7fX6WbS8JaMhlfZf1SSUtMZYFzTnBasMrUHYILv+PoOxbKaWCKWLCfkNRKScrvU3eqKQlrJua9OCjbcWcbOymJn4ffPoX62Jnva8M2v6VUipYIibslxSU4HYJYwMYctmQKcN6NH1Tk60L4dhOGPsfeq16pVS7FFFhPzw7mc4JgQ25rG9YdjI5qR2Yu3Jfw5dPMAaWPw6pedYZs0op1Q5FRNiXlFWx8cCJoIzCqU9EuGdsLuv3l7Jy97HzN9j5Tzi0AcY8CC530PevlFLBEBFh/8n25t1YvLVuzc8mLTGWJ5fsPH/l8schqQdcfHtI9q2UUsEQEWG/ZHsJaYnBG3JZX3yMm2+PyeWT7SVsOnDi7Ir9q2HPMrh0BnjiQrJvpZQKhrAPe5/fsGyHNeTS5Qrdj6PfHN2LxDgPf1ta5+h++eMQnwwj7g7ZfpVSKhjCPuw3FJVSWlETkv76ujonxPDN0b14b+Mh6y5Wxdug4B34yn16vXqlVLvXZNiLSLaIfCwiW0Vks4g8aLeniMhiEdlhT7vUec6jIlIoIgUiMjGUb2BJQQkugcuDPOSyIdPG5uBxu5j1yU749M8Q0wFG3Rfy/SqlVKCac2TvBR42xgwERgMzRGQQ8AjwkTGmL/CRvYy9biowGJgEPCkiIRumsrSgmGHZySR3iA3VLs7ISIrn1hFZrFi7HrNxHlxyF3RMDfl+lVIqUE2GvTHmkDFmnT1fBmwFMoEpwBx7sznATfb8FOAVY0yVMWY3UAiMCnLdAJTu+YLvHv45N2VXhOLlG3TfFX24W97Gb4DLvttm+1VKqUC0qM9eRHKA4cBKoKsx5hBYXwhA7bjHTGB/nacV2W31X2u6iKwRkTUlJSWtKB2+PO1mgnst13g2tOr5rdEzvoJvxCxhgX8sJ2K6ttl+lVIqEM0OexFJBF4HHjLGNHZz1oaGxJx36qkxZpYxJt8Yk5+e3rofVwcMHAxp/elesrxVz2+VlU8RY6r53+obeHHFnrbbr1JKBaBZYS8iMVhB/5IxZr7dfFhEutvruwO11wEuArLrPD0LaMZlI1up7wRk76dQfSpkuzij8iSsmoUMvJFe/Yfz/Gd7OF3dzGvdK6WUg5ozGkeA2cBWY8yf6qxaCNxlz98FLKjTPlVE4kQkF+gLrApeyfXkXQO+ati9LGS7OGPt81B5Asb+gAfG9+HYqWpeXb0v9PtVSqkANefIfgxwJ3CViKy3H9cDvwEmiMgOYIK9jDFmM/AasAVYBMwwxoTu8LfXZRDTEQoXh2wXANRUwor/hdxxkDmCkTkpjMzpwjPLdlPj84d230opFSBPUxsYY5bTcD88wNUXeM5MYGYAdTWfJw5yr4Adi60rUIbqEsMbXobyw3Dz02eaHhjfh2kvrGHh+oPcMiIrNPtVSqkgCPszaAHIuxpK98LRBi5UFgw+r3Vzkh7Doff4M81X9s9gQLck/rZ0J35/A5c/VkqpdiIywr7vBGsaqq6crQvg+O7zbk4iIjwwvg+FxeUs3no4NPtWSqkgiIyw75IDqX2trpxQ+Oyv1usPuPG8VTdc1J2eKR14csnOhm9uopRS7UBkhD1YR/d7lkN1kM+mLSmAg/+C/GngOv+fy+N2Mf2K3mzYX8qKXUeDu2+llAqSyAn7vGvAV2UFfjBtnAfigiG3XHCTr4/IIi0xjr81dHMTpZRqByIn7HuNsa5CWfhh8F7TGCvsc8dB0oUvjRAf4+aesbks23GEjUUnLridUko5JXLCPiYeci4P7o+0RWvg+B646NYmN/3m6J4kxXt4aqke3Sul2p/ICXuwunKO7QreEMyN88AdBwPP/2G2vqT4GO4c3Yt3Nx1iV0l5cPavlFJBEllh3/caaxqMrhyfFzbPh/6TIL5zs54ybWwusW4XTy/dFfj+lVIqiCIr7FN6Q0qf4AzB3L0ETpU0qwunVlpiHLePzGb+v4r48kRl4DUopVSQRFbYgz0EcxnUnA7sdb6YB3Gdoe+1LXrady7vjd/As8v06F4p1X5EXtjnTQBvJez5tPWvUV0B296GQZOta++0QHZKByYP7cHcVfsorahufQ1KKRVEkRf2OWPAEx9Yv/3296C6HC6+rVVPv39cH07X+Hh88fbW16CUUkEUeWEfkxD4EMyN/4Ck7tbY/Vbo3y2Juy7N4cXP9/KvfcdbX4dSSgVJ5IU9WEMwjxbCsd0tf27FMesH3iG3gMvd6hIevrYfXZPieXT+Rr3evVLKcZEZ9meugtmKrpwtC8Bf06JROA1Jio/hscmD2fZlGc8tb8WXjlJKBVFkhn1qH+iS27ohmBv/YV3hsvvQgMuYNKQbEwZ15fEPt7P/WJAv0KaUUi0QmWEP1tH97k+s2wk214ki2Lvc+mE2SHe8+uXkwbhF+Nmbm/QSyEopx0Ru2OdNAO9p2NuCIZibXremjVzhsqV6JCfww4n9Wbq9hLe+OBS011VKqZZoMuxF5DkRKRaRTXXahorIChHZKCJviUinOuseFZFCESkQkYmhKrxJOWOt69oUftT853wxDzLzrW6gIPrWpTlcnNWZX721mRMVNUF9baWUao7mHNm/AEyq1/Ys8Igx5iLgDeBHACIyCJgKDLaf86SItH5ISyBiO1hj7ps7BLN4KxzeGPAPsw1xu4T/uvkijlfU8JtF24L++kop1ZQmw94Y8wlwrF5zf+ATe34xUNvvMQV4xRhTZYzZDRQCo4JUa8vlTYAj2+H43qa3rb1JyeCbQ1LKkMzOTBuTw8ur9rF6T/1/TqWUCq3W9tlvAibb87cC2fZ8JrC/znZFdtt5RGS6iKwRkTUlJSWtLKMJzb0Ree1NSnqPb/QmJYH6wYR+ZCYn8JP5G6n26th7pVTbaW3YTwNmiMhaIAmovQhMQ0NYGhyCYoyZZYzJN8bkp6ent7KMJqTmQXIv2NHEePv9q6B0X0i6cOrqEOvh1zcNYUdxOU/rTU6UUm2oVWFvjNlmjLnWGDMCeBmoTa4izh7lA2QBBwMrMQAiZ4dgeqsuvN3Gedb1dAY0fZOSQF05IIMbLu7OXz8u1JucKKXaTKvCXkQy7KkL+BnwlL1qITBVROJEJBfoC6wKRqGtljcBak7BvhUNr/fVwOY3oN8kiO/U8DZB9osbBxHncenYe6VUm2nO0MuXgRVAfxEpEpF7gDtEZDuwDevI/XkAY8xm4DVgC7AImGGM8YWq+GbJvRzcsRc+m3bXEqg4EvIunLoyOsXz40kD+GznUeavO9Bm+1VKRS9PUxsYY+64wKq/XGD7mcDMQIoKqtiO0Osy6zo5Exsoa+M867aDtT/mtpFvjOrJG/86wK/f2cKVAzJI6RjbpvtXSkWXyD2Dtq68CVCyDUr3n9tefQq2vg2DprT4JiWBctlj78sqvcx8Z2ub7lspFX2iI+wvNASz4D2rP/+i1t2kJFD9uyVx37jevL6uiM92HnGkBqVUdIiOsE/rB517nj8Ec+M8SOrR6puUBMP3rupLr9QO/PSNTVTWOPvzhlIqckVH2ItA32tg91Lw2qcEVByz+vEvugVczv0zxMe4mXnTRew+coonPy50rA6lVGSLjrAHq9++uhz2f24tb34D/N42HYVzIWP7pnHz8EyeXLKTz3cddbocpVQEip6wz70CXDFnh2Bu/IfVvdPtYmfrsj02eTC9Ujtw/9/XsvfoKafLUUpFmOgJ+7hE6HWp1XVTug/2fWb9MBukm5QEqnNCDLPvGgnAtBdWc7JSL4WslAqe6Al7sLpyirfAp/9jLV8UvJuUBENOWkee+uYI9h6tYMZL6/DqjcqVUkESXWFfOwRz9bOQNRJSejtbTwNG905l5s1DWLbjCL/W8fdKqSBp8gzaiJI+ADplwcmidvHD7IXcPrInhcXlPLNsN30yErlzdC+nS1JKhbnoOrIXgX7XgrhDdpOSYHnkuoFcNSCDxxZuZvkOPeFKKRWY6Ap7gCt/BtMWQWKG05U0yu0S/jJ1GHnpifz7S2vZqZdDVkoFIPrCvmMqZDt3p8SWSIqP4dm78olxu7h3zhpKK6qbfpJSSjUg+sI+zGSndODpO0dw4PhpHvj7Omp0hI5SqhU07MNAfk4Kv7nlIlbsOsrPF2zWG54opVosukbjhLGvXZJFYXE5Ty7ZSd+MRKaNzXW6JKVUGNGwDyM/vLY/O0vK+fU7W8hN78iV/dv3j8xKqfZDu3HCiMslPH77MAZ068T35v6L7YfLnC5JKRUmNOzDTIdYD7Pvzich1s09c1ZztLzK6ZKUUmFAwz4Mde+cwDPfyqf4ZBV3Pb+KkjINfKVU45oMexF5TkSKRWRTnbZhIvK5iKwXkTUiMqrOukdFpFBECkRkYqgKj3bDspN56psjKCwu5+tPfaaXRVZKNao5R/YvAJPqtf0O+KUxZhjwc3sZERkETAUG2895UkTcwSpWnevKARnM/c5oTp6u4WtPfsYXRaVOl6SUaqeaDHtjzCfAsfrNQCd7vjNw0J6fArxijKkyxuwGCoHwOF01TF3Sswv/eOAyEmLdTJ31OUu3lzhdklKqHWptn/1DwO9FZD/wB+BRuz0T2F9nuyK77TwiMt3uAlpTUqIBFYg+6YnMf+AyclI7cs8Lq3l9bZHTJSml2pnWhv0DwA+MMdnAD4DZdntDt31q8HRPY8wsY0y+MSY/PT29lWWoWhmd4nn1vtF8pXcKD8/bwJNLCvVMW6XUGa0N+7uA+fb8PM521RQB2XW2y+JsF48KsaT4GJ6/exSTh/bgd4sK+OVbW/D5NfCVUq0P+4PAOHv+KmCHPb8QmCoicSKSC/QFVgVWomqJWI+LP98+jO9cnssLn+3hey+vo7LG53RZSimHNXm5BBF5GRgPpIlIEfAL4DvAX0TEA1QC0wGMMZtF5DVgC+AFZhhjNGnamMsl/PSGQXTtFM+v39nK0fJVzPpWPp0TYpwuTSnlEGkP/br5+flmzZo1TpcRkRasP8AP522gd1oic6aNolvneKdLUkoFiYisNcbkN2dbPYM2wk0ZlskL3x7FgdLTfO3JT9mh19NRKipp2EeBMXlpvHrfaGr8hq8/tYKPtxU7XZJSqo1p2EeJwT06M/+By+jeOZ5vv7CaH83bwMnKGqfLUkq1EQ37KJKd0oEF3x3DjCv78Pq6IiY+/omecatUlNCwjzJxHjc/mjiAN/59DB3jPNz13Coenf8FZXqUr1RE07CPUkOzk3n7e2O5b1xvXl29n0l/XsbyHUecLkspFSIa9lEsPsbNo9cNZN79lxHncfHN2Sv52ZsbOVXldbo0pVSQadgrRvTqwrsPXs69Y3N5aeU+Jv75E1bsPOp0WUqpINKwV4B1lP+zGwfx2n2X4nEJdzzzOY8t3ExFtR7lKxUJNOzVOUbmpPDug5dz92U5vPDZHq77yzJW7tKjfKXCnYa9Ok+HWA+PTR7MK9NHYwzcPutz7p2zmk0HTjhdmlKqlTTs1QWN7p3Kew9ezsMT+rFq9zFu/OtyvvPiGjYf1NBXKtzohdBUs5ysrOH55Xt4dvkuyiq9TBzclYeu6cfA7p2afrJSKiRaciE0DXvVIidO1zB7+W6eX76bsiov1w3pxoPX9GVANw19pdqahr0KuRMVNcxevovnPt1DeZWXGy7qzoPX9KVf1ySnS1MqamjYqzZTWlHNs8t28/ynu6mo8XHDRd156Jq+5GVo6CsVahr2qs0dP1XNM8t2MeezPVTU+Lh2UFduy89mXL90PG4dB6BUKGjYK8ccO1XNs8t28erq/Rw9VU16UhxfG57J10dk0Ve7eJQKKg175bhqr5+PC4qZt6aIjwuK8fkNQ7OTuXVEFl8d2kPvh6tUEAQ17EXkOeBGoNgYM8RuexXob2+SDJQaY4bZ6x4F7gF8wPeNMe83VYSGfWQrKatiwfoDzFtTRMHhMmI9LiYO7satI7IYk5eG2yVOl6hUWAp22F8BlAMv1oZ9vfV/BE4YY34lIoOAl4FRQA/gQ6CfMcbX2D407KODMYZNB04yb+1+Fqw/yInTNXTvHM8tl2Rxy4gsctM6Ol2iUmEl6N04IpIDvF0/7EVEgH3AVcaYHfZRPcaY/7bXvw88ZoxZ0djra9hHn8oaHx9tLWbe2v18sr0Ev4EB3ZIY1z+d8f0yGNGrC7Ee/WFXqca0JOw9Ae7rcuCwMWaHvZwJfF5nfZHddh4RmQ5MB+jZs2eAZahwEx/j5oaLu3PDxd05fLKSBesP8M9txcxetpunl+4iMc7DZX1SGd8/g3H908lMTnC6ZKXCWqBhfwdWt02thjpfG/zTwRgzC5gF1pF9gHWoMNa1UzzTr+jD9Cv6UF7l5dPCIyzdXsLSghI+2HIYgL4ZiYzrl874/hmMzO1CnMftcNVKhZdWh72IeICvASPqNBcB2XWWs4CDrd2Hij6JcR4mDu7GxMHdMMaws6ScJQUlLN1ewosr9vLs8t0kxLi5rE8ql/dN45JeXRjQrZN2+SjVhECO7K8Bthljiuq0LQTmisifsH6g7QusCmAfKoqJCHkZSeRlJHHv5b2pqPby+a6jLCkoYUlBCR9tKwYg1uNicI9ODMtOPvPomdIB6yclpRQ0I+xF5GVgPJAmIkXAL4wxs4GpnNuFgzFms4i8BmwBvMCMpkbiKNVcHWI9XDWgK1cN6IoxhgOlp1m/v5QN+0tZv7+Ul1ft4/lP9wDQpUMMQ7OTGZplhf/Q7GRSOsY6+waUcpCeVKUihtfnp+BwGRv2nzjzBbC9uIza/8R7pnRgSGYn8tIT6ZORSF5GIr3TEkmI1f5/FZ70DFqlbOVVXjYWnWBDUSnr95Wy7cuT7DtWgd/+z14EMpMTyMtIJC/d+gLoY8930b8EVDvXlkMvlWrXEuM8XNonlUv7pJ5pq6zxsefoKXYWn6KwuJzCknIKi8tZsfMoVV7/me1SO8bSJyORnikd6JGcQFZyApldEuiRnED3zvHEx+hfBCp8aNirqBMf42ZAt07n3XDF77d+BygstsJ/p/0lsHzHEQ6XVVL/j+C0xDgyuySQmRxPZnICmcnWF0GP5ATSk+JI7RirV/xU7YaGvVI2l0vITulAdkoHrhyQcc66Gp+fL09UUnT8NAdLT3Og9Ox026EyPtpafM5fBbW6dIghLTHOeiTFkZYYS1piHOmJcaQlxZ5Zl9IxVv9SUCGlYa9UM8S4XWe+CBpijOHoqWoO2l8CJeXVHCmr4kh57aOaL4pKOVJWxanqhgeoxXlcJHeIoXPC2UenhBiSE2LtZQ+dz6yPJSneQ8c4D4mxHjrGufWvCNUoDXulgkBEzhylX5yV3Oi2p6t9HCmvoqS8yv5CqOZ4RTUnTtdwoqKG0tPW/IHSSrYeKuPE6RrKq7xN1hDncZEYZ30BdIzz0DHWbX0ZxFlfBh3jPCTEuEmIcRMf4yY+tnbedbYtpk5brJt4j5tYj4tYjwuPS/TchTCmYa9UG0uIdTf6V0JDanx+Tp6usb4Q7Ed5lZdTVV7Kq3ycOjPvpaLad2ZdaUU1RccrOGVvU+n1UeNr3Qg8l1gnsMW6XcTFuK2p/UVwduomxi143NZ2HrcQ43ZZbS7XmfmYeuvcLuvLxOMWPK6zy26XnJ3W2c4lVpvbxZn52qnHJbhcgru23Z532du6xFqW2ueKIFK7DtwR+qWmYa9UGIhxu0hNjCM1MS7g16rx+ams8VFZY01P1/isaXXt/Lnt1V6/9fD5qbLnz059Z9ZVe/2crvFxstJPjc/g9fmp8VnzNT4/Xr+hxuunxm+1+fzOD/tujEvOfjkg5y4L1rBdl6vusvVlYW1eO299abhcVlvtl4qA/ZrClf3T+ekNg0L+fjTslYoy1tG0i6R4Z+vw+431BWB/Efj8Bq/fb019tcvWtMbnP2fZ6/fj94PPGPx2W+2812/wG7vtzDz4jcGY2jZr2XrUruPM9n5j1Wc4d70xjSzb78kYMFhTvz1PnW1MnXkMdOvcNld01bBXSjnC5RJiXaIXsWsj+q+slFJRQMNeKaWigIa9UkpFAQ17pZSKAhr2SikVBTTslVIqCmjYK6VUFNCwV0qpKNAu7lQlIiXA3gBeIg04EqRywo2+9+gVze8/mt87nH3/vYwx6c15QrsI+0CJyJrm3por0uh7j873DtH9/qP5vUPr3r924yilVBTQsFdKqSgQKWE/y+kCHKTvPXpF8/uP5vcOrXj/EdFnr5RSqnGRcmSvlFKqERr2SikVBcI67EVkkogUiEihiDzidD1tTUT2iMhGEVkvImucrieUROQ5ESkWkU112lJEZLGI7LCnXZysMZQu8P4fE5ED9ue/XkSud7LGUBGRbBH5WES2ishmEXnQbo/4z7+R997izz5s++xFxA1sByYARcBq4A5jzBZHC2tDIrIHyDfGRPzJJSJyBVAOvGiMGWK3/Q44Zoz5jf1l38UY82Mn6wyVC7z/x4ByY8wfnKwt1ESkO9DdGLNORJKAtcBNwN1E+OffyHu/jRZ+9uF8ZD8KKDTG7DLGVAOvAFMcrkmFiDHmE+BYveYpwBx7fg7W/wQR6QLvPyoYYw4ZY9bZ82XAViCTKPj8G3nvLRbOYZ8J7K+zXEQr/xHCmAE+EJG1IjLd6WIc0NUYcwis/ymADIfrccJ3ReQLu5sn4rox6hORHGA4sJIo+/zrvXdo4WcfzmEvDbSFZ59U640xxlwCXAfMsP/UV9Hjb0AfYBhwCPijo9WEmIgkAq8DDxljTjpdT1tq4L23+LMP57AvArLrLGcBBx2qxRHGmIP2tBh4A6trK5octvs0a/s2ix2up00ZYw4bY3zGGD/wDBH8+YtIDFbYvWSMmW83R8Xn39B7b81nH85hvxroKyK5IhILTAUWOlxTmxGRjvYPNohIR+BaYFPjz4o4C4G77Pm7gAUO1tLmaoPOdjMR+vmLiACzga3GmD/VWRXxn/+F3ntrPvuwHY0DYA83+jPgBp4zxsx0tqK2IyK9sY7mATzA3Eh+/yLyMjAe69Kuh4FfAG8CrwE9gX3ArcaYiPwR8wLvfzzWn/EG2APcV9uHHUlEZCywDNgI+O3mn2D1XUf059/Ie7+DFn72YR32Simlmiecu3GUUko1k4a9UkpFAQ17pZSKAhr2SikVBTTslVIqCmjYK6VUFNCwV0qpKPD/Aaxra9SDJU0HAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 67918.999343\n", + "1 50385.692684\n", + "dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
04328.2500004148.000000
15516.3906251215.000000
24549.5634771367.250000
33877.2622681481.437500
43402.7471351567.078125
53063.5730961631.308594
62818.5932401679.481445
72640.1462281715.611084
82509.2854011742.708313
92412.8128991763.031235
102341.3996511778.273426
112288.3691011789.705070
122248.8939671798.278802
132219.4551171804.709102
142197.4701991809.531826
152181.0345081813.148870
162168.7375521815.861652
172159.5316041817.896239
182152.6365751819.422179
192147.4706101820.566635
202143.5991201821.424976
212140.6971821822.068732
222138.5216721822.551549
232136.8905711822.913662
242135.6675446718.433669
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 4328.250000 4148.000000\n", + "1 5516.390625 1215.000000\n", + "2 4549.563477 1367.250000\n", + "3 3877.262268 1481.437500\n", + "4 3402.747135 1567.078125\n", + "5 3063.573096 1631.308594\n", + "6 2818.593240 1679.481445\n", + "7 2640.146228 1715.611084\n", + "8 2509.285401 1742.708313\n", + "9 2412.812899 1763.031235\n", + "10 2341.399651 1778.273426\n", + "11 2288.369101 1789.705070\n", + "12 2248.893967 1798.278802\n", + "13 2219.455117 1804.709102\n", + "14 2197.470199 1809.531826\n", + "15 2181.034508 1813.148870\n", + "16 2168.737552 1815.861652\n", + "17 2159.531604 1817.896239\n", + "18 2152.636575 1819.422179\n", + "19 2147.470610 1820.566635\n", + "20 2143.599120 1821.424976\n", + "21 2140.697182 1822.068732\n", + "22 2138.521672 1822.551549\n", + "23 2136.890571 1822.913662\n", + "24 2135.667544 6718.433669" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0100.500000132.000000
1108.37500083.000000
2102.03125083.000000
397.27343883.000000
493.70507883.000000
591.02880983.000000
689.02160683.000000
787.51620583.000000
886.38715483.000000
985.54036583.000000
1084.90527483.000000
1184.42895583.000000
1284.07171783.000000
1383.80378783.000000
1483.60284183.000000
1583.45213083.000000
1683.33909883.000000
1783.25432383.000000
1883.19074383.000000
1983.14305783.000000
2083.10729383.000000
2183.08047083.000000
2283.06035283.000000
2383.04526483.000000
2483.033948152.966052
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 100.500000 132.000000\n", + "1 108.375000 83.000000\n", + "2 102.031250 83.000000\n", + "3 97.273438 83.000000\n", + "4 93.705078 83.000000\n", + "5 91.028809 83.000000\n", + "6 89.021606 83.000000\n", + "7 87.516205 83.000000\n", + "8 86.387154 83.000000\n", + "9 85.540365 83.000000\n", + "10 84.905274 83.000000\n", + "11 84.428955 83.000000\n", + "12 84.071717 83.000000\n", + "13 83.803787 83.000000\n", + "14 83.602841 83.000000\n", + "15 83.452130 83.000000\n", + "16 83.339098 83.000000\n", + "17 83.254323 83.000000\n", + "18 83.190743 83.000000\n", + "19 83.143057 83.000000\n", + "20 83.107293 83.000000\n", + "21 83.080470 83.000000\n", + "22 83.060352 83.000000\n", + "23 83.045264 83.000000\n", + "24 83.033948 152.966052" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small NNBase.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small NNBase.ipynb new file mode 100644 index 0000000..b325fe0 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small NNBase.ipynb @@ -0,0 +1,353 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgentsBase import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NNBase(num_input=3+game.advHistoryNum, lr=0.0001,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(-0., grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.2575, 0.2566, 0.2574], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0., 0., 0.])\n", + "meanStageValue= tensor([14467.2676, 10395.5742, 5549.2500])\n", + "--------------------------------------------------\n", + "1000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.0039, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9221, 0.9263, 0.9314], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0.0517, 0.0608, 0.0400])\n", + "meanStageValue= tensor([14551.2285, 10494.4229, 5613.5835])\n", + "--------------------------------------------------\n", + "2000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(0.0003, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9890, 0.9904, 0.9917], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0.0276, 0.0319, 0.0210])\n", + "meanStageValue= tensor([14575.3613, 10523.3203, 5632.5498])\n", + "--------------------------------------------------\n", + "3000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(5.4508e-05, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9965, 0.9970, 0.9975], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0.0186, 0.0214, 0.0141])\n", + "meanStageValue= tensor([14584.3838, 10533.8330, 5639.4556])\n", + "--------------------------------------------------\n", + "4000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.8931e-05, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9983, 0.9986, 0.9989], grad_fn=)\n", + "shouldBreak: False\n", + "baseDiscReturns/1000= tensor([0.0137, 0.0159, 0.0105])\n", + "meanStageValue= tensor([14589.2217, 10539.3018, 5643.0317])\n", + "--------------------------------------------------\n", + "4743 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(9.2166e-06, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9990, 0.9992, 0.9994], grad_fn=)\n", + "shouldBreak: True\n", + "baseDiscReturns/1000= tensor([0.0115, 0.0133, 0.0088])\n", + "meanStageValue= tensor([14591.3877, 10541.8730, 5644.7266])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver(print_step=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'mean'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m prices \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(game\u001b[38;5;241m.\u001b[39mprices)\u001b[38;5;241m.\u001b[39mT\n\u001b[0;32m 4\u001b[0m demandPotential \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(game\u001b[38;5;241m.\u001b[39mdemandPotential)\u001b[38;5;241m.\u001b[39mT\n\u001b[1;32m----> 5\u001b[0m learning \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(\u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreturns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean\u001b[49m(axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m),columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mentry\u001b[39m\u001b[38;5;124m'\u001b[39m])\n", + "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'mean'" + ] + } + ], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])\n", + "loss=pd.DataFrame(algorithm.loss[0],columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small.ipynb new file mode 100644 index 0000000..c3d2092 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4 small.ipynb @@ -0,0 +1,2366 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0001,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 0, 2])\n", + "loss= tensor(4.9797, grad_fn=) , actor= tensor(3.9336, grad_fn=) , critic= tensor(10.4610, grad_fn=) , return= 16074.953125\n", + "probs of actions: tensor([0.2934, 0.2473, 0.2804], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "1000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 0])\n", + "loss= tensor(5.2275, grad_fn=) , actor= tensor(4.1640, grad_fn=) , critic= tensor(10.6347, grad_fn=) , return= 16182.078125\n", + "probs of actions: tensor([0.2676, 0.2565, 0.2366], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "2000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 2])\n", + "loss= tensor(5.5201, grad_fn=) , actor= tensor(4.4573, grad_fn=) , critic= tensor(10.6283, grad_fn=) , return= 16178.078125\n", + "probs of actions: tensor([0.2233, 0.2595, 0.2189], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "3000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 0])\n", + "loss= tensor(5.4532, grad_fn=) , actor= tensor(4.3818, grad_fn=) , critic= tensor(10.7132, grad_fn=) , return= 16232.8125\n", + "probs of actions: tensor([0.2424, 0.2464, 0.2302], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "4000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 2])\n", + "loss= tensor(5.4042, grad_fn=) , actor= tensor(4.3414, grad_fn=) , critic= tensor(10.6283, grad_fn=) , return= 16178.078125\n", + "probs of actions: tensor([0.2512, 0.2344, 0.2399], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "5000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(5.3095, grad_fn=) , actor= tensor(4.2383, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.2398, 0.2442, 0.3100], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "6000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 1, 1])\n", + "loss= tensor(5.1766, grad_fn=) , actor= tensor(4.1401, grad_fn=) , critic= tensor(10.3647, grad_fn=) , return= 16007.453125\n", + "probs of actions: tensor([0.2112, 0.3035, 0.3006], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "7000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 0])\n", + "loss= tensor(5.4203, grad_fn=) , actor= tensor(4.3728, grad_fn=) , critic= tensor(10.4742, grad_fn=) , return= 16075.078125\n", + "probs of actions: tensor([0.2213, 0.2679, 0.2317], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "8000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 2])\n", + "loss= tensor(5.0621, grad_fn=) , actor= tensor(4.0125, grad_fn=) , critic= tensor(10.4956, grad_fn=) , return= 16093.0625\n", + "probs of actions: tensor([0.2850, 0.2543, 0.2535], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "9000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 3])\n", + "loss= tensor(4.8157, grad_fn=) , actor= tensor(3.7568, grad_fn=) , critic= tensor(10.5889, grad_fn=) , return= 16156.8125\n", + "probs of actions: tensor([0.3071, 0.2715, 0.3004], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 1])\n", + "loss= tensor(5.5414, grad_fn=) , actor= tensor(4.4942, grad_fn=) , critic= tensor(10.4726, grad_fn=) , return= 16074.078125\n", + "probs of actions: tensor([0.1680, 0.3269, 0.2628], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "11000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 2])\n", + "loss= tensor(6.1389, grad_fn=) , actor= tensor(5.1086, grad_fn=) , critic= tensor(10.3023, grad_fn=) , return= 15968.328125\n", + "probs of actions: tensor([0.1691, 0.1778, 0.2453], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "12000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 0])\n", + "loss= tensor(5.5878, grad_fn=) , actor= tensor(4.5352, grad_fn=) , critic= tensor(10.5256, grad_fn=) , return= 16115.203125\n", + "probs of actions: tensor([0.2453, 0.2423, 0.1618], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "13000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 0])\n", + "loss= tensor(5.7609, grad_fn=) , actor= tensor(4.7028, grad_fn=) , critic= tensor(10.5814, grad_fn=) , return= 16149.578125\n", + "probs of actions: tensor([0.2336, 0.2302, 0.1540], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "14000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.6650, grad_fn=) , actor= tensor(3.6109, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.2538, 0.3657, 0.3627], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "15000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(5.2291, grad_fn=) , actor= tensor(4.1724, grad_fn=) , critic= tensor(10.5669, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.2375, 0.2340, 0.3665], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "16000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 0])\n", + "loss= tensor(4.5219, grad_fn=) , actor= tensor(3.4506, grad_fn=) , critic= tensor(10.7132, grad_fn=) , return= 16232.8125\n", + "probs of actions: tensor([0.3925, 0.3882, 0.1472], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "17000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 0])\n", + "loss= tensor(4.8447, grad_fn=) , actor= tensor(3.7734, grad_fn=) , critic= tensor(10.7132, grad_fn=) , return= 16232.8125\n", + "probs of actions: tensor([0.3544, 0.3517, 0.1303], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "18000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 0])\n", + "loss= tensor(5.4633, grad_fn=) , actor= tensor(4.4131, grad_fn=) , critic= tensor(10.5020, grad_fn=) , return= 16097.0625\n", + "probs of actions: tensor([0.3058, 0.2382, 0.1168], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "19000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.7379, grad_fn=) , actor= tensor(3.6782, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.3264, 0.3050, 0.2378], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 1])\n", + "loss= tensor(4.8365, grad_fn=) , actor= tensor(3.7732, grad_fn=) , critic= tensor(10.6331, grad_fn=) , return= 16181.078125\n", + "probs of actions: tensor([0.2657, 0.3365, 0.2902], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "21000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 1])\n", + "loss= tensor(6.3878, grad_fn=) , actor= tensor(5.3405, grad_fn=) , critic= tensor(10.4726, grad_fn=) , return= 16074.078125\n", + "probs of actions: tensor([0.0762, 0.3955, 0.3141], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "22000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(4.1148, grad_fn=) , actor= tensor(3.0703, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.3705, 0.3609, 0.3552], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "23000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(3.8579, grad_fn=) , actor= tensor(2.8134, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.4046, 0.3919, 0.3844], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "24000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 3])\n", + "loss= tensor(4.3906, grad_fn=) , actor= tensor(3.3317, grad_fn=) , critic= tensor(10.5889, grad_fn=) , return= 16156.8125\n", + "probs of actions: tensor([0.3059, 0.4007, 0.3127], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "25000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 1])\n", + "loss= tensor(4.2529, grad_fn=) , actor= tensor(3.1976, grad_fn=) , critic= tensor(10.5534, grad_fn=) , return= 16128.5\n", + "probs of actions: tensor([0.3603, 0.3420, 0.3480], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "26000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 1])\n", + "loss= tensor(4.7713, grad_fn=) , actor= tensor(3.7212, grad_fn=) , critic= tensor(10.5004, grad_fn=) , return= 16096.0625\n", + "probs of actions: tensor([0.3304, 0.2424, 0.3188], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "27000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(4.4134, grad_fn=) , actor= tensor(3.3422, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.3388, 0.3398, 0.3340], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "28000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.9025, grad_fn=) , actor= tensor(3.8405, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.2427, 0.3316, 0.3329], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "29000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 3])\n", + "loss= tensor(4.0224, grad_fn=) , actor= tensor(2.9792, grad_fn=) , critic= tensor(10.4321, grad_fn=) , return= 16053.75\n", + "probs of actions: tensor([0.4008, 0.3902, 0.2935], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.6600, grad_fn=) , actor= tensor(3.6089, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.2664, 0.3544, 0.3356], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "31000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.3270, grad_fn=) , actor= tensor(3.2730, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.3796, 0.3123, 0.3136], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "32000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 3])\n", + "loss= tensor(4.0273, grad_fn=) , actor= tensor(2.9841, grad_fn=) , critic= tensor(10.4321, grad_fn=) , return= 16053.75\n", + "probs of actions: tensor([0.3960, 0.3869, 0.3050], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "33000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(3.7352, grad_fn=) , actor= tensor(2.6907, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.4200, 0.4091, 0.4014], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "34000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(4.5755, grad_fn=) , actor= tensor(3.5056, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.3188, 0.3216, 0.3231], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "35000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.5353, grad_fn=) , actor= tensor(3.4756, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.3134, 0.4002, 0.2280], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "36000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.5500, grad_fn=) , actor= tensor(3.4903, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.3194, 0.3832, 0.2294], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "37000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 0])\n", + "loss= tensor(4.8269, grad_fn=) , actor= tensor(3.7823, grad_fn=) , critic= tensor(10.4465, grad_fn=) , return= 16062.75\n", + "probs of actions: tensor([0.4075, 0.3954, 0.0648], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "38000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 2])\n", + "loss= tensor(3.9521, grad_fn=) , actor= tensor(2.9081, grad_fn=) , critic= tensor(10.4401, grad_fn=) , return= 16058.75\n", + "probs of actions: tensor([0.4313, 0.4173, 0.2436], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "39000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.6413, grad_fn=) , actor= tensor(3.5902, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.2525, 0.4277, 0.2804], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(5.0671, grad_fn=) , actor= tensor(4.0026, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.2640, 0.2813, 0.2744], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "41000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 3])\n", + "loss= tensor(4.3581, grad_fn=) , actor= tensor(3.3093, grad_fn=) , critic= tensor(10.4876, grad_fn=) , return= 16088.0625\n", + "probs of actions: tensor([0.3999, 0.3012, 0.2696], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "42000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 1])\n", + "loss= tensor(4.2029, grad_fn=) , actor= tensor(3.1505, grad_fn=) , critic= tensor(10.5240, grad_fn=) , return= 16114.203125\n", + "probs of actions: tensor([0.3314, 0.3817, 0.3784], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "43000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 1])\n", + "loss= tensor(4.0830, grad_fn=) , actor= tensor(3.0306, grad_fn=) , critic= tensor(10.5240, grad_fn=) , return= 16114.203125\n", + "probs of actions: tensor([0.3387, 0.4038, 0.3989], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "44000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 2])\n", + "loss= tensor(4.1149, grad_fn=) , actor= tensor(3.0708, grad_fn=) , critic= tensor(10.4401, grad_fn=) , return= 16058.75\n", + "probs of actions: tensor([0.3675, 0.3649, 0.3546], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "45000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 1])\n", + "loss= tensor(4.4763, grad_fn=) , actor= tensor(3.4209, grad_fn=) , critic= tensor(10.5534, grad_fn=) , return= 16128.5\n", + "probs of actions: tensor([0.3859, 0.2398, 0.3792], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "46000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(5.0607, grad_fn=) , actor= tensor(3.9896, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.2551, 0.2632, 0.3567], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "47000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 3])\n", + "loss= tensor(4.3433, grad_fn=) , actor= tensor(3.2946, grad_fn=) , critic= tensor(10.4876, grad_fn=) , return= 16088.0625\n", + "probs of actions: tensor([0.3698, 0.3460, 0.2618], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "48000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 1])\n", + "loss= tensor(4.5006, grad_fn=) , actor= tensor(3.4373, grad_fn=) , critic= tensor(10.6331, grad_fn=) , return= 16181.078125\n", + "probs of actions: tensor([0.3894, 0.2466, 0.3499], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "49000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(3.9104, grad_fn=) , actor= tensor(2.8659, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.3908, 0.3895, 0.3872], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 3])\n", + "loss= tensor(4.3497, grad_fn=) , actor= tensor(3.3009, grad_fn=) , critic= tensor(10.4876, grad_fn=) , return= 16088.0625\n", + "probs of actions: tensor([0.3504, 0.3886, 0.2398], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "51000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.8515, grad_fn=) , actor= tensor(3.7862, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.2179, 0.3823, 0.3748], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "52000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(3.6407, grad_fn=) , actor= tensor(2.5962, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.4305, 0.4237, 0.4180], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "53000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(4.7517, grad_fn=) , actor= tensor(3.6950, grad_fn=) , critic= tensor(10.5669, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.3198, 0.3135, 0.2297], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "54000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.6382, grad_fn=) , actor= tensor(3.5842, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.4054, 0.2408, 0.2466], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "55000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 1])\n", + "loss= tensor(4.2062, grad_fn=) , actor= tensor(3.1561, grad_fn=) , critic= tensor(10.5004, grad_fn=) , return= 16096.0625\n", + "probs of actions: tensor([0.3595, 0.3483, 0.3583], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "56000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.5654, grad_fn=) , actor= tensor(3.5001, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.2196, 0.4544, 0.4422], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "57000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 2])\n", + "loss= tensor(5.0714, grad_fn=) , actor= tensor(4.0166, grad_fn=) , critic= tensor(10.5486, grad_fn=) , return= 16125.5\n", + "probs of actions: tensor([0.2512, 0.2118, 0.5010], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "58000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.5462, grad_fn=) , actor= tensor(3.4809, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.1826, 0.5434, 0.5277], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "59000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(6.0326, grad_fn=) , actor= tensor(4.9615, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.1829, 0.1939, 0.2672], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "60000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 1])\n", + "loss= tensor(3.7214, grad_fn=) , actor= tensor(2.6634, grad_fn=) , critic= tensor(10.5798, grad_fn=) , return= 16148.578125\n", + "probs of actions: tensor([0.4780, 0.4614, 0.2488], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "61000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 1])\n", + "loss= tensor(3.8367, grad_fn=) , actor= tensor(2.7787, grad_fn=) , critic= tensor(10.5798, grad_fn=) , return= 16148.578125\n", + "probs of actions: tensor([0.4601, 0.4442, 0.2402], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "62000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(3.9422, grad_fn=) , actor= tensor(2.8847, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.3979, 0.3856, 0.3771], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "63000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 3])\n", + "loss= tensor(4.6071, grad_fn=) , actor= tensor(3.5584, grad_fn=) , critic= tensor(10.4876, grad_fn=) , return= 16088.0625\n", + "probs of actions: tensor([0.2668, 0.3580, 0.3575], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "64000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.2269, grad_fn=) , actor= tensor(3.1616, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.3149, 0.4041, 0.3947], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "65000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 0])\n", + "loss= tensor(5.7966, grad_fn=) , actor= tensor(4.7331, grad_fn=) , critic= tensor(10.6347, grad_fn=) , return= 16182.078125\n", + "probs of actions: tensor([0.4374, 0.2879, 0.0196], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "66000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.5164, grad_fn=) , actor= tensor(3.4519, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.2879, 0.4030, 0.2978], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "67000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.2706, grad_fn=) , actor= tensor(3.2052, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.3045, 0.4057, 0.3957], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "68000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 2])\n", + "loss= tensor(4.6365, grad_fn=) , actor= tensor(3.5925, grad_fn=) , critic= tensor(10.4401, grad_fn=) , return= 16058.75\n", + "probs of actions: tensor([0.2909, 0.2968, 0.3749], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "69000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.6196, grad_fn=) , actor= tensor(3.5655, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.3238, 0.2998, 0.3032], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "70000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(4.7775, grad_fn=) , actor= tensor(3.7077, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.2970, 0.3019, 0.3053], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "71000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.3538, grad_fn=) , actor= tensor(3.3027, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.3805, 0.3022, 0.3098], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "72000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 2])\n", + "loss= tensor(4.1258, grad_fn=) , actor= tensor(3.0630, grad_fn=) , critic= tensor(10.6283, grad_fn=) , return= 16178.078125\n", + "probs of actions: tensor([0.4240, 0.2902, 0.4021], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "73000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(4.7027, grad_fn=) , actor= tensor(3.6316, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.3098, 0.3130, 0.2942], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "74000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.3988, grad_fn=) , actor= tensor(3.3367, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.3836, 0.2992, 0.3020], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "75000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 2])\n", + "loss= tensor(4.0946, grad_fn=) , actor= tensor(3.0426, grad_fn=) , critic= tensor(10.5192, grad_fn=) , return= 16111.203125\n", + "probs of actions: tensor([0.4192, 0.2964, 0.3994], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "76000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 1])\n", + "loss= tensor(4.5562, grad_fn=) , actor= tensor(3.5061, grad_fn=) , critic= tensor(10.5004, grad_fn=) , return= 16096.0625\n", + "probs of actions: tensor([0.2857, 0.3811, 0.2938], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "77000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.3697, grad_fn=) , actor= tensor(3.3186, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.3964, 0.2781, 0.3163], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "78000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 1])\n", + "loss= tensor(3.8965, grad_fn=) , actor= tensor(2.8386, grad_fn=) , critic= tensor(10.5798, grad_fn=) , return= 16148.578125\n", + "probs of actions: tensor([0.4386, 0.4248, 0.2657], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "79000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.3657, grad_fn=) , actor= tensor(3.3004, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.3084, 0.3773, 0.3703], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "80000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 1])\n", + "loss= tensor(4.3244, grad_fn=) , actor= tensor(3.2611, grad_fn=) , critic= tensor(10.6331, grad_fn=) , return= 16181.078125\n", + "probs of actions: tensor([0.3795, 0.3513, 0.2644], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "81000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 1])\n", + "loss= tensor(4.8643, grad_fn=) , actor= tensor(3.8198, grad_fn=) , critic= tensor(10.4449, grad_fn=) , return= 16061.75\n", + "probs of actions: tensor([0.2822, 0.2864, 0.2885], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "82000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.1545, grad_fn=) , actor= tensor(3.0900, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.4014, 0.3062, 0.4007], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "83000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 1])\n", + "loss= tensor(5.0287, grad_fn=) , actor= tensor(3.9787, grad_fn=) , critic= tensor(10.5004, grad_fn=) , return= 16096.0625\n", + "probs of actions: tensor([0.2345, 0.3501, 0.2466], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "84000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.5777, grad_fn=) , actor= tensor(2.5071, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.4863, 0.4797, 0.3016], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "85000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(4.1685, grad_fn=) , actor= tensor(3.1111, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.3670, 0.3595, 0.3540], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "86000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 1])\n", + "loss= tensor(5.4579, grad_fn=) , actor= tensor(4.4055, grad_fn=) , critic= tensor(10.5240, grad_fn=) , return= 16114.203125\n", + "probs of actions: tensor([0.3286, 0.1733, 0.1786], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "87000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(4.2887, grad_fn=) , actor= tensor(3.2312, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.3537, 0.3452, 0.3391], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "88000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 0])\n", + "loss= tensor(5.5099, grad_fn=) , actor= tensor(4.4386, grad_fn=) , critic= tensor(10.7132, grad_fn=) , return= 16232.8125\n", + "probs of actions: tensor([0.4930, 0.4905, 0.0092], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "89000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 2])\n", + "loss= tensor(4.1462, grad_fn=) , actor= tensor(3.0809, grad_fn=) , critic= tensor(10.6531, grad_fn=) , return= 16196.25\n", + "probs of actions: tensor([0.4781, 0.2906, 0.2861], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "90000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 0])\n", + "loss= tensor(6.1150, grad_fn=) , actor= tensor(5.0547, grad_fn=) , critic= tensor(10.6034, grad_fn=) , return= 16165.8125\n", + "probs of actions: tensor([0.4208, 0.2550, 0.0147], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "91000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(4.3492, grad_fn=) , actor= tensor(3.2925, grad_fn=) , critic= tensor(10.5669, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.3341, 0.3257, 0.3918], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "92000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(4.5170, grad_fn=) , actor= tensor(3.4603, grad_fn=) , critic= tensor(10.5669, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.3069, 0.2998, 0.4226], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "93000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(4.5964, grad_fn=) , actor= tensor(3.5389, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.3189, 0.3126, 0.3083], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "94000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(3.9227, grad_fn=) , actor= tensor(2.8529, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.3967, 0.3957, 0.3957], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "95000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(3.9115, grad_fn=) , actor= tensor(2.8540, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.3999, 0.3906, 0.3836], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "96000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.3043, grad_fn=) , actor= tensor(3.2532, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.4193, 0.2817, 0.2999], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "97000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2])\n", + "loss= tensor(3.5843, grad_fn=) , actor= tensor(2.5268, grad_fn=) , critic= tensor(10.5749, grad_fn=) , return= 16145.578125\n", + "probs of actions: tensor([0.4471, 0.4336, 0.4236], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "98000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 2])\n", + "loss= tensor(4.3736, grad_fn=) , actor= tensor(3.3217, grad_fn=) , critic= tensor(10.5192, grad_fn=) , return= 16111.203125\n", + "probs of actions: tensor([0.4023, 0.2445, 0.3865], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "99000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 1])\n", + "loss= tensor(4.6651, grad_fn=) , actor= tensor(3.6127, grad_fn=) , critic= tensor(10.5240, grad_fn=) , return= 16114.203125\n", + "probs of actions: tensor([0.3911, 0.2438, 0.2484], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "100000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.0569, grad_fn=) , actor= tensor(2.9949, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.3819, 0.3729, 0.3717], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "101000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(4.6044, grad_fn=) , actor= tensor(3.5533, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.3370, 0.2549, 0.3732], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "102000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.4273, grad_fn=) , actor= tensor(3.3733, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.2624, 0.4117, 0.4074], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "103000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(4.1490, grad_fn=) , actor= tensor(3.0778, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.3919, 0.3851, 0.2898], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "104000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 2])\n", + "loss= tensor(4.1121, grad_fn=) , actor= tensor(3.0492, grad_fn=) , critic= tensor(10.6283, grad_fn=) , return= 16178.078125\n", + "probs of actions: tensor([0.3754, 0.3677, 0.3632], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "105000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 0, 1])\n", + "loss= tensor(7.6220, grad_fn=) , actor= tensor(6.5833, grad_fn=) , critic= tensor(10.3870, grad_fn=) , return= 16025.5625\n", + "probs of actions: tensor([0.2476, 0.0249, 0.2607], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "106000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.7500, grad_fn=) , actor= tensor(3.6959, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.2414, 0.3628, 0.3600], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "107000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.5315, grad_fn=) , actor= tensor(3.4718, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.3603, 0.2676, 0.3402], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "108000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 2])\n", + "loss= tensor(4.8516, grad_fn=) , actor= tensor(3.7968, grad_fn=) , critic= tensor(10.5486, grad_fn=) , return= 16125.5\n", + "probs of actions: tensor([0.2123, 0.4056, 0.3417], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "109000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 3])\n", + "loss= tensor(7.5620, grad_fn=) , actor= tensor(6.5160, grad_fn=) , critic= tensor(10.4598, grad_fn=) , return= 16066.078125\n", + "probs of actions: tensor([0.0250, 0.4802, 0.4726], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "110000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.7651, grad_fn=) , actor= tensor(2.7006, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.5164, 0.2793, 0.4952], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "111000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.1043, grad_fn=) , actor= tensor(3.0423, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.2684, 0.5001, 0.4918], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "112000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.5390, grad_fn=) , actor= tensor(2.4683, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.5065, 0.4930, 0.2763], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "113000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 3])\n", + "loss= tensor(4.0931, grad_fn=) , actor= tensor(3.0342, grad_fn=) , critic= tensor(10.5889, grad_fn=) , return= 16156.8125\n", + "probs of actions: tensor([0.4887, 0.2239, 0.4694], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "114000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.2571, grad_fn=) , actor= tensor(3.2030, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.2380, 0.5011, 0.4924], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "115000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.1000, grad_fn=) , actor= tensor(3.0460, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.2778, 0.4805, 0.4725], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "116000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.7895, grad_fn=) , actor= tensor(1.7196, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.5829, 0.5664, 0.5564], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "117000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.2533, grad_fn=) , actor= tensor(3.1936, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.5575, 0.2813, 0.1633], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "118000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 2])\n", + "loss= tensor(4.2348, grad_fn=) , actor= tensor(3.1751, grad_fn=) , critic= tensor(10.5970, grad_fn=) , return= 16161.8125\n", + "probs of actions: tensor([0.5338, 0.2841, 0.1857], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "119000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 1])\n", + "loss= tensor(5.5831, grad_fn=) , actor= tensor(4.5307, grad_fn=) , critic= tensor(10.5240, grad_fn=) , return= 16114.203125\n", + "probs of actions: tensor([0.1633, 0.3038, 0.3080], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "120000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 2])\n", + "loss= tensor(8.8275, grad_fn=) , actor= tensor(7.7808, grad_fn=) , critic= tensor(10.4678, grad_fn=) , return= 16071.078125\n", + "probs of actions: tensor([0.0148, 0.5427, 0.1549], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "121000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.8864, grad_fn=) , actor= tensor(1.8165, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.5662, 0.5481, 0.5373], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "122000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6306, grad_fn=) , actor= tensor(1.5608, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.6146, 0.5960, 0.5844], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "123000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(2.9910, grad_fn=) , actor= tensor(1.9199, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.6889, 0.6672, 0.1874], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "124000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 1])\n", + "loss= tensor(4.9805, grad_fn=) , actor= tensor(3.9252, grad_fn=) , critic= tensor(10.5534, grad_fn=) , return= 16128.5\n", + "probs of actions: tensor([0.1666, 0.6937, 0.1878], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "125000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.1058, grad_fn=) , actor= tensor(3.0413, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.6803, 0.1199, 0.6442], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "126000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 3])\n", + "loss= tensor(5.6580, grad_fn=) , actor= tensor(4.6092, grad_fn=) , critic= tensor(10.4876, grad_fn=) , return= 16088.0625\n", + "probs of actions: tensor([0.2315, 0.1199, 0.6064], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "127000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.3525, grad_fn=) , actor= tensor(1.2826, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.6732, 0.6524, 0.6382], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "128000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.1599, grad_fn=) , actor= tensor(1.0900, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7138, 0.6961, 0.6832], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "129000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9157, grad_fn=) , actor= tensor(0.8458, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7714, 0.7543, 0.7413], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "130000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9023, grad_fn=) , actor= tensor(0.8325, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7750, 0.7575, 0.7441], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "131000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.1230, grad_fn=) , actor= tensor(1.0531, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7226, 0.7043, 0.6913], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "132000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.2246, grad_fn=) , actor= tensor(2.1539, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.7480, 0.7267, 0.0853], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "133000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.2385, grad_fn=) , actor= tensor(1.1687, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7011, 0.6757, 0.6584], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "134000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 0])\n", + "loss= tensor(5.3047, grad_fn=) , actor= tensor(4.2444, grad_fn=) , critic= tensor(10.6034, grad_fn=) , return= 16165.8125\n", + "probs of actions: tensor([0.6764, 0.2435, 0.0198], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "135000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(5.2203, grad_fn=) , actor= tensor(4.1583, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.0996, 0.6146, 0.5996], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "136000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.3626, grad_fn=) , actor= tensor(3.2981, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.7025, 0.0883, 0.6649], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "137000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9271, grad_fn=) , actor= tensor(0.8573, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7721, 0.7498, 0.7329], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "138000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.0575, grad_fn=) , actor= tensor(0.9877, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7399, 0.7186, 0.7033], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "139000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.2820, grad_fn=) , actor= tensor(3.2175, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.7200, 0.0906, 0.6872], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "140000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.2760, grad_fn=) , actor= tensor(3.2115, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.7450, 0.0852, 0.7132], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "141000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(7.5781, grad_fn=) , actor= tensor(6.5270, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.0553, 0.1217, 0.7948], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "142000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.0990, grad_fn=) , actor= tensor(2.0283, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.8333, 0.8171, 0.0648], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "143000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.6593, grad_fn=) , actor= tensor(0.5895, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8373, 0.8206, 0.8066], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "144000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.6672, grad_fn=) , actor= tensor(0.5974, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8353, 0.8184, 0.8043], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "145000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(4.2835, grad_fn=) , actor= tensor(3.2190, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.8182, 0.0706, 0.7851], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "146000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7237, grad_fn=) , actor= tensor(0.6538, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8210, 0.8031, 0.7887], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "147000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.5935, grad_fn=) , actor= tensor(0.5236, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8552, 0.8384, 0.8243], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "148000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(2.7966, grad_fn=) , actor= tensor(1.7254, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.9187, 0.9063, 0.0710], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "149000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3488, grad_fn=) , actor= tensor(0.2789, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9211, 0.9102, 0.9000], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "150000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2870, grad_fn=) , actor= tensor(0.2171, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9386, 0.9292, 0.9201], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "151000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2422, grad_fn=) , actor= tensor(0.1723, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9514, 0.9433, 0.9353], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "152000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(2.9289, grad_fn=) , actor= tensor(1.8577, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.9498, 0.9427, 0.0479], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "153000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2002, grad_fn=) , actor= tensor(0.1303, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9633, 0.9567, 0.9501], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "154000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2227, grad_fn=) , actor= tensor(0.1529, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9567, 0.9495, 0.9423], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "155000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1972, grad_fn=) , actor= tensor(0.1274, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9640, 0.9577, 0.9513], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "156000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2019, grad_fn=) , actor= tensor(0.1320, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9626, 0.9562, 0.9498], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "157000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2086, grad_fn=) , actor= tensor(0.1387, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9605, 0.9542, 0.9476], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "158000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 1, 3])\n", + "loss= tensor(10.7576, grad_fn=) , actor= tensor(9.7065, grad_fn=) , critic= tensor(10.5111, grad_fn=) , return= 16106.203125\n", + "probs of actions: tensor([0.0112, 0.0488, 0.9295], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "159000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3577, grad_fn=) , actor= tensor(0.2878, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9159, 0.9089, 0.9013], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "160000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.4131, grad_fn=) , actor= tensor(0.3432, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9010, 0.8920, 0.8830], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "161000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(4.7231, grad_fn=) , actor= tensor(3.6690, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.0919, 0.8832, 0.8745], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "162000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3713, grad_fn=) , actor= tensor(0.3015, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9127, 0.9045, 0.8961], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "163000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2779, grad_fn=) , actor= tensor(0.2081, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9392, 0.9330, 0.9263], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "164000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2150, grad_fn=) , actor= tensor(0.1451, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9573, 0.9528, 0.9477], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "165000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(5.6652, grad_fn=) , actor= tensor(4.6111, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.0446, 0.9431, 0.9372], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "166000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 1, 3])\n", + "loss= tensor(4.2920, grad_fn=) , actor= tensor(3.2331, grad_fn=) , critic= tensor(10.5889, grad_fn=) , return= 16156.8125\n", + "probs of actions: tensor([0.9428, 0.0518, 0.9315], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "167000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3152, grad_fn=) , actor= tensor(0.2454, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9274, 0.9221, 0.9158], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "168000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3223, grad_fn=) , actor= tensor(0.2524, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9250, 0.9202, 0.9142], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "169000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3883, grad_fn=) , actor= tensor(0.3185, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9067, 0.9000, 0.8926], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "170000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.5187, grad_fn=) , actor= tensor(0.4488, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8708, 0.8619, 0.8529], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "171000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3813, grad_fn=) , actor= tensor(0.3114, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9097, 0.9016, 0.8932], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "172000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3709, grad_fn=) , actor= tensor(0.3011, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9131, 0.9044, 0.8957], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "173000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 3])\n", + "loss= tensor(8.4639, grad_fn=) , actor= tensor(7.4179, grad_fn=) , critic= tensor(10.4598, grad_fn=) , return= 16066.078125\n", + "probs of actions: tensor([0.0068, 0.8850, 0.8750], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "174000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7393, grad_fn=) , actor= tensor(0.6695, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8108, 0.8023, 0.7937], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "175000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.6230, grad_fn=) , actor= tensor(0.5531, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8421, 0.8331, 0.8241], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "176000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.5020, grad_fn=) , actor= tensor(0.4322, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8753, 0.8667, 0.8579], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "177000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.1461, grad_fn=) , actor= tensor(2.0754, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.8854, 0.8778, 0.0446], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "178000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7033, grad_fn=) , actor= tensor(0.6334, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8224, 0.8106, 0.7999], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "179000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7967, grad_fn=) , actor= tensor(0.7269, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7986, 0.7860, 0.7747], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "180000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.8868, grad_fn=) , actor= tensor(0.8169, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7780, 0.7619, 0.7489], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "181000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(3.1086, grad_fn=) , actor= tensor(2.0379, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.7345, 0.7207, 0.1115], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "182000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.2745, grad_fn=) , actor= tensor(1.2047, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.6858, 0.6718, 0.6611], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "183000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 0, 1])\n", + "loss= tensor(5.8304, grad_fn=) , actor= tensor(4.7761, grad_fn=) , critic= tensor(10.5433, grad_fn=) , return= 16128.5\n", + "probs of actions: tensor([0.6056, 0.0512, 0.1852], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "184000 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 1])\n", + "loss= tensor(7.2354, grad_fn=) , actor= tensor(6.1882, grad_fn=) , critic= tensor(10.4726, grad_fn=) , return= 16074.078125\n", + "probs of actions: tensor([0.0389, 0.6346, 0.1637], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "185000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.2191, grad_fn=) , actor= tensor(1.1493, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.6985, 0.6838, 0.6728], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "186000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9961, grad_fn=) , actor= tensor(0.9262, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7507, 0.7356, 0.7231], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "187000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7673, grad_fn=) , actor= tensor(0.6974, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8080, 0.7927, 0.7794], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "188000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7799, grad_fn=) , actor= tensor(0.7100, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8052, 0.7893, 0.7754], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "189000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.7943, grad_fn=) , actor= tensor(0.7244, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8019, 0.7853, 0.7711], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "190000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(2.9647, grad_fn=) , actor= tensor(1.8936, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.8129, 0.7945, 0.0925], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "191000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.8813, grad_fn=) , actor= tensor(3.8193, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.0923, 0.8104, 0.7955], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "192000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(2.8905, grad_fn=) , actor= tensor(1.8198, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.7850, 0.7656, 0.1234], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "193000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 3, 3])\n", + "loss= tensor(5.2078, grad_fn=) , actor= tensor(4.1538, grad_fn=) , critic= tensor(10.5406, grad_fn=) , return= 16120.5\n", + "probs of actions: tensor([0.0737, 0.8007, 0.7851], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "194000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(5.2927, grad_fn=) , actor= tensor(4.2307, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.0638, 0.8743, 0.8619], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "195000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(3.2196, grad_fn=) , actor= tensor(2.1485, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.9132, 0.9021, 0.0344], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "196000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3270, grad_fn=) , actor= tensor(0.2572, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9273, 0.9168, 0.9068], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "197000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2367, grad_fn=) , actor= tensor(0.1669, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9528, 0.9451, 0.9373], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "198000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2761, grad_fn=) , actor= tensor(0.2063, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9420, 0.9324, 0.9233], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "199000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2741, grad_fn=) , actor= tensor(0.2042, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9431, 0.9328, 0.9230], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "200000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2457, grad_fn=) , actor= tensor(0.1759, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9516, 0.9416, 0.9319], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "201000 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 2, 1])\n", + "loss= tensor(9.4285, grad_fn=) , actor= tensor(8.3785, grad_fn=) , critic= tensor(10.5004, grad_fn=) , return= 16096.0625\n", + "probs of actions: tensor([0.0423, 0.1229, 0.0564], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "202000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.6532, grad_fn=) , actor= tensor(2.5887, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.8330, 0.1244, 0.7953], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "203000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.7101, grad_fn=) , actor= tensor(2.6456, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.8592, 0.1108, 0.8237], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "204000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.5300, grad_fn=) , actor= tensor(0.4601, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8751, 0.8551, 0.8379], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "205000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.6005, grad_fn=) , actor= tensor(0.5307, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8563, 0.8352, 0.8173], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "206000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6653, grad_fn=) , actor= tensor(1.5946, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.8139, 0.7911, 0.1574], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "207000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.1340, grad_fn=) , actor= tensor(3.0720, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1698, 0.7451, 0.7252], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "208000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.8933, grad_fn=) , actor= tensor(0.8234, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7819, 0.7577, 0.7387], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "209000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(3.2967, grad_fn=) , actor= tensor(2.2255, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.7870, 0.7637, 0.0602], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "210000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 2])\n", + "loss= tensor(4.9102, grad_fn=) , actor= tensor(3.8474, grad_fn=) , critic= tensor(10.6283, grad_fn=) , return= 16178.078125\n", + "probs of actions: tensor([0.1670, 0.7523, 0.1883], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "211000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.1766, grad_fn=) , actor= tensor(3.1146, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1623, 0.7544, 0.7373], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "212000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 0])\n", + "loss= tensor(4.5420, grad_fn=) , actor= tensor(3.4706, grad_fn=) , critic= tensor(10.7132, grad_fn=) , return= 16232.8125\n", + "probs of actions: tensor([0.7082, 0.6890, 0.0106], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "213000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.0016, grad_fn=) , actor= tensor(0.9317, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7531, 0.7319, 0.7168], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "214000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9472, grad_fn=) , actor= tensor(0.8773, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7661, 0.7452, 0.7300], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "215000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 3])\n", + "loss= tensor(5.6584, grad_fn=) , actor= tensor(4.6017, grad_fn=) , critic= tensor(10.5669, grad_fn=) , return= 16140.578125\n", + "probs of actions: tensor([0.1646, 0.1761, 0.7505], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "216000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6553, grad_fn=) , actor= tensor(1.5846, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.7744, 0.7526, 0.1999], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "217000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(3.9847, grad_fn=) , actor= tensor(2.9227, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1946, 0.7216, 0.7048], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "218000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.2177, grad_fn=) , actor= tensor(1.1479, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7043, 0.6809, 0.6654], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "219000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.3094, grad_fn=) , actor= tensor(1.2395, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.6838, 0.6608, 0.6459], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "220000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.1503, grad_fn=) , actor= tensor(1.0804, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7195, 0.6962, 0.6806], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "221000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.2213, grad_fn=) , actor= tensor(1.1515, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7043, 0.6796, 0.6635], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "222000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(2.1106, grad_fn=) , actor= tensor(1.0407, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7296, 0.7049, 0.6880], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "223000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.9683, grad_fn=) , actor= tensor(0.8984, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7619, 0.7397, 0.7234], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "224000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 0, 2])\n", + "loss= tensor(7.4641, grad_fn=) , actor= tensor(6.4103, grad_fn=) , critic= tensor(10.5385, grad_fn=) , return= 16125.5\n", + "probs of actions: tensor([0.7595, 0.0076, 0.1962], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "225000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.0545, grad_fn=) , actor= tensor(2.9925, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1805, 0.7389, 0.7240], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "226000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.2628, grad_fn=) , actor= tensor(3.2008, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1455, 0.7887, 0.7735], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "227000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.4660, grad_fn=) , actor= tensor(2.4015, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.7961, 0.1619, 0.7626], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "228000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 1])\n", + "loss= tensor(3.1800, grad_fn=) , actor= tensor(2.1089, grad_fn=) , critic= tensor(10.7116, grad_fn=) , return= 16231.8125\n", + "probs of actions: tensor([0.8023, 0.7850, 0.0669], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "229000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.8675, grad_fn=) , actor= tensor(0.7976, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.7844, 0.7659, 0.7515], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "230000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.2257, grad_fn=) , actor= tensor(3.1636, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1542, 0.7668, 0.7493], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "231000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.5965, grad_fn=) , actor= tensor(2.5320, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.8296, 0.1324, 0.7919], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "232000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6577, grad_fn=) , actor= tensor(1.5870, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.8367, 0.8157, 0.1403], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "233000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.5625, grad_fn=) , actor= tensor(3.5005, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1134, 0.8205, 0.8036], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "234000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.6196, grad_fn=) , actor= tensor(0.5497, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.8505, 0.8301, 0.8135], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "235000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 2, 3])\n", + "loss= tensor(3.6203, grad_fn=) , actor= tensor(2.5558, grad_fn=) , critic= tensor(10.6450, grad_fn=) , return= 16191.25\n", + "probs of actions: tensor([0.8451, 0.1248, 0.8084], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "236000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(4.5930, grad_fn=) , actor= tensor(3.5310, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.1104, 0.8247, 0.8083], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "237000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.4142, grad_fn=) , actor= tensor(0.3443, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9050, 0.8893, 0.8763], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "238000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3228, grad_fn=) , actor= tensor(0.2529, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9307, 0.9169, 0.9050], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "239000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 2])\n", + "loss= tensor(2.7431, grad_fn=) , actor= tensor(1.6724, grad_fn=) , critic= tensor(10.7067, grad_fn=) , return= 16228.8125\n", + "probs of actions: tensor([0.9212, 0.9065, 0.0773], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "240000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3007, grad_fn=) , actor= tensor(0.2309, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9369, 0.9238, 0.9120], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "241000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2161, grad_fn=) , actor= tensor(0.1462, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9608, 0.9506, 0.9411], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "242000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2318, grad_fn=) , actor= tensor(0.1619, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9559, 0.9458, 0.9363], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "243000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1840, grad_fn=) , actor= tensor(0.1141, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9692, 0.9613, 0.9537], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "244000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1382, grad_fn=) , actor= tensor(0.0683, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9819, 0.9765, 0.9711], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "245000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1444, grad_fn=) , actor= tensor(0.0745, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9802, 0.9744, 0.9687], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "246000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1258, grad_fn=) , actor= tensor(0.0560, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9854, 0.9807, 0.9759], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "247000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1562, grad_fn=) , actor= tensor(0.0863, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9770, 0.9705, 0.9640], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "248000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2454, grad_fn=) , actor= tensor(0.1755, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9520, 0.9415, 0.9316], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "249000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2118, grad_fn=) , actor= tensor(0.1419, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9612, 0.9524, 0.9440], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "250000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3342, grad_fn=) , actor= tensor(0.2644, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9264, 0.9140, 0.9028], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "251000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3920, grad_fn=) , actor= tensor(0.3222, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9108, 0.8962, 0.8833], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "252000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2845, grad_fn=) , actor= tensor(0.2146, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9411, 0.9291, 0.9181], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "253000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3911, grad_fn=) , actor= tensor(0.3213, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9119, 0.8960, 0.8823], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "254000 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 3, 3])\n", + "loss= tensor(5.1156, grad_fn=) , actor= tensor(4.0536, grad_fn=) , critic= tensor(10.6202, grad_fn=) , return= 16173.078125\n", + "probs of actions: tensor([0.0714, 0.8823, 0.8675], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "255000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.3539, grad_fn=) , actor= tensor(0.2840, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9221, 0.9074, 0.8947], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "256000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2114, grad_fn=) , actor= tensor(0.1416, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9615, 0.9524, 0.9438], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "257000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1953, grad_fn=) , actor= tensor(0.1254, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9660, 0.9577, 0.9497], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "258000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2321, grad_fn=) , actor= tensor(0.1623, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9559, 0.9456, 0.9360], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "259000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2652, grad_fn=) , actor= tensor(0.1954, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9469, 0.9349, 0.9242], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "260000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2025, grad_fn=) , actor= tensor(0.1326, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9643, 0.9551, 0.9465], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "261000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.2095, grad_fn=) , actor= tensor(0.1397, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9614, 0.9533, 0.9455], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "262000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1894, grad_fn=) , actor= tensor(0.1195, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9669, 0.9599, 0.9530], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "263000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1779, grad_fn=) , actor= tensor(0.1080, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9698, 0.9638, 0.9578], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "264000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1898, grad_fn=) , actor= tensor(0.1199, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9666, 0.9599, 0.9531], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "265000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1519, grad_fn=) , actor= tensor(0.0820, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9776, 0.9722, 0.9666], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "266000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1800, grad_fn=) , actor= tensor(0.1101, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9697, 0.9629, 0.9562], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "267000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1636, grad_fn=) , actor= tensor(0.0937, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9746, 0.9682, 0.9619], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "268000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1553, grad_fn=) , actor= tensor(0.0855, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9770, 0.9709, 0.9648], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "269000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1384, grad_fn=) , actor= tensor(0.0685, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9818, 0.9765, 0.9711], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "270000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1606, grad_fn=) , actor= tensor(0.0908, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9757, 0.9690, 0.9624], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "271000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1597, grad_fn=) , actor= tensor(0.0899, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9759, 0.9693, 0.9629], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "272000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1394, grad_fn=) , actor= tensor(0.0696, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9815, 0.9761, 0.9708], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "273000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1217, grad_fn=) , actor= tensor(0.0518, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9863, 0.9821, 0.9778], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "274000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1219, grad_fn=) , actor= tensor(0.0520, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9864, 0.9820, 0.9776], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "275000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1106, grad_fn=) , actor= tensor(0.0407, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9893, 0.9859, 0.9823], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "276000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0841, grad_fn=) , actor= tensor(0.0142, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9964, 0.9950, 0.9935], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "277000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1123, grad_fn=) , actor= tensor(0.0424, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9889, 0.9853, 0.9816], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "278000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.1096, grad_fn=) , actor= tensor(0.0398, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9896, 0.9862, 0.9827], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "279000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0989, grad_fn=) , actor= tensor(0.0290, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9925, 0.9899, 0.9871], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "280000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0810, grad_fn=) , actor= tensor(0.0112, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9972, 0.9961, 0.9947], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "281000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0787, grad_fn=) , actor= tensor(0.0088, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9979, 0.9969, 0.9958], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "282000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0749, grad_fn=) , actor= tensor(0.0051, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9988, 0.9982, 0.9975], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "283000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0730, grad_fn=) , actor= tensor(0.0032, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9993, 0.9989, 0.9984], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "284000 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0723, grad_fn=) , actor= tensor(0.0025, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9994, 0.9991, 0.9987], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "284724 adversary: AdversaryModes.myopic\n", + " actions: tensor([3, 3, 3])\n", + "loss= tensor(1.0718, grad_fn=) , actor= tensor(0.0019, grad_fn=) , critic= tensor(10.6986, grad_fn=) , return= 16223.8125\n", + "probs of actions: tensor([0.9996, 0.9993, 0.9990], grad_fn=)\n", + "shouldBreak: True\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver(print_step=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns[0],columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss[0],columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.0200.0
1205.0195.0
2207.5192.5
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.0 200.0\n", + "1 205.0 195.0\n", + "2 207.5 192.5" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16223.8125\n", + "1 11694.8125\n", + "dtype: float64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05103.25004160.2500
15467.00003844.0000
25653.56253690.5625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5103.2500 4160.2500\n", + "1 5467.0000 3844.0000\n", + "2 5653.5625 3690.5625" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0125.50135.50
1128.00133.00
2129.25131.75
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 125.50 135.50\n", + "1 128.00 133.00\n", + "2 129.25 131.75" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD4CAYAAADsKpHdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1kklEQVR4nO3deXxU1dnA8d9DQhL2JYR9CfsOohFRFtlUlFpwrVYrrb7S2mJrFy0WcamooPbV+lJtbaUubRUXRFoEtW4oKhD2RdAAUcKWsIU1+3n/uHcms9xJJpNZMpnn+/nkkzvnnrlzrsH7zD33nOeIMQallFKqQawboJRSqm7QgKCUUgrQgKCUUsqmAUEppRSgAUEppZQtOdYNCFWbNm1MZmZmrJuhlFJxZe3atYeMMRlO++I2IGRmZpKdnR3rZiilVFwRkW8C7dMuI6WUUoAGBKWUUjYNCEoppQANCEoppWwaEJRSSgEaEJRSStk0ICillALieB6CUkrVJ+UVhpz8k/Rt38xdtib3CGtyj5CWnER5haGkvILi0nIm9G/H0C4tw94GDQhKKRVjpeUV9J61DIAxfTKYMa4Xt76YTeGZUsf6bZunaUBQSqlIOHSymKw5/wVg58OXkdRAIv6Zm/MK+XL/cb7YfZhF6/a6y1d8VcCKrwrcr2eM68X4/m3p3bYpKckNSElqgEhk2qcBQSmV0DJnLvV6feXTK3lrxqhaH7eiwvDutoNcMrAdW/Ye5+YX1lBwophHrhzM1LM6cfn8T/3es/3BSfSbvdz9essDl9A0NXqX6Wo/SUQWAN8B8o0xgzzKbwdmAGXAUmPMXSJyETAXSAFKgDuNMR+ISGPgNaAnUA782xgz0z5OKvAicA5wGPieMSY3fKeolFLOcvJP+JVtzCukvMLU+i6hx+/ediy/e9Fm7l602ausX/tmLPvFaESE3LmTa/W5tRHMKKPngUmeBSIyDpgCDDHGDAQet3cdAi43xgwGpgEvebztcWNMP2AYMFJELrXLbwGOGmN6AU8A80I8F6WUqpGNewoBeHDqIK8L8X1LtlT5vsIzpWzcc8xxX+bMpX53HYHcOro779wxhuV3jIlYN1BNVHuHYIxZISKZPsW3AXONMcV2nXz793qPOluBNBFJNcacBj6065SIyDqgs11vCnC/vf06MF9ExBhjQjslpeLD9gPH+d2izfzr1hGkNUyKdXMSjjGGX7+2EYAJ/doC8OlvxzFq3of844tvmTN1cMD3Dn3gXff25MEdeOJ7Z9HnnmVVft7uRy6jtNzw+to8tuwr5MphncjKbB2GMwmfUOch9AFGi8gqEflYRM51qHMVsN4VNFxEpCVwOfC+XdQJ2ANgjCkDCoF0pw8Vkekiki0i2QUFBU5VlIobk578hHXfHuO/Xx6MdVNqzBjDiSLnETDxIHPmUrrfXdml07FlIwA62b8BZr25mWC+ly7dvN8xGJzVpSVf/n4S/Ts05z+3j0JESEluwPfP68rDVwyuc8EAQg8IyUArYARwJ/CqeNzviMhArK6fH3u+SUSSgZeBp4wxu1zFDsd3/CsYY541xmQZY7IyMhzXd1Aq7iSJsGrXYZ75aGesmxK0Z1fsYvD97/Ja9h5W5hwic+ZSfvrPtbFuVlCKSssD7vPstvnnqm8Z8cj7fnWqCxIikDt3Mot/NpJGKUks+8VoBnVqEXqDoyjUx9d5wCK7W2e1iFQAbYACEekMvAncZIzx/Rf+LPC1MeZJn2N1AfLsgNECOBJiu5SKC0dPlbi3b/vnOvf2vOXbY/pQMVhvrMsD4M7XN7nL3t58IFbNCUpxWTmCeI3iAXhl+oiA7zl4vNiv7GRxGQDtm6dx4HiR1754+NtVJdQ7hMXAeAAR6YM1quiQ3R20FLjbGLPS8w0iMgfrYn+Hz7GWYD2ABrga+ECfH6j6bvPewoD7Aj2Q3HHgBDPf2OS4L9oCDYUsLgv87TvW+t6z3KtrZ+N9F5M7dzIjenj3UK+bfVGVx/nm8GkAbrqgm/3+1qQ3SWHnw5eFv9FRFsyw05eBsUAbEckD7gMWAAtEZAvW8NJpxhgjIjOAXsBsEZltH+JirIAxC9gOrLNvy+YbY/4GPAe8JCI5WHcG14Xx/JSqk25asLrG77nkyRUAtGueRqeWjZg0uD3N0xqGu2lBWfftMcfy/OPFdGndOLqNCVGLRs7/7Vo3SWHNrIlc8fRK8o6e8du/bd9xAAZ2tLqBXpl+fuQaGWXBjDK6PsCuGx3qzgHmBKjvOKbKGFMEXFNdO5SqLwpO+HdDpDdJYfkdYzj3IWu27JmSchqlVI48KiuvcG//8f2vAbjrjU0x66IQAaf7+MOnSupkQPD87xeMjGappDdNJe/oGfKPFzH84fe585K+/HRsT+6y79LqY0eGZjtVKooe/M8290Uf4I3bziejWSprZk0ko1mqu3zdt0e93re/0LuvOtZc18LcuZPJnTuZp64fBsDKnEMxbFVgm3y66B67eki179l3zLo7GP6w9WD5sXd2cMXTn7n3n1sHRwnVlgYEpaLouU93u7cn9m/LOd1as2bWRBrYs2Ifv2YoAEs27PN630c78qPXyBCc060VYHW31EW3vpDt9XrKWZ2qfc8frzvLr2yDx2S0JlFMKREtGhCUipF5V/l/S3WNg1+Yvcd7hz0ccsmMkXx+93h3sVP3UyS5hpgCXD+8i7u8eZp1cTxlj8Cpaw57jOoCSEmu/tJ3dtdWAfd9NefSgPvimQYEpWLghZuHk9401a98WNeWjvV35p8ErNE9HVpUTp6a8a91jvUj5Ya/rXJvv7et8q6lcYoVEE7W0YDg4uriCkZVs8eDCSjxqH6elVJ13IV9nCdWBroIPf9ZLgDpTawgMvWsjgCs2n2Ej7+Kzaz9/xnd3b2d1EBo1DCpzt4hhOrGEV39ypql1b+uIpf6e2ZK1VHXnNO5+kpY6ZMb+GTcbNHYGip516R+LLafM0xbsDomo41Ky7xH7jROSeJUSd2dhxCKOVMHc/v43mQ0TeVkSRmNGyaRnFR/v0fX3zNTqo5xTdp6bW1elfVcMWCrPd69vMJ/eGOHFmler4tKy8mcuZSnP8oJuMpWuN06pofX67SGSe60EJvzCsmcuTRqbanKXnu0UJfWjaqp6axd8zQaNBCapzWs18EANCAoFRVnSso5/5EPgqo72M578/eV1ogk3yGoYOXc2Xz/xe7XrnQMjy7f4ZWJM1K2PzjJr3urUUplQHAt/vK7Nzf7vTfaXGmqu9bB+RF1jQYEpaKg/73LOWKPdPn5hN5V1v3RSKtvftF6a1nF1but1F5XDvMeKtnMY5ZyNB5yuvIvNUtNdnzW0ahhEqd9uowKHHIBRdsra6wRW9PH9IxxS+o+DQhKRVlKUtULoZzXw3vC06dfW5O9rqri2UNJWc1m4oYi9/ApAK7Ocm5Ho5Qk8n0CwOrc2OepdK1P7PvMQ/nTgKBUFNwyqnJEzqRBHaqs6zmsdFfBSdo1t0YWDensn0L57kv7OR4jEmkVXJk/L+jZxnH/6t1H2Lb/OO/XkfUdXCuXDbdnFE/o3zbGLar7NCAoFQWuWa3/d/0werVtGvT7xv/hY/doIqcMo4Fm3BaVhv/bsOuheHpT59nIrlXHbvGZFRxrrruUurBEZV2nAUGpKFi45lsALh/aMaj6nncULk4XNNfdg8v9lw8A4EwVi8CE6hevbADgG7vryFfX9MY0cwham/MCp/qOlJz8E1H/zPpAA4JSUeC00EpVfnhBZlD1RMR9xzGkcwtKy62uoqOnK1M1ZM5cygUOK3+FyrNLy1OjhklegehHIzOB2MxefuDf26L+mfWBBgSl6qCOLYMfM59jp7XYlFfIP1d9A8AvF24ArEV1APYVFoXtuUK3dOfhm6eKyyjzmDPRp10zAB7499awfG51Dh4vYsOeYxw6WVznssPGC52prFQdlNRAeOiKQcx6c0uN3vfsTVlc/MQKNtndNC+v/ta9b++xM3RuVfux+O2apTmWN/VJ6dDF/qztB6LTfXPew+G7C0pUeoegVB11w3ndaGWnqhjQoXlQ7/GdfHXMo+voe3/5Iizt8k2n4TK+n/conlG9nUcjhYMxxj0JLhi/uqhPxNpSn2hAUCrCjDE0EJgxrleN33v0tJX6Ydv+40HV950w1spjfQJXCodIyUxv4t7e5DGLOhImP/Up/WYvd59Tdd1h033SbChnGhCUirDTJeVUGP8ulXAZ2qUlADecZ2Xm7NOuclhr9zZNnN4SEZ6L4ziNNgonV4Bc942V1mPe8h2O9f52UxbXZnWuMpW1qqTPEJSKsHx7EZtvj5yu8Xt/O6kf85ZvZ9FPLwhY562fjfRag7ld8zSO2XcWNelWqUowxxERtj5wCceLSv2GyBpjqpwH8O7WA9y/ZCuf3T2hRu26/eX1bD9wnD9/vNNv3yd3jaNL68ZMHNCuRsdMZHqHoFSEudJKZAYYnVOV28b2JHfu5CpX7wLcwcD6nCbu0T5/+tD/QhmKvKPBdTc18VnAx8W19OTDb39J5sylfhlcp7+0ln2FRWzZW/M5C77nuOWBS8idO5kumsyuxjQgKBVmJWUVbD9Q2edfWm4FhO5tgp+hXBuL1+/lyKkS9hw57U4/HWrqZ5dnV1gX3f5BPtx2Sbe7ka54+jMyZy7l2RW7ACslh5NnPqo+gHk+KPe1+5HLHGd0q+BUGxBEZIGI5IvIFp/y20Vkh4hsFZFH7bKLRGStiGy2f4/3qH+OXZ4jIk+Jff8oIqkistAuXyUimWE+R6Wiqs89y5j05CdkzlzKwjXfui+CjaLUj33CngjmmXp6zxHrG35ZeWgpLV7NttZw6FrDwHLFMOfUGrPfqryceCbm8wykgby9+UDAfZqeonaCuUN4HpjkWSAi44ApwBBjzEDgcXvXIeByY8xgYBrwksfbngGmA73tH9cxbwGOGmN6AU8A80I6E6VibN+xM+4F6F1++8Zmlmy0chFFIp2Ek4vsPvODx/0nZ4XyHMNTdam7ff364r6O5V/sqsyC+t62ymR4Wd1aO1UHrOcQ5RWGecu316gNKnjVBgRjzArAN4ftbcBcY0yxXSff/r3eGLPPrrMVSLPvADoAzY0xnxtrfNiLwFS73hTgBXv7dWCCaJhXceiCuVUvgJNcTdrrcLl9vDW89auD/t0yOwuc8xC5nCkp55o/f+ZeVObY6RKvINczo2bdXp7PNgJ57J3KC/zC7D0B63W/+216/u5tx7uOTi0bxWQZ0fom1GcIfYDRdhfPxyJyrkOdq4D1dtDoBHiuG5hnl2H/3gNgjCkDCoF0pw8Vkekiki0i2QUFsVlYXKlQdapBOoraaNM01a/sxxf2sPc5Zyp1eWTZl6zJPcqUP63kpc9zOev373ntD+fwTVcCut52iguXl774xq+u5zyD5z/L9du/cuZ4vzJVc6EGhGSgFTACuBN41fNbvYgMxOr6+bGryOEYJoh93oXGPGuMyTLGZGVkZITYdKVio4/PhS9SfNdbnti/HRX2qJ7nPt1d5XvfXLfXvT37rcjmIJr4vysA/NZdnr3YP12HZxeTS98o/fdMJKEGhDxgkbGsBiqANgAi0hl4E7jJGLPTo77nMkudgX0e+7rY700GWuDfRaVUnRbqw9pI8O1x/fmEXozpY32Bqu7BdqDV0MJhePfWXD+8C1ee7d3l45vyAvxnHr+21r8r6Z1fjuGJ7w3lqzmXhrehCSzUgLAYGA8gIn2AFOCQiLQElgJ3G2NWuiobY/YDJ0RkhH0ncRPwlr17CdYDaICrgQ9MJJZ7UiqC/uuwSliAlD9R179Dc3q3tb5Nv7Y2z702spO/r8wN++f/e8YourRuxMLpI3jkyiE8dvVQr/15R60H3S/cPNxd5pu+epHHnYunK4Z1jsp60okimGGnLwOfA31FJE9EbgEWAD3soaivANPsi/gMoBcwW0Q22D+u8H8b8DcgB9gJLLPLnwPSRSQH+BUwM3ynp1R0/OQf6/zKKurI15qGSQ28FtJ5/F3nNA+RMrhzCz65a7z7ziXJJ1L+4wsrI+uFfSq7gRety6MqP7mwZ5hbqSCI1BXGmOsD7LrRoe4cYE6A42QDgxzKi4BrqmuHUtG0evcRrv3L53z5+0lBjZRp1bihOxGdk80RTvbma82siZz70H/drz27kf656lseumJwVNsTiO8wXZfjRWWcKCpl8P3vctXZld1Yj1w5mOzco/zyopoNf1XB0XstpRxc+5fPAfhDkN+mfzTSWvJy0sD2ADz5vbO89jdLaxi+xgUho1kqG++7mJyHgu9f3+MxR2H3I5fx15uyvPZH41v58jtGu7cH3/8uAG943C1cP7wrf7h2KKnJmqwuEjQgKFWFv1UzKsfFlTvoyevOYtfDlzF1WCfO7+E4ejpqWjRqSHJS8P+Lu1YZa9ssFRFhYv/Kh70pSQ34+YSap++uqX7tK1NjTHB42KwiS5N+KBUGf/owB4DU5Abu7pl//M959Pzd27FsVkBHTpV4pauGyruiH4zoBljdTLGc7DW8e2ve354fs89PRHqHoFQYuLJ3evbVJzUQ/u/6YXz0m7ExapW3NbMmurerGiY7oGPNEtjV1s0juzsGnmAXBVLhowFBqQi6fGhHMqO4SE1VMpqlcs/k/gAUlQYOCNEYxvmixxDTey8f4LXPNav6rQ37vMp7ZtSN/471mQYEpRLIAfs5QcFJ/8R3LmfZK7BFku9sak/92zvfodwzeYBjuQofDQhKJZDh3a1sokkNAv+vH40RUT0zmnLpoPYsmTHSb1+gRXLG9tV0NZGmAUGpBLLWXoP4UZ8U0lXNXo6EBg2EZ248hyGdW/rtG9SpheN7NAly5GlAUMpHTdchjqdMK4dOWhf+z3Ye9iovLqs7uZhcw19V9GlAUMpHsc8D15P2CmSe9h47w2c7DwFw2P52PaSz8zfbuuSBKQMdy4vLrCD42NVDotkcR7eO7u7ebtU4uhP6Ep0GBKV8uC6OLk4rj42c+wHf/+sqAO54ZQMAm/JqvkB8tAVab9i1mE7e0TPRbI4jz8l0t4+3UlT8eEyPWDUnoWhAUMrH4g3emTUn/OFjPgwwQaqsvILu9rDSlBrMCq5rFq+3ztl3bYJY+9HITHLnTubuy/rHuikJQWcqK+WjQwv/lc1+9Pwax8lTT/73a/cKX7+YGL8J15Zu3g/AuZmB1zSOJl0OMzbi9yuNUhHyztYDQdedb6esAGvGbbzLbNM41k1QMaQBQSW00vIKvzQOmelWF9C/bj2vRscKJk12XeI0OqpHm6YxaImqKzQgqITWe9Yyes1a5lXm+ta/ff+JWDQparbsrcwV9J0hHYD4C2oqvDQgKAXsLDjpV5aV2SoGLYmey+d/6t7++KuCGLZE1RUaEJTCGknkK1BSuoq6sjZmiNo2S/UrG9AhuhlOVd2kAUElrOqGWDb3yenjmp9wssR/olo8+cAhHfeq3Uei3xBV52hAUAlr+Zb91dbp2rpy1M1b6610zKeL/VNbDA6Qf6cuCjQ5TSkNCCphBZP3f8Vd49zbr9tr+x5xSAT3aB1I+aBUbWlAUAnL89t/VYbaOYrSGlojcH7+ynqv/bO/M4D+2gev6oFqA4KILBCRfBHZ4lN+u4jsEJGtIvKoXZYuIh+KyEkRme9T/3oR2Swim0RkuYi0sctTRWShiOSIyCoRyQzj+SkV0BKfFbnKK4zjA+MTRdYzgxX2SJxrzukMwMu3jiB37mRuGRX/E9KUguDuEJ4HJnkWiMg4YAowxBgzEHjc3lUEzAZ+41M/GfgjMM4YMwTYBMywd98CHDXG9AKeAOaFdCZK1dC72w56vd66r5CF2Xv86t0y2vuC/yd7nkJaw/i9wZ7Qry0Ax4vqVu4iFVvV/os2xqwAfIcg3AbMNcYU23Xy7d+njDGfYgUGT2L/NBFrlYvmgOvr2RTgBXv7dWCC6EoYKgp88+7vPnSK/33vK796/XyWdDxu3zE0S4vfh7Pv28n6Ln3yE/eMZVeQUIkr1K84fYDRdhfPxyJyblWVjTGlWEFkM1YgGAA8Z+/uBOyx65UBhUB6iO1SKmT//OJbCk4UAzDcI8mb7xrD/do3A6BX22ZRa1u4DevaErBmJhfZ6z+cU88n4qnqhRoQkoFWwAjgTuDVqr7Vi0hDrIAwDOiI1WV0t2u3w1scZ/6IyHQRyRaR7IICnVmpwsM1DHN1buWNcIbH5K2kBt7/RFs3SYlOwyLoqeuGAZCZ3pi7F20CYOEa/+4ylVhCDQh5wCJjWQ1UAG2qqH8WgDFmp7HuT18FLvA4VhdwP2togX8XFfb7nzXGZBljsjIydMFtFR7XZnXxK6sqlbXv8pPxyDXpruBkCYvth+vfHD4dyyapOiDUgLAYGA8gIn2AFOBQFfX3AgNExHUVvwj40t5eAkyzt68GPjDxtEitins3j8oEYEyfyi8Zfdo5dwdlzlwajSZFnCuJ3cY9x9xlV57dKUatUXVFtU/FRORlYCzQRkTygPuABcACeyhqCTDNdREXkVysh8YpIjIVuNgYs01EHgBWiEgp8A3wQ/sjngNeEpEcrDuD68J2dkpVYUSP1hw5VeJOYbEigRK8OU3Ke+TKwTFoiapLqg0IxpjrA+y6MUD9zADlfwb+7FBeBFxTXTuUCidjDF/ssnomO7fSRWEAUpM19XWii99xc0rVwnXPfuHebh7Hw0fDYWjnFjRv1LD6iqrei9+ZNUrVgmd2z2CmvWSm17+7iOHdW3Ne99YcLyqjhQYEhQYElaB+d1k/AN795RgA/qea9BMdWzaKeJuiLf94Eat2H6HwTKkGBAVoQFAJyjUBrZv9zX/T3sIq698zeUDE2xRtufYwUw0IykUDgkpIf/1kN1D5IDU7t+oFYg6dLPZ6fbY907c+KK8wGhAUoAFBKQDO71mZLeUTjzUQXAZ09M5n9MZtF/jViWf6UFmBBgSlAHj4isox+O2ap/ntT/dIV5E7d3JQD6LruoeuGOTe1jsEBTrsVCkAOrSofGjcMMn/Yi8ibHngEsod1kuIV67nKKABQVk0ICiFNXN3yYyRCBLw2399W4vYlc8INCAoS/36F65UDUw7v5vX6yGdW8amITHSOKVyZrIGBAX6DEFF0MHjRWTOXMryLftj3RQvh+0RQy98/k2MWxJbo3pXJijWh8oKNCCoCDrv4fcB+Mk/1sW4Jd5yD5+KdRPqhLSGlXcIzepZd5gKjQYEFRWnS8pY/+3RWDcDgNxDmvcfINUj42mDBvE/akrVngYEFRUD7n2HK57+jIPHfZfbrr3isnIyZy4l72hwF/pdh04CkJzgF8FmadpNpLxpQFBR9VIE+u0H3fcOAKPmfcj3//oFp4rLqqy/M9/qMuqR0STsbVEqnmlAUBGxKe+YY3n7Fv6TvmqrtLxybsBnOw8z0A4QgbjuEHq0aRr2tigVz/RJkoqI785f6Vh+z+It3Diim+O+SHAteZk7d7K7bFeB3iG4rLhzHOW6Yq2y6R2CCru6uCT2oPveoai0HIAye7Zxjwy9Q+ia3pjubTQwKosGBBV2+wsrHxxf6LFwfSydLC4jO9d7lFNPvUNQyosGBBV2b67f695+/JqhEf2s3EOB5xT45h268blVXq/1DkEpbxoQVNj1tC+0c6YOIqNZKp1bRW61sbGPf+RYbozxSt7mUuERJBJ9LWWlfOn/ESrsKuxnCGd3bQVA3tEzUW9D97vf5rtDO/qV9/jd2+7t+pDCWqlw0jsEFXZPf5QDwJ4gJ4pFypKN+2L6+UrFm2oDgogsEJF8EdniU367iOwQka0i8qhdli4iH4rISRGZ71M/RUSeFZGvRGS7iFxll6eKyEIRyRGRVSKSGcbzUzFwyYD2AAy1s4c++b2zALh4QDuaRaib5vO7xwfcpzcCSgUnmDuE54FJngUiMg6YAgwxxgwEHrd3FQGzgd84HGcWkG+M6QMMAD62y28BjhpjegFPAPNqeA6qjnElTWtqX/ynDutE7tzJ5BSc5ERR1bOIa2p07zac3bUlHVo0YsecSYxxGNV0UxTnPSgVz6oNCMaYFYDvCuS3AXONMcV2nXz79yljzKdYgcHXzcAjdr0KY8whu3wK8IK9/TowQbRzN66dKrEu+o08smlC5TOFcPrk60Os+/YYAKnJSbzwo3P96lzYt24MfVWqrgv1GUIfYLTdxfOxiPj/X+hBRFramw+KyDoReU1E2tllnYA9AMaYMqAQSPc/CojIdBHJFpHsgoKCEJuuIu1MSTmpyQ1I8kke1755Gg0kfBPXKhyWs3T6LpGV2Tosn6dUfRdqQEgGWgEjgDuBV6v5Vp8MdAZWGmPOBj6nspvJ6X2OVwxjzLPGmCxjTFZGhn7rq6tOl5R7rcblktRAqDCVM4W37ivkP5tCf/B79HRJUPWccv1r2gql/IUaEPKARcayGqgA2lRR/zBwGnjTfv0acLbHsboAiEgy0AL/LioVR6yA4H8RXrByN4A7Bfbkpz5lxr/Wc7oktOcKJ+2spu2beyfMe++XY7xeO31XcT3oVkpVCjUgLAbGA4hIHyAFOBSosrH6CP4NjLWLJgDb7O0lwDR7+2rgA1MXk+GooB0+Veyei+ApvUkK4L9Azbxl20P6HNdM5N9e2tervHe7Zn5150wd5N6+4byuDOrYIqTPVKo+C2bY6ctYXTx9RSRPRG4BFgA97KGorwDTXBdxEckF/hf4oV1/gH2o3wL3i8gm4AfAr+3y54B0EckBfgXMDNvZqajLnLmUj3YUeOUzcjl6uhSwUkj83b5bgNDXNnYthVlUWuG3r1t6Y6/X12Z1AeBHIzN56IrBukKYUg6qHRRujLk+wK4bA9TPDFD+DTDGobwIuKa6dqj4N2lgexZm7wHggX9vq6Z29W5+PhuA+97ayvXDu3rte/yaoVzz58/dr1OSG3ilwFZK+dOZyipqqlrcvrTc/1t+sMY6DCvN6hb+Ia5K1XcaEFTUPPfDwKOTt+wtDPm43z3LP2eRiLD5/ovZ+fBlIR9XqUSjAUGFjWe66VG9/AedNXUY/ulyxdOfhfy5E/u3cyxvltbQby6EUiowDQgqbA6frEw3/bzDjGGAds1Tw/JZZ0rK3dtpDf3nPCilak4DggqbL3ZXTh9JTnL+p7XqdxO9Xl82uH3A433n/z4hc+ZS9hw57Z5z4NL/3uW1aKlSyomuh5CgikrL6Td7OY9eNYRrz+0SlmMeC3Lm8NcPXcrnOw9zTrdWNElNJnPmUsd6W/YeB2D0ox8C6CghpSJM7xAS1Ptf5gNw1xubwnbMpZv2B1WvYVIDxvTJoEmAZwr3vbWFrDn/9Sv/1cINDLrvHQAymoWn60kpVUnvEBJUi0YNw37MVXaXUWt7RnIoThSVBpyotsheq/nrgyfcy2Mu/tnIkD9LKeVNA0KC+vVrGyJ27OuHh9YFFajryNdFT6xwb5/VpWVIn6WU8qcBIUEdPO6/AH2o1n5zhGWbD7hf/+TCnmE7tlIqejQgKErKKkhJDv1x0lXPfO71ulla+LujlFKRpw+VE1BJmXeaiP2FZ2LUEsu/Z4yK6ecrpSwaEBJQn3uWeb3elBd62ohwZCrv18E/XbVSKvo0ICSYu17f6Fd2+8vrQ04u5zthLBQNA0xiA3jkysE6kkipKNGAkGBezc5zLF+ZE3B9oyrtORLZ7qbrzu3iNZJo2S9Gu7eHdtZFbpQKJw0ICczzm7fTgjbBqHIl7RrwHT7aqnFD+/jWB9w2tieXD+1I/w7N6WuviPaWPntQKqx0lFEC87wIb95bSKCVkKpSVXdPTWzYc8zr9fp7L/Z6/dtJ/dzbnncJSqnw0TuEBOL5APjlW0d47Tt+ppSVOYfInLmUg8e97xYyZy4lc+ZStu077nfM4rJyr9f/e+3QMLbYWYMGoktgKhUBGhASyGk7ZfQPRnTj/J7pANx/ubXk9X827eeGv60C4J7FWxzf/935n/qVTZm/0uv1lWd3Dqlt08f0cG9vvO/iKmoqpSJFA0IC2VlwEoDVHmmqrzrH/wL+3raDACzfcsArnUSZxwI4Xx08QebMpe6yG87rWqtspN3SG7u3I5FnSSlVPX2GkEA++doaSXS8qNRdFmgVs3988Y3jncLP/rXOMavpg1MG1aptE/u3Y9abzncmSqno0DuEBDKokzVM877LB7rLJMAwoUDdRoFSXNe2T79d87RavV8pVXvVBgQRWSAi+SKyxaf8dhHZISJbReRRuyxdRD4UkZMiMj/A8ZZ4HktEUkVkoYjkiMgqEcms5TmpAMorrMln7VvUzYvvB7++kA9+fWGsm6FUwgqmy+h5YD7woqtARMYBU4AhxphiEWlr7yoCZgOD7B8vInIlcNKn+BbgqDGml4hcB8wDvlfD81BVuOCR9xndO4OF2XsAOHIqfJlOw6lHRtNYN0GphFbtHYIxZgVwxKf4NmCuMabYrpNv/z5ljPkUKzB4EZGmwK+AOT67pgAv2NuvAxMkUD+GCsm+wiJ3MABo0ch7AZv//moMN4/sDsCPPUb7eGrTNPRFb5RS8SHUZwh9gNF2F8/HInJuEO95EPgDcNqnvBOwB8AYUwYUAulOBxCR6SKSLSLZBQUFITY9sTgln+veponX615tm3Hv5QPInTuZuy/r73icv96U5Vf28Z1jw9JGpVTdEGpASAZaASOAO4FXq/pWLyJnAb2MMW867XYoc0yhaYx51hiTZYzJysjIqHmrE1BxmX/Suposcfmf20fx3LQshnVtxaNXD3GXz/7OALqlN+GZG87m09+OC0tblVKxFeqw0zxgkbG+fq4WkQqgDRDoa/v5wDkikmt/ZlsR+cgYM9Y+VhcgT0SSgRb4d1GpEBWXhpbF1GVQpxbu0UnXZnXh8iEdKS4rp2VjK6hcOrhDrduolKobQr1DWAyMBxCRPkAKEDBdpjHmGWNMR2NMJjAK+MoOBgBLgGn29tXAByYcSfaj7OmPcvjt65ti3Qw/RT6pJW4d3T3o977lkHa6UUqSOxgopeqXau8QRORlYCzQRkTygPuABcACe/hoCTDNdRG37wKaAykiMhW42BizrYqPeA54SURysO4Mrgv5bGLo0eU7AOjTvhm3jAr+ohtpvovfzJo8oNr37JgziZKyCl0KU6kEU21AMMYESoJ5Y4D6mdUcLxePIanGmCLgmuraUVcs27yfLw+c4FcX9XHc/+B/tgUMCGXlFfz3y4NMGhS9bpZbX8x2bzdOSQrqPanJSaQmB1dXKVV/aOqKGrrtn+sAvALCsdMlQb231yxr6cqfj+/Fry7uG/7GORie2ZrVuUd49cfnM7x766h8plIqPmnqihBVeCR6q+maxE99kBPu5jj69vBpVudaz+drMrJIKZWYNCDUQLlHEPjUY8lJVxZRXyeLy3h364GIt8vJko37GPPYh+7XPXzmHiillC8NCDWQf6JyAvYf3t3h3t5VcMqrXnmFYceBEwy67x2mv7SWL3Yd9jvWVc98FrmGAj9/eb3Xa11QRilVHX2GUAPvf5nv3t7o0U3ke4dw/Ewplzy5wv36ume/4Pwe3pOv135zlLLyCpLDtASlUkrVll6NauBMSeWYfs/1iLMyrYe1roe2peX+k8E+d7hLWJN7NCxtUUqpcNCAUAOPvrPdvT2sa0v39lPvfw1ULjbjlC4inOZ/8DX9713utfKZJ8+ANPfKway4U1NLKKWqpwGhBkrLKx8q/31lrt+dwL5jZwBYkxtc5o273thY4za8vjaPx9/9CoA/vv+VY50DhZXPOq4b3pWuHstTKqVUIBoQguTURfPu1oNer0f1agNAUZD5g/YcOVOjNhw9VcJvXqsMIrsKTnHCYzlMF32ArJQKhQaEIPW/d7lf2dLN+7xepza0/nO+9MU3QR83c+ZSVuYETAPlZoxhxCPve5XtLyxi8P3vUlZeQbFHzqKiUmu7VWNNPaGUCp4GhCBc+5fPHcvf3uw9xyDNTvfw5f7jNTr+DX9bFXBfaXkFJWUVfPRVQcBnE71mLaPvPZUBK++odecRaG0DpZRyosNOgxDo4S3AqeIy93ZKcvjja2873UUwlmzcx3eHdmTagtUA/OXjnVyb1SXsbVJK1U96hxCCSwe1d2+PeLiyG8fp4pvk05//8wm9a/35f/+h8wJ1vpPRpgdYDlMppZxoQKiG74zi3LmTGWk/PAY44XGH0MonX9APL8hk58OXkTt3srtsaOcWXq9dMmcuZcTD7/PN4VP8Z9M+Mmcu9Xou4PLLiX0Y168tr//k/GrbrovXKKVqQgNCNdZ+Uzl5bMkMa8GYYLthxvdr695++oazAbiwT+ClPw8cL+LCxz5ixr+sb/p/XbHLr84vJlp3GFmZrflxNXcATVK0R1ApFTwNCDXgyhjq9KzgogHt/Mo8001fNrgDuXMn1yhVhWu+QSA/HdvLr+ytDXvd277dVUopVRUNCDXQqWUj9/ZXcy712vfIlYP96idH+ILcwmFY6S9e2RDRz1RK1V8aEGpApPIC73uX4Epb4SmYb+hO76uJOVMHccnAdlw+tGOtjqOUUhoQgnTP5KrH9Kc19F9y0jOA+Hr4CuuOIvueibVq140juvGXH2TRJMjlMZVSKhANCFXInLnUvf0/o/0f4L7989EhH/v753Uld+5k0homOY46qim9Q1BK1ZYGhAAKT/vnCPI1oGNzFv30AtbPvshdNv/7w0L6vOx7JvLCzcOrrFPVXYrnUFillAqFBoQARs37IKh6Z3dt5TX/4DtDQvum3qZpapVDUgHG9q16v6fVsyaE1A6lVOKqNiCIyAIRyReRLT7lt4vIDhHZKiKP2mXpIvKhiJwUkfkedRuLyFIR2W7Xn+uxL1VEFopIjoisEpHMMJ5fyMb3b1t9pQDe+tlIPr97fBhbY0lJCv45QevGKdVXUkopD8HcITwPTPIsEJFxwBRgiDFmIPC4vasImA38xuE4jxtj+gHDgJEi4hq3eQtw1BjTC3gCmFfTk4iELq0q1xDYeN/FNXrv0C4t6dCiUfUVHbz/6wt5ZfoI3rjNmon8f9dXdkGlNQz+hk6X5lRK1VS1Vw1jzArAN7vbbcBcY0yxXSff/n3KGPMpVmDwPMZpY8yH9nYJsA7obO+eArxgb78OTJCqhudEyfwPcwC485K+tGgUvTTSPTOaMqJHOud0a03u3MlcPrQjj109BLC6lapy9TnWf9KpZ+kDZqVUzYU6CL4PMFpEHsK6+P/GGLMmmDeKSEvgcuCPdlEnYA+AMaZMRAqBdMBvkQARmQ5MB+jatWuITa+ZSwa2r75ShF2T1YVrgkiX8dAVg5h2fiaDO7eIQquUUvVNqP0KyUArYARwJ/BqMN/qRSQZeBl4yhjjStTj9D7jUIYx5lljTJYxJisjI/gHrLXRtXX8LD+ZmpykwUApFbJQA0IesMhYVgMVQDDjHp8FvjbGPOlzrC7gDhgt8O+iiirPIaeRWONAKaXqolCvdouB8QAi0gdIwaGLx5OIzMG62N/hs2sJMM3evhr4wBjjeIcQLUN//24sP14ppWKi2mcIIvIyMBZoIyJ5wH3AAmCBPRS1BJjmuoiLSC7QHEgRkanAxcBxYBawHVhn9y7NN8b8DXgOeElEcrDuDK4L4/kppZQKUrUBwRhzfYBdNwaonxmgvuMzBmNMEXBNde1QSikVWdpBrpRSCtCAUCXPBW6UUqq+04BQhZduqTrZnFJK1ScaEKqQmqxrDCilEocGBB+uEa9tm1WdJkIppeobDQg+zpSWAzChFtlOlVIqHmlA8HHweDEABSdKYtwSpZSKLg0IPpZt2Q/ARzvyY9wSpZSKLg0IPnYcOAHA7eN7x7glSikVXRoQfLy1YR8ArZtEbw0EpZSqCzQgeHh36wH3duGZ0ipqKqVU/ZNwAcEYw/YDxx33zVu+3b09qJOuK6CUSiwJFxCWbt7PpCc/YfH6vX77xvWtHGo6pnd0FuBRSqm6IuECwmvZeQDcsXCD375/rf7Wvd2gQcyXdVZKqahKuIBQ1bOB0yXlUWyJUkrVLQkXEJqlVS4BUVpe4VjnlekjotUcpZSqMxIuIKQ1rExY53lH8N62g+7tgR2bR7VNSilVFyRcQNicV+jeLiqtDAi3vpjt3m6WpnMQlFKJJ+ECwoNTB7m39xcWAbBtn/MwVKWUSiQJFxAuGtCOR64cDMC9b20B4IF/b41lk5RSqk5IuIAA8PzKXAA22d1Hh09pZlOllErIgNC8UeVIo8Mni8nJP+l+fe93BsSiSUopFXPVBgQRWSAi+SKyxaf8dhHZISJbReRRuyxdRD4UkZMiMt+n/jkisllEckTkKRERuzxVRBba5atEJDOM5+eofYtG7u1/raqcjPbGbedz86jukf54pZSqk4K5Q3gemORZICLjgCnAEGPMQOBxe1cRMBv4jcNxngGmA73tH9cxbwGOGmN6AU8A82p2CjX3++8OdG//4b2v3NvndGsd6Y9WSqk6q9qAYIxZARzxKb4NmGuMKbbr5Nu/TxljPsUKDG4i0gFoboz53FiLFr8ITLV3TwFesLdfBya47h4ipVWTlEgeXiml4lKozxD6AKPtLp6PReTcaup3AvI8XufZZa59ewCMMWVAIZDudBARmS4i2SKSXVBQEGLTLXde0rdW71dKqfom1ICQDLQCRgB3Aq9W863eaZ8JYp93oTHPGmOyjDFZGRm1y0b607E9a/V+pZSqb0INCHnAImNZDVQAbaqp39njdWdgn8e+LgAikgy0wL+LKuwi3CullFJxJ9SAsBgYDyAifYAU4FCgysaY/cAJERlh30ncBLxl714CTLO3rwY+sJ8zRNW5ma2i/ZFKKVWnJFdXQUReBsYCbUQkD7gPWAAssIeilgDTXBdxEckFmgMpIjIVuNgYsw3rQfTzQCNgmf0D8BzwkojkYN0ZXBemcwvauL4ZLPhhdY9BlFKqfpMYfBkPi6ysLJOdnV19xSrsKjjJsi0H+OnYntqFpJRKCCKy1hiT5bSv2juE+qxHRlN+Nq5XrJuhlFJ1QkKmrlBKKeVPA4JSSilAA4JSSimbBgSllFKABgSllFI2DQhKKaUADQhKKaVsGhCUUkoBcTxTWUQKgG9CfHsbqsi9FMf0vOJHfTwnqJ/nVd/OqZsxxjFddNwGhNoQkexAU7fjmZ5X/KiP5wT187zq4zkFol1GSimlAA0ISimlbIkaEJ6NdQMiRM8rftTHc4L6eV718ZwcJeQzBKWUUv4S9Q5BKaWUDw0ISimlgAQMCCIySUR2iEiOiMyMdXuciEiuiGwWkQ0ikm2XtRaR90Tka/t3K4/6d9vns0NELvEoP8c+To6IPGWvZ42IpIrIQrt8lYhkRug8FohIvr3UqqssKuchItPsz/haRFxrdkfqnO4Xkb3232uDiFwWZ+fURUQ+FJEvRWSriPzCLo/3v1Wg84rrv1dEGWMS5gdIAnYCPYAUYCMwINbtcmhnLtDGp+xRYKa9PROYZ28PsM8jFehun1+SvW81cD4gWGtYX2qX/xT4s719HbAwQucxBjgb2BLN8wBaA7vs363s7VYRPKf7gd841I2Xc+oAnG1vNwO+stse73+rQOcV13+vSP4k2h3CcCDHGLPLGFMCvAJMiXGbgjUFeMHefgGY6lH+ijGm2BizG8gBhotIB6C5MeZzY/0LfdHnPa5jvQ5McH3jCSdjzArgSAzO4xLgPWPMEWPMUeA9YFIEzymQeDmn/caYdfb2CeBLoBPx/7cKdF6BxMV5RVKiBYROwB6P13lU/Q8kVgzwroisFZHpdlk7Y8x+sP6hA23t8kDn1Mne9i33eo8xpgwoBNIjcB5OonEesfg7zxCRTXaXkqtrJe7Oye7yGAasoh79rXzOC+rJ3yvcEi0gOH0LrovjbkcaY84GLgV+JiJjqqgb6JyqOte6+N8hnOcR7fN7BugJnAXsB/5gl8fVOYlIU+AN4A5jzPGqqgZoS7ycV734e0VCogWEPKCLx+vOwL4YtSUgY8w++3c+8CZWV9dB+9YV+3e+XT3QOeXZ277lXu8RkWSgBcF3g9RWNM4jqn9nY8xBY0y5MaYC+CvW38urfT7tqHPnJCINsS6a/zTGLLKL4/5v5XRe9eHvFTGxfogRzR8gGevhTncqHyoPjHW7fNrYBGjmsf0ZVt/jY3g/4HvU3h6I94OwXVQ+CFsDjKDyQdhldvnP8H4Q9moEzycT7wewET8PrAd5u7Ee5rWyt1tH8Jw6eGz/EqsfOm7OyW7Di8CTPuVx/beq4rzi+u8VyZ+YNyDqJwyXYY022AnMinV7HNrXw/5HuRHY6mojVr/k+8DX9u/WHu+ZZZ/PDuzRD3Z5FrDF3jefypnpacBrWA/NVgM9InQuL2PdkpdifWO6JVrnAdxsl+cAP4rwOb0EbAY2AUt8LjjxcE6jsLozNgEb7J/L6sHfKtB5xfXfK5I/mrpCKaUUkHjPEJRSSgWgAUEppRSgAUEppZRNA4JSSilAA4JSSimbBgSllFKABgSllFK2/wf2RWKGEwGqPQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4.ipynb new file mode 100644 index 0000000..ca18153 --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-4.ipynb @@ -0,0 +1,2445 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0001)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 4, 6, 2, 45, 26, 43, 3, 47, 23, 39, 23, 22, 38, 31, 40, 32, 30, 15,\n", + " 41, 9, 46, 15, 5, 16, 17])\n", + "loss= tensor(1934.0676, grad_fn=) , actor= tensor(449.7137, grad_fn=) , critic= tensor(14843.5381, grad_fn=) , return= 166956.53055921535\n", + "probs of actions: tensor([0.0222, 0.0149, 0.0183, 0.0189, 0.0198, 0.0213, 0.0179, 0.0209, 0.0193,\n", + " 0.0221, 0.0193, 0.0191, 0.0256, 0.0242, 0.0207, 0.0157, 0.0205, 0.0205,\n", + " 0.0191, 0.0217, 0.0213, 0.0201, 0.0193, 0.0204, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "1000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 19, 41, 14, 23, 35, 38, 2, 14, 0, 22, 42, 16, 15, 30, 46, 25, 9,\n", + " 33, 5, 2, 39, 25, 11, 34])\n", + "loss= tensor(1824.7794, grad_fn=) , actor= tensor(429.6995, grad_fn=) , critic= tensor(13950.7998, grad_fn=) , return= 163880.7395040804\n", + "probs of actions: tensor([0.0246, 0.0223, 0.0212, 0.0222, 0.0196, 0.0143, 0.0246, 0.0191, 0.0224,\n", + " 0.0173, 0.0203, 0.0221, 0.0226, 0.0234, 0.0220, 0.0225, 0.0199, 0.0182,\n", + " 0.0238, 0.0201, 0.0195, 0.0190, 0.0202, 0.0152, 0.0286],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "2000 adversary: AdversaryModes.myopic\n", + " actions: tensor([48, 6, 42, 12, 49, 38, 14, 15, 6, 12, 18, 31, 0, 10, 6, 19, 17, 22,\n", + " 27, 38, 39, 21, 45, 6, 5])\n", + "loss= tensor(1848.1609, grad_fn=) , actor= tensor(445.6644, grad_fn=) , critic= tensor(14024.9639, grad_fn=) , return= 164268.36982155184\n", + "probs of actions: tensor([0.0118, 0.0142, 0.0237, 0.0183, 0.0210, 0.0226, 0.0222, 0.0247, 0.0143,\n", + " 0.0188, 0.0159, 0.0226, 0.0171, 0.0194, 0.0144, 0.0203, 0.0200, 0.0221,\n", + " 0.0192, 0.0211, 0.0167, 0.0181, 0.0233, 0.0147, 0.0214],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "3000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 1, 19, 39, 42, 46, 26, 5, 40, 27, 39, 9, 13, 6, 22, 31, 15, 8,\n", + " 33, 21, 25, 14, 43, 23, 27])\n", + "loss= tensor(1881.9005, grad_fn=) , actor= tensor(443.8128, grad_fn=) , critic= tensor(14380.8770, grad_fn=) , return= 165712.64291598083\n", + "probs of actions: tensor([0.0137, 0.0211, 0.0221, 0.0156, 0.0236, 0.0247, 0.0188, 0.0203, 0.0268,\n", + " 0.0211, 0.0158, 0.0176, 0.0131, 0.0139, 0.0236, 0.0204, 0.0255, 0.0202,\n", + " 0.0264, 0.0170, 0.0197, 0.0203, 0.0179, 0.0219, 0.0202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "4000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 3, 30, 20, 21, 10, 47, 43, 44, 36, 49, 34, 31, 7, 32, 26, 38, 34, 7,\n", + " 47, 31, 37, 46, 45, 41, 36])\n", + "loss= tensor(1972.4824, grad_fn=) , actor= tensor(452.7652, grad_fn=) , critic= tensor(15197.1709, grad_fn=) , return= 169661.78501027267\n", + "probs of actions: tensor([0.0185, 0.0274, 0.0214, 0.0158, 0.0190, 0.0219, 0.0188, 0.0161, 0.0172,\n", + " 0.0229, 0.0307, 0.0248, 0.0175, 0.0165, 0.0185, 0.0172, 0.0303, 0.0176,\n", + " 0.0223, 0.0242, 0.0170, 0.0232, 0.0279, 0.0214, 0.0179],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "5000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 38, 24, 28, 33, 21, 2, 39, 33, 34, 25, 15, 28, 3, 15, 17, 22, 14,\n", + " 48, 19, 35, 3, 46, 40, 4])\n", + "loss= tensor(1872.3132, grad_fn=) , actor= tensor(443.6362, grad_fn=) , critic= tensor(14286.7695, grad_fn=) , return= 165526.84154119986\n", + "probs of actions: tensor([0.0193, 0.0178, 0.0179, 0.0146, 0.0294, 0.0151, 0.0192, 0.0121, 0.0299,\n", + " 0.0306, 0.0198, 0.0271, 0.0150, 0.0175, 0.0269, 0.0185, 0.0257, 0.0206,\n", + " 0.0091, 0.0223, 0.0123, 0.0178, 0.0256, 0.0310, 0.0181],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "6000 adversary: AdversaryModes.myopic\n", + " actions: tensor([11, 2, 33, 14, 47, 34, 47, 3, 40, 26, 0, 43, 46, 40, 9, 28, 9, 9,\n", + " 47, 1, 16, 13, 12, 35, 32])\n", + "loss= tensor(1823.4182, grad_fn=) , actor= tensor(426.7574, grad_fn=) , critic= tensor(13966.6074, grad_fn=) , return= 162863.4364112562\n", + "probs of actions: tensor([0.0152, 0.0194, 0.0309, 0.0210, 0.0290, 0.0304, 0.0290, 0.0178, 0.0329,\n", + " 0.0175, 0.0161, 0.0175, 0.0241, 0.0321, 0.0154, 0.0163, 0.0154, 0.0153,\n", + " 0.0294, 0.0211, 0.0197, 0.0112, 0.0262, 0.0119, 0.0212],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "7000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 8, 2, 38, 41, 18, 24, 37, 38, 23, 41, 5, 23, 14, 43, 11, 1, 41,\n", + " 5, 13, 43, 7, 26, 13, 6])\n", + "loss= tensor(1865.3514, grad_fn=) , actor= tensor(441.4802, grad_fn=) , critic= tensor(14238.7119, grad_fn=) , return= 165023.83027266446\n", + "probs of actions: tensor([0.0294, 0.0187, 0.0192, 0.0179, 0.0228, 0.0136, 0.0172, 0.0157, 0.0176,\n", + " 0.0246, 0.0229, 0.0263, 0.0246, 0.0188, 0.0194, 0.0155, 0.0218, 0.0228,\n", + " 0.0261, 0.0111, 0.0195, 0.0187, 0.0193, 0.0113, 0.0136],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "8000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 7, 27, 45, 4, 15, 29, 43, 18, 34, 17, 19, 24, 25, 22, 24, 32, 41,\n", + " 27, 1, 35, 49, 13, 34, 19])\n", + "loss= tensor(1925.4965, grad_fn=) , actor= tensor(454.8486, grad_fn=) , critic= tensor(14706.4775, grad_fn=) , return= 167577.48526414193\n", + "probs of actions: tensor([0.0103, 0.0171, 0.0192, 0.0239, 0.0182, 0.0272, 0.0157, 0.0204, 0.0123,\n", + " 0.0277, 0.0203, 0.0183, 0.0164, 0.0190, 0.0242, 0.0166, 0.0279, 0.0234,\n", + " 0.0179, 0.0220, 0.0101, 0.0226, 0.0113, 0.0269, 0.0189],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "9000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 5, 24, 20, 33, 18, 32, 2, 43, 18, 5, 28, 28, 1, 12, 17, 16, 31,\n", + " 20, 14, 30, 13, 31, 3, 40])\n", + "loss= tensor(1795.0070, grad_fn=) , actor= tensor(431.6086, grad_fn=) , critic= tensor(13633.9824, grad_fn=) , return= 161942.90373772845\n", + "probs of actions: tensor([0.0208, 0.0221, 0.0144, 0.0215, 0.0341, 0.0127, 0.0299, 0.0196, 0.0196,\n", + " 0.0128, 0.0221, 0.0142, 0.0141, 0.0240, 0.0291, 0.0194, 0.0202, 0.0208,\n", + " 0.0213, 0.0153, 0.0190, 0.0110, 0.0207, 0.0183, 0.0349],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 46, 32, 22, 42, 7, 12, 11, 47, 26, 5, 25, 40, 46, 23, 47, 46, 1,\n", + " 49, 8, 0, 33, 2, 10, 14])\n", + "loss= tensor(1878.0314, grad_fn=) , actor= tensor(428.7307, grad_fn=) , critic= tensor(14493.0059, grad_fn=) , return= 166296.12745740308\n", + "probs of actions: tensor([0.0187, 0.0165, 0.0281, 0.0207, 0.0321, 0.0171, 0.0308, 0.0121, 0.0291,\n", + " 0.0235, 0.0233, 0.0196, 0.0518, 0.0167, 0.0272, 0.0294, 0.0169, 0.0200,\n", + " 0.0244, 0.0190, 0.0151, 0.0372, 0.0219, 0.0226, 0.0137],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "11000 adversary: AdversaryModes.myopic\n", + " actions: tensor([11, 9, 1, 36, 38, 41, 40, 49, 0, 32, 15, 10, 33, 37, 47, 22, 14, 31,\n", + " 16, 43, 33, 46, 32, 7, 37])\n", + "loss= tensor(1904.5972, grad_fn=) , actor= tensor(436.8900, grad_fn=) , critic= tensor(14677.0713, grad_fn=) , return= 166824.91116603822\n", + "probs of actions: tensor([0.0113, 0.0147, 0.0194, 0.0145, 0.0214, 0.0252, 0.0499, 0.0241, 0.0149,\n", + " 0.0291, 0.0300, 0.0243, 0.0387, 0.0159, 0.0293, 0.0194, 0.0142, 0.0218,\n", + " 0.0226, 0.0209, 0.0386, 0.0206, 0.0285, 0.0170, 0.0162],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "12000 adversary: AdversaryModes.myopic\n", + " actions: tensor([36, 9, 46, 0, 16, 31, 26, 14, 40, 27, 31, 34, 40, 9, 4, 7, 30, 19,\n", + " 5, 32, 11, 11, 43, 8, 30])\n", + "loss= tensor(1834.4082, grad_fn=) , actor= tensor(430.4747, grad_fn=) , critic= tensor(14039.3350, grad_fn=) , return= 163708.8136166578\n", + "probs of actions: tensor([0.0158, 0.0149, 0.0186, 0.0144, 0.0233, 0.0228, 0.0254, 0.0151, 0.0578,\n", + " 0.0142, 0.0225, 0.0308, 0.0570, 0.0147, 0.0189, 0.0180, 0.0206, 0.0182,\n", + " 0.0236, 0.0290, 0.0109, 0.0109, 0.0190, 0.0207, 0.0203],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "13000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 29, 11, 42, 43, 22, 46, 37, 23, 14, 16, 37, 8, 20, 17, 22, 40, 47,\n", + " 15, 34, 47, 28, 31, 38, 2])\n", + "loss= tensor(1951.2400, grad_fn=) , actor= tensor(448.0898, grad_fn=) , critic= tensor(15031.5020, grad_fn=) , return= 169431.23905832306\n", + "probs of actions: tensor([0.0205, 0.0141, 0.0090, 0.0257, 0.0182, 0.0206, 0.0159, 0.0177, 0.0362,\n", + " 0.0167, 0.0248, 0.0179, 0.0204, 0.0174, 0.0174, 0.0210, 0.0741, 0.0345,\n", + " 0.0324, 0.0371, 0.0346, 0.0117, 0.0201, 0.0223, 0.0166],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "14000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 30, 14, 40, 33, 45, 40, 20, 40, 16, 25, 9, 12, 7, 22, 29, 41, 38,\n", + " 49, 47, 35, 46, 4, 16, 10])\n", + "loss= tensor(1949.6801, grad_fn=) , actor= tensor(432.3452, grad_fn=) , critic= tensor(15173.3486, grad_fn=) , return= 170616.16500920325\n", + "probs of actions: tensor([0.0157, 0.0229, 0.0178, 0.0716, 0.0254, 0.0201, 0.0722, 0.0153, 0.0722,\n", + " 0.0255, 0.0183, 0.0149, 0.0285, 0.0174, 0.0228, 0.0159, 0.0234, 0.0223,\n", + " 0.0300, 0.0431, 0.0070, 0.0171, 0.0173, 0.0253, 0.0220],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "15000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 5, 23, 45, 40, 40, 45, 49, 40, 9, 1, 18, 3, 3, 47, 40, 34, 27, 5,\n", + " 42, 9, 44, 12, 32, 11, 48])\n", + "loss= tensor(1825.0857, grad_fn=) , actor= tensor(409.3825, grad_fn=) , critic= tensor(14157.0312, grad_fn=) , return= 164185.47198932868\n", + "probs of actions: tensor([0.0232, 0.0421, 0.0208, 0.0666, 0.0668, 0.0208, 0.0315, 0.0669, 0.0165,\n", + " 0.0176, 0.0061, 0.0118, 0.0119, 0.0408, 0.0651, 0.0365, 0.0133, 0.0236,\n", + " 0.0275, 0.0166, 0.0137, 0.0275, 0.0262, 0.0073, 0.0043],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "16000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 4, 23, 23, 15, 15, 6, 34, 47, 5, 34, 40, 5, 46, 1, 17, 47, 16, 29,\n", + " 16, 0, 32, 15, 27, 26, 10])\n", + "loss= tensor(1804.6067, grad_fn=) , actor= tensor(412.3293, grad_fn=) , critic= tensor(13922.7744, grad_fn=) , return= 163462.37097280342\n", + "probs of actions: tensor([0.0126, 0.0406, 0.0408, 0.0284, 0.0285, 0.0049, 0.0490, 0.0490, 0.0247,\n", + " 0.0490, 0.0661, 0.0246, 0.0174, 0.0154, 0.0159, 0.0498, 0.0183, 0.0175,\n", + " 0.0184, 0.0086, 0.0226, 0.0271, 0.0120, 0.0284, 0.0261],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "17000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 9, 33, 12, 10, 40, 9, 33, 27, 47, 17, 34, 21, 32, 12, 33, 38, 34, 29,\n", + " 21, 15, 5, 49, 33, 41, 47])\n", + "loss= tensor(1850.6973, grad_fn=) , actor= tensor(405.6036, grad_fn=) , critic= tensor(14450.9365, grad_fn=) , return= 165686.45954345565\n", + "probs of actions: tensor([0.0222, 0.0276, 0.0338, 0.0271, 0.0618, 0.0225, 0.0279, 0.0144, 0.0486,\n", + " 0.0163, 0.0440, 0.0212, 0.0199, 0.0339, 0.0283, 0.0307, 0.0434, 0.0146,\n", + " 0.0219, 0.0313, 0.0213, 0.0254, 0.0285, 0.0250, 0.0490],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "18000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 26, 41, 38, 48, 15, 33, 49, 3, 32, 30, 19, 5, 20, 40, 32, 33, 35,\n", + " 49, 23, 23, 12, 15, 14, 10])\n", + "loss= tensor(1984.0735, grad_fn=) , actor= tensor(458.5512, grad_fn=) , critic= tensor(15255.2217, grad_fn=) , return= 170484.28355169322\n", + "probs of actions: tensor([0.0151, 0.0284, 0.0213, 0.0317, 0.0035, 0.0317, 0.0273, 0.0223, 0.0093,\n", + " 0.0202, 0.0142, 0.0142, 0.0222, 0.0115, 0.0540, 0.0201, 0.0277, 0.0052,\n", + " 0.0227, 0.0436, 0.0438, 0.0438, 0.0306, 0.0177, 0.0309],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "19000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 36, 40, 23, 43, 10, 17, 5, 12, 22, 12, 19, 33, 23, 38, 12, 25, 49,\n", + " 8, 2, 1, 40, 38, 45, 43])\n", + "loss= tensor(1779.5568, grad_fn=) , actor= tensor(400.8188, grad_fn=) , critic= tensor(13787.3789, grad_fn=) , return= 163054.3484651628\n", + "probs of actions: tensor([0.0570, 0.0102, 0.0509, 0.0413, 0.0211, 0.0270, 0.0135, 0.0242, 0.0496,\n", + " 0.0190, 0.0493, 0.0123, 0.0257, 0.0424, 0.0294, 0.0488, 0.0136, 0.0245,\n", + " 0.0146, 0.0117, 0.0146, 0.0495, 0.0292, 0.0250, 0.0211],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 12, 41, 46, 14, 31, 40, 31, 40, 30, 34, 43, 23, 9, 34, 33, 27, 22,\n", + " 14, 7, 10, 27, 38, 38, 40])\n", + "loss= tensor(1910.5619, grad_fn=) , actor= tensor(404.5587, grad_fn=) , critic= tensor(15060.0312, grad_fn=) , return= 168666.25417203968\n", + "probs of actions: tensor([0.0316, 0.0529, 0.0219, 0.0200, 0.0195, 0.0383, 0.0522, 0.0382, 0.0522,\n", + " 0.0153, 0.0560, 0.0206, 0.0415, 0.0223, 0.0555, 0.0261, 0.0159, 0.0189,\n", + " 0.0190, 0.0204, 0.0294, 0.0157, 0.0286, 0.0286, 0.0494],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "21000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 31, 38, 45, 40, 30, 13, 10, 28, 30, 22, 34, 12, 34, 17, 35, 40, 14,\n", + " 34, 47, 4, 26, 34, 38, 47])\n", + "loss= tensor(1912.7351, grad_fn=) , actor= tensor(424.3539, grad_fn=) , critic= tensor(14883.8105, grad_fn=) , return= 168409.66633387658\n", + "probs of actions: tensor([0.0228, 0.0345, 0.0274, 0.0289, 0.0611, 0.0160, 0.0055, 0.0261, 0.0081,\n", + " 0.0157, 0.0156, 0.0582, 0.0615, 0.0580, 0.0124, 0.0062, 0.0595, 0.0186,\n", + " 0.0573, 0.0517, 0.0164, 0.0232, 0.0564, 0.0262, 0.0516],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "22000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 46, 34, 47, 22, 7, 32, 43, 34, 5, 43, 32, 31, 29, 31, 29, 23, 34,\n", + " 23, 30, 5, 32, 27, 44, 33])\n", + "loss= tensor(1954.1024, grad_fn=) , actor= tensor(425.2961, grad_fn=) , critic= tensor(15288.0635, grad_fn=) , return= 170152.6350041157\n", + "probs of actions: tensor([0.0233, 0.0186, 0.0592, 0.0468, 0.0165, 0.0199, 0.0177, 0.0229, 0.0601,\n", + " 0.0203, 0.0225, 0.0176, 0.0341, 0.0131, 0.0338, 0.0132, 0.0482, 0.0590,\n", + " 0.0480, 0.0166, 0.0205, 0.0178, 0.0162, 0.0078, 0.0358],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "23000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 23, 7, 40, 40, 12, 42, 43, 26, 15, 15, 34, 12, 27, 45, 7, 23, 15,\n", + " 21, 12, 34, 48, 38, 12, 26])\n", + "loss= tensor(1832.5764, grad_fn=) , actor= tensor(382.9427, grad_fn=) , critic= tensor(14496.3359, grad_fn=) , return= 166122.25052608163\n", + "probs of actions: tensor([0.0169, 0.0425, 0.0223, 0.0693, 0.0698, 0.0642, 0.0244, 0.0307, 0.0233,\n", + " 0.0390, 0.0390, 0.0516, 0.0647, 0.0185, 0.0377, 0.0218, 0.0435, 0.0381,\n", + " 0.0174, 0.0641, 0.0505, 0.0035, 0.0183, 0.0634, 0.0236],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "24000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 14, 23, 45, 12, 47, 33, 35, 45, 21, 43, 4, 34, 34, 38, 22, 43, 47,\n", + " 2, 30, 23, 23, 42, 40, 19])\n", + "loss= tensor(1941.1002, grad_fn=) , actor= tensor(411.2881, grad_fn=) , critic= tensor(15298.1211, grad_fn=) , return= 170392.35371716938\n", + "probs of actions: tensor([0.0271, 0.0180, 0.0488, 0.0418, 0.0598, 0.0474, 0.0315, 0.0061, 0.0424,\n", + " 0.0153, 0.0333, 0.0175, 0.0644, 0.0641, 0.0230, 0.0156, 0.0331, 0.0481,\n", + " 0.0138, 0.0141, 0.0498, 0.0498, 0.0262, 0.0639, 0.0098],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "25000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 33, 43, 19, 12, 35, 33, 16, 15, 23, 43, 42, 38, 40, 38, 4, 38, 31,\n", + " 34, 43, 33, 44, 40, 23, 37])\n", + "loss= tensor(1978.7489, grad_fn=) , actor= tensor(430.5833, grad_fn=) , critic= tensor(15481.6562, grad_fn=) , return= 171523.86665746494\n", + "probs of actions: tensor([0.0169, 0.0315, 0.0267, 0.0081, 0.0493, 0.0063, 0.0318, 0.0131, 0.0330,\n", + " 0.0517, 0.0265, 0.0283, 0.0244, 0.0920, 0.0243, 0.0136, 0.0240, 0.0392,\n", + " 0.0685, 0.0266, 0.0323, 0.0076, 0.0867, 0.0511, 0.0189],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "26000 adversary: AdversaryModes.myopic\n", + " actions: tensor([10, 37, 2, 31, 34, 3, 45, 7, 37, 40, 34, 27, 11, 2, 21, 9, 23, 33,\n", + " 26, 20, 49, 13, 30, 32, 34])\n", + "loss= tensor(1850.4479, grad_fn=) , actor= tensor(434.2155, grad_fn=) , critic= tensor(14162.3223, grad_fn=) , return= 164493.95772424008\n", + "probs of actions: tensor([0.0196, 0.0176, 0.0105, 0.0449, 0.0690, 0.0069, 0.0307, 0.0218, 0.0178,\n", + " 0.0738, 0.0695, 0.0153, 0.0058, 0.0106, 0.0170, 0.0250, 0.0478, 0.0325,\n", + " 0.0213, 0.0058, 0.0167, 0.0052, 0.0142, 0.0133, 0.0666],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "27000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 24, 22, 45, 7, 5, 23, 40, 15, 26, 45, 32, 40, 9, 31, 15, 8, 12,\n", + " 45, 44, 34, 27, 43, 0, 8])\n", + "loss= tensor(1891.5154, grad_fn=) , actor= tensor(416.3406, grad_fn=) , critic= tensor(14751.7480, grad_fn=) , return= 168126.3379276226\n", + "probs of actions: tensor([0.0782, 0.0076, 0.0134, 0.0265, 0.0220, 0.0201, 0.0511, 0.0801, 0.0322,\n", + " 0.0177, 0.0266, 0.0131, 0.0787, 0.0219, 0.0372, 0.0316, 0.0178, 0.0618,\n", + " 0.0268, 0.0095, 0.0565, 0.0148, 0.0343, 0.0043, 0.0179],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "28000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 9, 14, 37, 10, 4, 12, 26, 40, 23, 31, 47, 45, 2, 47, 46, 41, 21,\n", + " 23, 8, 38, 40, 23, 30, 47])\n", + "loss= tensor(1852.0168, grad_fn=) , actor= tensor(406.4398, grad_fn=) , critic= tensor(14455.7695, grad_fn=) , return= 165905.5261654769\n", + "probs of actions: tensor([0.0338, 0.0196, 0.0134, 0.0179, 0.0169, 0.0084, 0.0635, 0.0180, 0.0853,\n", + " 0.0616, 0.0368, 0.0594, 0.0283, 0.0113, 0.0594, 0.0138, 0.0287, 0.0146,\n", + " 0.0618, 0.0209, 0.0254, 0.0782, 0.0609, 0.0147, 0.0585],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "29000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 45, 26, 32, 31, 12, 40, 25, 38, 42, 1, 40, 32, 40, 27, 33, 32, 37,\n", + " 17, 10, 26, 46, 49, 45, 42])\n", + "loss= tensor(1941.8411, grad_fn=) , actor= tensor(425.8026, grad_fn=) , critic= tensor(15160.3838, grad_fn=) , return= 169737.0666486782\n", + "probs of actions: tensor([0.0067, 0.0291, 0.0172, 0.0144, 0.0406, 0.0681, 0.1030, 0.0131, 0.0238,\n", + " 0.0247, 0.0179, 0.1011, 0.0145, 0.1002, 0.0217, 0.0351, 0.0147, 0.0194,\n", + " 0.0108, 0.0203, 0.0170, 0.0144, 0.0130, 0.0288, 0.0245],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 1, 49, 40, 23, 26, 5, 16, 33, 30, 34, 1, 40, 30, 12, 38, 5, 24,\n", + " 40, 22, 12, 43, 7, 25, 47])\n", + "loss= tensor(1837.3821, grad_fn=) , actor= tensor(416.6577, grad_fn=) , critic= tensor(14207.2432, grad_fn=) , return= 164343.2286534562\n", + "probs of actions: tensor([0.0035, 0.0178, 0.0092, 0.1357, 0.0713, 0.0171, 0.0185, 0.0088, 0.0344,\n", + " 0.0107, 0.0543, 0.0177, 0.1330, 0.0107, 0.0631, 0.0266, 0.0191, 0.0062,\n", + " 0.1262, 0.0135, 0.0627, 0.0322, 0.0210, 0.0135, 0.0600],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "31000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 16, 47, 37, 24, 17, 14, 15, 9, 3, 12, 38, 23, 42, 27, 10, 15, 3,\n", + " 40, 13, 12, 43, 40, 32, 47])\n", + "loss= tensor(1809.8481, grad_fn=) , actor= tensor(429.6126, grad_fn=) , critic= tensor(13802.3555, grad_fn=) , return= 162979.0427944121\n", + "probs of actions: tensor([0.0337, 0.0070, 0.0698, 0.0144, 0.0051, 0.0095, 0.0123, 0.0217, 0.0217,\n", + " 0.0067, 0.0580, 0.0278, 0.0679, 0.0186, 0.0238, 0.0262, 0.0213, 0.0071,\n", + " 0.1137, 0.0046, 0.0569, 0.0409, 0.1099, 0.0113, 0.0707],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "32000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 7, 42, 26, 9, 14, 38, 40, 35, 5, 47, 23, 17, 40, 17, 23, 12, 1,\n", + " 28, 12, 40, 9, 31, 31, 40])\n", + "loss= tensor(1810.2644, grad_fn=) , actor= tensor(397.7045, grad_fn=) , critic= tensor(14125.5986, grad_fn=) , return= 164266.18039263558\n", + "probs of actions: tensor([0.0639, 0.0230, 0.0178, 0.0179, 0.0226, 0.0141, 0.0274, 0.1680, 0.0049,\n", + " 0.0193, 0.0781, 0.0677, 0.0073, 0.1637, 0.0074, 0.0684, 0.0406, 0.0216,\n", + " 0.0034, 0.0405, 0.1535, 0.0227, 0.0344, 0.0344, 0.1486],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "33000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 8, 40, 23, 2, 40, 27, 8, 40, 40, 38, 31, 36, 33, 47, 40, 41, 43,\n", + " 38, 47, 30, 27, 41, 45, 31])\n", + "loss= tensor(1942.7634, grad_fn=) , actor= tensor(382.7814, grad_fn=) , critic= tensor(15599.8203, grad_fn=) , return= 171807.71165710632\n", + "probs of actions: tensor([0.0398, 0.0120, 0.2224, 0.0771, 0.0047, 0.2258, 0.0165, 0.0115, 0.2256,\n", + " 0.2243, 0.0222, 0.0385, 0.0066, 0.0281, 0.0922, 0.2150, 0.0234, 0.0344,\n", + " 0.0222, 0.0918, 0.0097, 0.0164, 0.0235, 0.0298, 0.0378],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "34000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 41, 16, 31, 42, 23, 12, 15, 43, 40, 42, 7, 40, 47, 34, 1, 40, 47,\n", + " 40, 45, 31, 40, 49, 47, 21])\n", + "loss= tensor(1899.3230, grad_fn=) , actor= tensor(364.4943, grad_fn=) , critic= tensor(15348.2871, grad_fn=) , return= 171174.61292724346\n", + "probs of actions: tensor([0.0884, 0.0324, 0.0044, 0.0428, 0.0224, 0.0714, 0.0350, 0.0156, 0.0285,\n", + " 0.2603, 0.0221, 0.0174, 0.2572, 0.0927, 0.0400, 0.0158, 0.2488, 0.0925,\n", + " 0.2424, 0.0338, 0.0416, 0.2376, 0.0083, 0.0919, 0.0204],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "35000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 45, 45, 31, 38, 38, 40, 40, 41, 40, 40, 40, 40, 47, 21, 40, 15, 1,\n", + " 40, 40, 37, 27, 26, 1, 40])\n", + "loss= tensor(1906.9243, grad_fn=) , actor= tensor(312.2659, grad_fn=) , critic= tensor(15946.5830, grad_fn=) , return= 173154.96749020036\n", + "probs of actions: tensor([0.0459, 0.0303, 0.0301, 0.0377, 0.0159, 0.0158, 0.3803, 0.3808, 0.0336,\n", + " 0.3799, 0.3787, 0.3769, 0.3748, 0.0966, 0.0162, 0.3677, 0.0091, 0.0144,\n", + " 0.3555, 0.3486, 0.0081, 0.0154, 0.0158, 0.0151, 0.3366],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "36000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 40, 40, 26, 33, 4, 12, 45, 40, 43, 40, 43, 45, 40, 45, 46, 47,\n", + " 34, 40, 45, 23, 38, 33, 41])\n", + "loss= tensor(1940.4596, grad_fn=) , actor= tensor(329.1897, grad_fn=) , critic= tensor(16112.6992, grad_fn=) , return= 174242.14052957445\n", + "probs of actions: tensor([0.3594, 0.0779, 0.3699, 0.3752, 0.0162, 0.0290, 0.0022, 0.0293, 0.0435,\n", + " 0.3813, 0.0323, 0.3797, 0.0323, 0.0437, 0.3731, 0.0438, 0.0068, 0.0816,\n", + " 0.0452, 0.3589, 0.0442, 0.0456, 0.0144, 0.0317, 0.0309],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "37000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 40, 47, 40, 43, 34, 21, 40, 47, 43, 22, 40, 40, 36, 47, 34, 47, 21,\n", + " 26, 27, 37, 3, 27, 40, 40])\n", + "loss= tensor(1950.2042, grad_fn=) , actor= tensor(338.7780, grad_fn=) , critic= tensor(16114.2617, grad_fn=) , return= 173621.9703902889\n", + "probs of actions: tensor([0.0974, 0.3161, 0.0987, 0.3241, 0.0411, 0.0424, 0.0174, 0.3316, 0.1018,\n", + " 0.0409, 0.0055, 0.3282, 0.3253, 0.0036, 0.1029, 0.0429, 0.1031, 0.0189,\n", + " 0.0154, 0.0201, 0.0083, 0.0032, 0.0203, 0.2936, 0.2913],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "38000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 40, 40, 27, 43, 40, 12, 34, 40, 34, 40, 45, 5, 47, 40, 26, 40, 45,\n", + " 27, 46, 40, 47, 40, 47, 23])\n", + "loss= tensor(1903.6860, grad_fn=) , actor= tensor(308.3848, grad_fn=) , critic= tensor(15953.0127, grad_fn=) , return= 174210.27376657238\n", + "probs of actions: tensor([0.0357, 0.2630, 0.2657, 0.0245, 0.0462, 0.2714, 0.0219, 0.0524, 0.2722,\n", + " 0.0524, 0.2704, 0.0591, 0.0099, 0.1049, 0.2614, 0.0177, 0.2590, 0.0589,\n", + " 0.0239, 0.0109, 0.2479, 0.1039, 0.2440, 0.1037, 0.0316],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "39000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 40, 40, 45, 41, 47, 45, 40, 30, 10, 21, 40, 40, 45, 41, 43, 43, 47,\n", + " 3, 28, 47, 40, 23, 4, 40])\n", + "loss= tensor(1950.4392, grad_fn=) , actor= tensor(352.0874, grad_fn=) , critic= tensor(15983.5176, grad_fn=) , return= 173537.06367083805\n", + "probs of actions: tensor([0.0070, 0.3138, 0.3174, 0.0649, 0.0375, 0.0956, 0.0651, 0.3256, 0.0050,\n", + " 0.0148, 0.0172, 0.3212, 0.3183, 0.0654, 0.0377, 0.0436, 0.0437, 0.0974,\n", + " 0.0020, 0.0024, 0.0976, 0.2916, 0.0315, 0.0028, 0.2852],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 41, 43, 47, 34, 40, 34, 40, 38, 43, 40, 14, 27, 41, 21, 47, 40, 47,\n", + " 26, 14, 40, 45, 42, 40, 40])\n", + "loss= tensor(1938.1335, grad_fn=) , actor= tensor(327.5223, grad_fn=) , critic= tensor(16106.1123, grad_fn=) , return= 174154.0815492963\n", + "probs of actions: tensor([0.1075, 0.0394, 0.0539, 0.1100, 0.0622, 0.2445, 0.0625, 0.2444, 0.0167,\n", + " 0.0539, 0.2411, 0.0127, 0.0204, 0.0395, 0.0272, 0.1126, 0.2278, 0.1121,\n", + " 0.0179, 0.0130, 0.2197, 0.0486, 0.0390, 0.2132, 0.2114],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "41000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 36, 27, 40, 40, 40, 33, 40, 40, 2, 41, 30, 34, 40, 10, 38, 26, 12,\n", + " 40, 40, 26, 46, 40, 45, 34])\n", + "loss= tensor(1899.1803, grad_fn=) , actor= tensor(346.5873, grad_fn=) , critic= tensor(15525.9297, grad_fn=) , return= 171922.08809270166\n", + "probs of actions: tensor([0.2581, 0.0044, 0.0231, 0.2682, 0.2693, 0.2704, 0.0288, 0.2712, 0.2704,\n", + " 0.0042, 0.0332, 0.0052, 0.0502, 0.2624, 0.0142, 0.0137, 0.0178, 0.0182,\n", + " 0.2497, 0.2455, 0.0180, 0.0114, 0.2393, 0.0491, 0.0505],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "42000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 32, 43, 3, 25, 40, 32, 41, 45, 42, 38, 40, 23, 38, 21, 40, 40, 41,\n", + " 45, 21, 42, 40, 11, 40, 40])\n", + "loss= tensor(1990.8116, grad_fn=) , actor= tensor(405.9772, grad_fn=) , critic= tensor(15848.3447, grad_fn=) , return= 172826.86316042294\n", + "probs of actions: tensor([0.0458, 0.0094, 0.0414, 0.0028, 0.0064, 0.2702, 0.0091, 0.0262, 0.0484,\n", + " 0.0272, 0.0146, 0.2665, 0.0296, 0.0145, 0.0299, 0.2582, 0.2546, 0.0263,\n", + " 0.0485, 0.0307, 0.0276, 0.2427, 0.0031, 0.2395, 0.2349],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "43000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 2, 15, 33, 15, 9, 43, 34, 47, 8, 40, 29, 41, 47, 27, 43, 43, 33,\n", + " 21, 40, 43, 31, 30, 47, 26])\n", + "loss= tensor(1934.7596, grad_fn=) , actor= tensor(398.5946, grad_fn=) , critic= tensor(15361.6504, grad_fn=) , return= 170501.07910383225\n", + "probs of actions: tensor([0.0544, 0.0051, 0.0120, 0.0352, 0.0117, 0.0191, 0.0518, 0.0551, 0.1433,\n", + " 0.0156, 0.1661, 0.0102, 0.0251, 0.1432, 0.0232, 0.0520, 0.0523, 0.0361,\n", + " 0.0333, 0.1565, 0.0520, 0.0250, 0.0060, 0.1392, 0.0197],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "44000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 47, 40, 7, 27, 44, 47, 9, 34, 23, 47, 41, 45, 42, 40, 46, 9,\n", + " 8, 27, 45, 34, 26, 28, 21])\n", + "loss= tensor(1958.9130, grad_fn=) , actor= tensor(385.0005, grad_fn=) , critic= tensor(15739.1250, grad_fn=) , return= 172462.66492684738\n", + "probs of actions: tensor([0.0256, 0.1684, 0.1276, 0.1715, 0.0093, 0.0281, 0.0051, 0.1321, 0.0162,\n", + " 0.0408, 0.0323, 0.1337, 0.0250, 0.0728, 0.0324, 0.1681, 0.0106, 0.0161,\n", + " 0.0155, 0.0275, 0.0714, 0.0410, 0.0228, 0.0053, 0.0319],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "45000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 40, 47, 23, 47, 45, 45, 33, 5, 42, 47, 46, 25, 42, 42, 47, 21, 40,\n", + " 15, 31, 21, 13, 34, 10, 47])\n", + "loss= tensor(1942.5558, grad_fn=) , actor= tensor(369.1435, grad_fn=) , critic= tensor(15734.1230, grad_fn=) , return= 171770.52927745812\n", + "probs of actions: tensor([0.0367, 0.1775, 0.1327, 0.0306, 0.1355, 0.0564, 0.0565, 0.0387, 0.0102,\n", + " 0.0400, 0.1382, 0.0102, 0.0097, 0.0396, 0.0394, 0.1376, 0.0290, 0.1733,\n", + " 0.0118, 0.0355, 0.0296, 0.0036, 0.0484, 0.0159, 0.1342],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "46000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 16, 26, 49, 23, 31, 0, 30, 43, 5, 42, 17, 40, 26, 41, 47, 41, 40,\n", + " 42, 41, 40, 43, 25, 45, 47])\n", + "loss= tensor(1953.8489, grad_fn=) , actor= tensor(434.0124, grad_fn=) , critic= tensor(15198.3652, grad_fn=) , return= 169956.35907053328\n", + "probs of actions: tensor([0.0664, 0.0059, 0.0231, 0.0046, 0.0360, 0.0355, 0.0022, 0.0058, 0.0473,\n", + " 0.0084, 0.0670, 0.0028, 0.1884, 0.0227, 0.0274, 0.1004, 0.0274, 0.1820,\n", + " 0.0652, 0.0274, 0.1773, 0.0474, 0.0118, 0.0489, 0.0990],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "47000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 38, 40, 47, 42, 42, 47, 23, 40, 23, 41, 43, 33, 29, 43, 40, 47, 33,\n", + " 31, 40, 47, 31, 43, 25, 9])\n", + "loss= tensor(2022.1404, grad_fn=) , actor= tensor(347.9472, grad_fn=) , critic= tensor(16741.9316, grad_fn=) , return= 177577.44162311134\n", + "probs of actions: tensor([0.1659, 0.0163, 0.1702, 0.1141, 0.0511, 0.0512, 0.1166, 0.0397, 0.1727,\n", + " 0.0398, 0.0285, 0.0441, 0.0342, 0.0145, 0.0439, 0.1654, 0.1182, 0.0345,\n", + " 0.0311, 0.1602, 0.1172, 0.0312, 0.0440, 0.0121, 0.0124],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "48000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 42, 47, 29, 10, 27, 23, 47, 46, 47, 46, 40, 40, 26, 23, 10, 43, 40,\n", + " 12, 3, 40, 47, 42, 45, 42])\n", + "loss= tensor(1895.0851, grad_fn=) , actor= tensor(372.1323, grad_fn=) , critic= tensor(15229.5273, grad_fn=) , return= 169782.09082993094\n", + "probs of actions: tensor([0.0332, 0.0514, 0.1662, 0.0133, 0.0083, 0.0293, 0.0435, 0.1740, 0.0117,\n", + " 0.1740, 0.0116, 0.1651, 0.1643, 0.0196, 0.0438, 0.0085, 0.0431, 0.1571,\n", + " 0.0139, 0.0030, 0.1535, 0.1687, 0.0493, 0.0403, 0.0492],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "49000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 42, 40, 40, 10, 23, 41, 42, 42, 47, 41, 40, 34, 11, 40, 40, 40, 40,\n", + " 43, 34, 40, 34, 33, 12, 47])\n", + "loss= tensor(1949.2179, grad_fn=) , actor= tensor(336.9052, grad_fn=) , critic= tensor(16123.1270, grad_fn=) , return= 174024.07765591634\n", + "probs of actions: tensor([0.0574, 0.0568, 0.1534, 0.1547, 0.0082, 0.0378, 0.0378, 0.0567, 0.0566,\n", + " 0.1630, 0.0376, 0.1561, 0.0757, 0.0015, 0.1535, 0.1525, 0.1519, 0.1510,\n", + " 0.0367, 0.0752, 0.1482, 0.0750, 0.0335, 0.0109, 0.1593],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 40, 33, 43, 10, 23, 42, 21, 40, 47, 40, 40, 40, 40, 34, 40, 40, 47,\n", + " 40, 31, 31, 43, 10, 43, 47])\n", + "loss= tensor(1897.4397, grad_fn=) , actor= tensor(295.2003, grad_fn=) , critic= tensor(16022.3936, grad_fn=) , return= 173390.75777404525\n", + "probs of actions: tensor([0.1487, 0.2400, 0.0275, 0.0313, 0.0056, 0.0333, 0.0745, 0.0337, 0.2538,\n", + " 0.1599, 0.2534, 0.2531, 0.2524, 0.2514, 0.0655, 0.2491, 0.2475, 0.1606,\n", + " 0.2446, 0.0172, 0.0172, 0.0313, 0.0059, 0.0312, 0.1584],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "51000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 38, 12, 40, 45, 34, 41, 43, 21, 38, 40, 40, 40, 17, 47, 23, 47, 24,\n", + " 23, 41, 47, 27, 47, 34, 34])\n", + "loss= tensor(1972.7800, grad_fn=) , actor= tensor(373.8938, grad_fn=) , critic= tensor(15988.8623, grad_fn=) , return= 173792.00390315338\n", + "probs of actions: tensor([0.2701, 0.0080, 0.0063, 0.2819, 0.0392, 0.0476, 0.0277, 0.0294, 0.0305,\n", + " 0.0069, 0.2894, 0.2887, 0.2879, 0.0007, 0.2249, 0.0289, 0.2241, 0.0050,\n", + " 0.0292, 0.0278, 0.2214, 0.0268, 0.2213, 0.0489, 0.0490],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "52000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 34, 43, 21, 40, 47, 47, 27, 10, 40, 22, 21, 27, 40, 12, 47, 34,\n", + " 27, 47, 45, 40, 47, 42, 40])\n", + "loss= tensor(1882.0869, grad_fn=) , actor= tensor(323.2399, grad_fn=) , critic= tensor(15588.4697, grad_fn=) , return= 172209.99797255316\n", + "probs of actions: tensor([0.0263, 0.2768, 0.0396, 0.0307, 0.0289, 0.2890, 0.2117, 0.2125, 0.0341,\n", + " 0.0060, 0.2920, 0.0246, 0.0293, 0.0337, 0.2882, 0.0057, 0.2160, 0.0399,\n", + " 0.0338, 0.2143, 0.0444, 0.2775, 0.2126, 0.0640, 0.2729],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "53000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 21, 40, 40, 45, 47, 47, 47, 42, 42, 23, 45, 47, 7, 40, 40, 23, 40,\n", + " 38, 45, 35, 47, 9, 40, 47])\n", + "loss= tensor(1913.4150, grad_fn=) , actor= tensor(310.8380, grad_fn=) , critic= tensor(16025.7695, grad_fn=) , return= 173432.20510563417\n", + "probs of actions: tensor([0.0716, 0.0251, 0.3529, 0.3568, 0.0345, 0.1982, 0.1992, 0.2001, 0.0688,\n", + " 0.0687, 0.0319, 0.0338, 0.2026, 0.0022, 0.3631, 0.3606, 0.0325, 0.3578,\n", + " 0.0060, 0.0346, 0.0031, 0.2019, 0.0029, 0.3454, 0.2005],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "54000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 22, 26, 45, 45, 16, 40, 47, 40, 22, 40, 40, 25, 42, 47, 40, 40, 40,\n", + " 40, 27, 34, 41, 42, 40, 39])\n", + "loss= tensor(1929.1096, grad_fn=) , actor= tensor(315.3784, grad_fn=) , critic= tensor(16137.3125, grad_fn=) , return= 174516.30504297005\n", + "probs of actions: tensor([0.0297, 0.0292, 0.0214, 0.0426, 0.0425, 0.0023, 0.3461, 0.1641, 0.3483,\n", + " 0.0284, 0.3489, 0.3479, 0.0078, 0.0773, 0.1658, 0.3425, 0.3414, 0.3395,\n", + " 0.3373, 0.0341, 0.0447, 0.0153, 0.0759, 0.3257, 0.0009],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "55000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 26, 40, 10, 40, 47, 27, 40, 33, 47, 40, 40, 40, 10, 12, 26, 42, 40,\n", + " 47, 40, 47, 40, 26, 40, 23])\n", + "loss= tensor(1894.4506, grad_fn=) , actor= tensor(298.3205, grad_fn=) , critic= tensor(15961.3008, grad_fn=) , return= 173901.51550909627\n", + "probs of actions: tensor([0.0205, 0.0423, 0.2471, 0.0104, 0.2509, 0.1631, 0.0387, 0.2548, 0.0367,\n", + " 0.1664, 0.2540, 0.2536, 0.2526, 0.0102, 0.0043, 0.0403, 0.0865, 0.2437,\n", + " 0.1656, 0.2412, 0.1651, 0.2381, 0.0407, 0.2350, 0.0422],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "56000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 40, 47, 45, 42, 40, 36, 45, 26, 37, 29, 45, 10, 47, 14, 34, 26, 33,\n", + " 22, 47, 47, 23, 47, 21, 47])\n", + "loss= tensor(1952.9753, grad_fn=) , actor= tensor(376.9277, grad_fn=) , critic= tensor(15760.4756, grad_fn=) , return= 172558.93871528696\n", + "probs of actions: tensor([0.0409, 0.2515, 0.1690, 0.0340, 0.1111, 0.2606, 0.0044, 0.0336, 0.0384,\n", + " 0.0023, 0.0127, 0.0336, 0.0072, 0.1783, 0.0153, 0.0417, 0.0381, 0.0297,\n", + " 0.0316, 0.1765, 0.1753, 0.0368, 0.1755, 0.0235, 0.1746],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "57000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 40, 33, 40, 42, 40, 47, 23, 47, 34, 42, 23, 47, 26, 27, 40, 43, 40,\n", + " 47, 34, 40, 43, 26, 34, 34])\n", + "loss= tensor(1950.5826, grad_fn=) , actor= tensor(303.2906, grad_fn=) , critic= tensor(16472.9199, grad_fn=) , return= 176152.7298561289\n", + "probs of actions: tensor([0.0242, 0.2055, 0.0363, 0.2099, 0.1351, 0.2127, 0.1267, 0.0305, 0.1280,\n", + " 0.0549, 0.1357, 0.0308, 0.1288, 0.0408, 0.0514, 0.2084, 0.0238, 0.2061,\n", + " 0.1278, 0.0559, 0.2023, 0.0242, 0.0408, 0.0563, 0.0563],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "58000 adversary: AdversaryModes.myopic\n", + " actions: tensor([19, 21, 41, 27, 27, 22, 1, 26, 40, 34, 40, 40, 40, 34, 42, 27, 40, 40,\n", + " 40, 12, 14, 14, 10, 27, 27])\n", + "loss= tensor(1883.1145, grad_fn=) , actor= tensor(342.8173, grad_fn=) , critic= tensor(15402.9717, grad_fn=) , return= 170704.38847908634\n", + "probs of actions: tensor([0.0040, 0.0262, 0.0264, 0.0583, 0.0584, 0.0288, 0.0060, 0.0439, 0.2187,\n", + " 0.0713, 0.2183, 0.2178, 0.2171, 0.0717, 0.1039, 0.0574, 0.2128, 0.2113,\n", + " 0.2101, 0.0067, 0.0196, 0.0197, 0.0083, 0.0568, 0.0566],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "59000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 43, 41, 31, 30, 45, 40, 47, 35, 42, 40, 45, 27, 32, 42, 40, 37, 33,\n", + " 33, 29, 37, 45, 23, 42, 29])\n", + "loss= tensor(2065.2161, grad_fn=) , actor= tensor(405.2301, grad_fn=) , critic= tensor(16599.8594, grad_fn=) , return= 176582.5452396331\n", + "probs of actions: tensor([0.1654, 0.0212, 0.0226, 0.0210, 0.0059, 0.0372, 0.1757, 0.1224, 0.0067,\n", + " 0.1032, 0.1762, 0.0373, 0.0482, 0.0087, 0.1013, 0.1727, 0.0026, 0.0413,\n", + " 0.0414, 0.0185, 0.0027, 0.0377, 0.0395, 0.0977, 0.0189],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "60000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 43, 27, 10, 14, 42, 23, 10, 26, 46, 34, 17, 22, 34, 47, 34, 34, 12,\n", + " 34, 5, 27, 42, 34, 43, 47])\n", + "loss= tensor(1873.6284, grad_fn=) , actor= tensor(395.7643, grad_fn=) , critic= tensor(14778.6416, grad_fn=) , return= 167685.1336480978\n", + "probs of actions: tensor([0.1726, 0.0232, 0.0592, 0.0098, 0.0171, 0.1092, 0.0322, 0.0095, 0.0461,\n", + " 0.0076, 0.0764, 0.0011, 0.0242, 0.0768, 0.1409, 0.0764, 0.0766, 0.0074,\n", + " 0.0767, 0.0050, 0.0579, 0.1034, 0.0760, 0.0229, 0.1366],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "61000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 45, 42, 41, 44, 26, 43, 23, 20, 47, 41, 47, 40, 23, 40, 9, 47, 47,\n", + " 47, 34, 40, 34, 41, 40, 47])\n", + "loss= tensor(1972.1832, grad_fn=) , actor= tensor(378.8188, grad_fn=) , critic= tensor(15933.6445, grad_fn=) , return= 173520.84451664618\n", + "probs of actions: tensor([0.0193, 0.0448, 0.0799, 0.0233, 0.0023, 0.0469, 0.0216, 0.0393, 0.0039,\n", + " 0.1442, 0.0230, 0.1437, 0.1938, 0.0399, 0.1922, 0.0028, 0.1429, 0.1414,\n", + " 0.1414, 0.0842, 0.1868, 0.0841, 0.0234, 0.1829, 0.1390],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "62000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 34, 34, 30, 40, 47, 47, 27, 22, 40, 7, 12, 31, 47, 43, 47, 33, 47,\n", + " 40, 42, 43, 7, 23, 45, 27])\n", + "loss= tensor(1934.8679, grad_fn=) , actor= tensor(356.4716, grad_fn=) , critic= tensor(15783.9629, grad_fn=) , return= 173076.32865821663\n", + "probs of actions: tensor([0.1587, 0.0599, 0.0602, 0.0043, 0.1672, 0.1240, 0.1244, 0.0845, 0.0167,\n", + " 0.1702, 0.0067, 0.0079, 0.0242, 0.1250, 0.0261, 0.1245, 0.0356, 0.1242,\n", + " 0.1654, 0.0719, 0.0263, 0.0071, 0.0409, 0.0556, 0.0809],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "63000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 47, 26, 27, 27, 23, 27, 31, 40, 40, 47, 40, 41, 41, 22, 33, 10, 27,\n", + " 47, 27, 42, 26, 47, 45, 45])\n", + "loss= tensor(1892.2144, grad_fn=) , actor= tensor(324.2747, grad_fn=) , critic= tensor(15679.3965, grad_fn=) , return= 172105.96689582008\n", + "probs of actions: tensor([0.1411, 0.1422, 0.0426, 0.0762, 0.0762, 0.0355, 0.0764, 0.0253, 0.1529,\n", + " 0.1528, 0.1490, 0.1523, 0.0281, 0.0281, 0.0180, 0.0321, 0.0086, 0.0748,\n", + " 0.1460, 0.0739, 0.0672, 0.0418, 0.1443, 0.0628, 0.0628],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "64000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 39, 42, 30, 25, 47, 47, 27, 10, 47, 38, 21, 45, 47, 47, 42, 33, 19,\n", + " 47, 47, 34, 47, 42, 47, 26])\n", + "loss= tensor(1984.8193, grad_fn=) , actor= tensor(372.1967, grad_fn=) , critic= tensor(16126.2266, grad_fn=) , return= 174633.10666467805\n", + "probs of actions: tensor([0.1829, 0.0020, 0.0575, 0.0061, 0.0109, 0.1936, 0.1937, 0.0593, 0.0094,\n", + " 0.1970, 0.0140, 0.0262, 0.0618, 0.1945, 0.1941, 0.0558, 0.0359, 0.0032,\n", + " 0.1924, 0.1900, 0.0550, 0.1895, 0.0548, 0.1874, 0.0443],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "65000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 7, 27, 23, 26, 42, 47, 42, 31, 40, 31, 43, 42, 34, 34, 27, 33, 47,\n", + " 47, 38, 5, 43, 46, 33, 21])\n", + "loss= tensor(1988.1757, grad_fn=) , actor= tensor(389.8658, grad_fn=) , critic= tensor(15983.0977, grad_fn=) , return= 173772.72361840305\n", + "probs of actions: tensor([0.0062, 0.0063, 0.0516, 0.0291, 0.0510, 0.0429, 0.1872, 0.0425, 0.0263,\n", + " 0.1544, 0.0262, 0.0296, 0.0419, 0.0555, 0.0556, 0.0502, 0.0422, 0.1856,\n", + " 0.1842, 0.0129, 0.0086, 0.0297, 0.0087, 0.0427, 0.0293],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "66000 adversary: AdversaryModes.myopic\n", + " actions: tensor([14, 40, 22, 49, 47, 40, 40, 40, 38, 11, 45, 47, 41, 43, 16, 47, 45, 42,\n", + " 41, 10, 45, 40, 21, 26, 47])\n", + "loss= tensor(1966.0580, grad_fn=) , actor= tensor(378.4311, grad_fn=) , critic= tensor(15876.2686, grad_fn=) , return= 172689.31829423655\n", + "probs of actions: tensor([0.0203, 0.1626, 0.0187, 0.0052, 0.1671, 0.1674, 0.1681, 0.1684, 0.0105,\n", + " 0.0030, 0.0535, 0.1715, 0.0435, 0.0295, 0.0026, 0.1718, 0.0537, 0.0453,\n", + " 0.0431, 0.0084, 0.0538, 0.1578, 0.0243, 0.0576, 0.1657],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "67000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 38, 40, 38, 26, 45, 34, 3, 40, 36, 36, 22, 40, 26, 7, 14, 47,\n", + " 45, 31, 47, 40, 35, 30, 47])\n", + "loss= tensor(1919.0579, grad_fn=) , actor= tensor(392.5379, grad_fn=) , critic= tensor(15265.1992, grad_fn=) , return= 170674.15584359824\n", + "probs of actions: tensor([0.0639, 0.0647, 0.0083, 0.1618, 0.0081, 0.0647, 0.0587, 0.0450, 0.0027,\n", + " 0.1636, 0.0139, 0.0140, 0.0195, 0.1622, 0.0639, 0.0056, 0.0214, 0.1629,\n", + " 0.0589, 0.0197, 0.1614, 0.1551, 0.0072, 0.0076, 0.1590],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "68000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 21, 41, 41, 47, 26, 22, 47, 47, 34, 42, 40, 47, 47, 45, 19, 21, 47,\n", + " 40, 40, 15, 47, 40, 26, 46])\n", + "loss= tensor(1935.9998, grad_fn=) , actor= tensor(328.2297, grad_fn=) , critic= tensor(16077.7002, grad_fn=) , return= 173860.81925396374\n", + "probs of actions: tensor([0.0526, 0.0169, 0.0523, 0.0521, 0.2061, 0.0640, 0.0146, 0.2112, 0.2103,\n", + " 0.0460, 0.0389, 0.1955, 0.2116, 0.2109, 0.0497, 0.0019, 0.0173, 0.2099,\n", + " 0.1887, 0.1882, 0.0060, 0.2074, 0.1841, 0.0624, 0.0052],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "69000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 47, 38, 42, 31, 33, 40, 47, 22, 33, 40, 34, 40, 47, 47, 45, 40, 47,\n", + " 14, 40, 35, 27, 47, 47, 21])\n", + "loss= tensor(1959.4614, grad_fn=) , actor= tensor(321.0421, grad_fn=) , critic= tensor(16384.1934, grad_fn=) , return= 175805.2573237658\n", + "probs of actions: tensor([0.0701, 0.1932, 0.0060, 0.0480, 0.0183, 0.0481, 0.2233, 0.2027, 0.0162,\n", + " 0.0482, 0.2235, 0.0480, 0.2223, 0.2042, 0.2036, 0.0402, 0.2185, 0.2029,\n", + " 0.0184, 0.2147, 0.0049, 0.0491, 0.1999, 0.1982, 0.0168],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "70000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 32, 47, 26, 40, 47, 40, 42, 47, 47, 32, 40, 41, 37, 47, 33, 40, 22,\n", + " 40, 40, 42, 47, 27, 47, 40])\n", + "loss= tensor(1950.5181, grad_fn=) , actor= tensor(300.4617, grad_fn=) , critic= tensor(16500.5625, grad_fn=) , return= 175947.86496708682\n", + "probs of actions: tensor([0.2545, 0.0056, 0.2183, 0.0739, 0.2673, 0.2241, 0.2702, 0.0459, 0.2274,\n", + " 0.2278, 0.0050, 0.2708, 0.0444, 0.0015, 0.2290, 0.0424, 0.2653, 0.0181,\n", + " 0.2622, 0.2602, 0.0452, 0.2252, 0.0406, 0.2248, 0.2524],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "71000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 41, 46, 40, 30, 42, 10, 26, 23, 46, 47, 47, 49, 23, 27, 47, 21,\n", + " 45, 41, 34, 40, 47, 31, 5])\n", + "loss= tensor(2034.5222, grad_fn=) , actor= tensor(402.6420, grad_fn=) , critic= tensor(16318.8027, grad_fn=) , return= 175651.95275741126\n", + "probs of actions: tensor([0.2213, 0.2540, 0.0506, 0.0041, 0.2306, 0.0071, 0.0406, 0.0026, 0.0753,\n", + " 0.0151, 0.0038, 0.2722, 0.2724, 0.0027, 0.0153, 0.0436, 0.2722, 0.0107,\n", + " 0.0239, 0.0486, 0.0410, 0.2213, 0.2665, 0.0180, 0.0044],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "72000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 26, 40, 30, 47, 40, 27, 40, 42, 45, 33, 31, 47, 39, 26, 47, 40, 26,\n", + " 2, 12, 40, 40, 45, 34, 23])\n", + "loss= tensor(1938.0613, grad_fn=) , actor= tensor(335.1321, grad_fn=) , critic= tensor(16029.2920, grad_fn=) , return= 174027.61829858657\n", + "probs of actions: tensor([0.2302, 0.0799, 0.2378, 0.0091, 0.1748, 0.2432, 0.0444, 0.2452, 0.0464,\n", + " 0.0318, 0.0462, 0.0199, 0.1799, 0.0009, 0.0789, 0.1796, 0.2385, 0.0785,\n", + " 0.0028, 0.0068, 0.2312, 0.2294, 0.0329, 0.0411, 0.0198],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "73000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 26, 40, 41, 26, 29, 26, 31, 33, 34, 40, 33, 26, 33, 14, 25, 42, 47,\n", + " 10, 21, 22, 42, 47, 44, 27])\n", + "loss= tensor(1907.7290, grad_fn=) , actor= tensor(351.0570, grad_fn=) , critic= tensor(15566.7197, grad_fn=) , return= 172165.99867898755\n", + "probs of actions: tensor([0.2456, 0.0911, 0.2544, 0.0623, 0.0913, 0.0108, 0.0911, 0.0198, 0.0461,\n", + " 0.0309, 0.2629, 0.0464, 0.0905, 0.0466, 0.0173, 0.0080, 0.0570, 0.1154,\n", + " 0.0055, 0.0174, 0.0157, 0.0566, 0.1148, 0.0067, 0.0460],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "74000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 34, 25, 26, 31, 42, 26, 30, 26, 40, 40, 42, 41, 34, 21, 5, 26, 27,\n", + " 21, 40, 14, 40, 40, 41, 12])\n", + "loss= tensor(1910.5181, grad_fn=) , actor= tensor(353.0750, grad_fn=) , critic= tensor(15574.4297, grad_fn=) , return= 172356.5496182668\n", + "probs of actions: tensor([0.1008, 0.0353, 0.0105, 0.1027, 0.0215, 0.0525, 0.1033, 0.0111, 0.1031,\n", + " 0.2070, 0.2066, 0.0517, 0.0615, 0.0360, 0.0222, 0.0061, 0.1005, 0.0428,\n", + " 0.0228, 0.1958, 0.0189, 0.1935, 0.1915, 0.0592, 0.0087],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "75000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 26, 26, 40, 23, 47, 47, 23, 40, 40, 42, 26, 40, 40, 44,\n", + " 47, 27, 47, 20, 44, 33, 40])\n", + "loss= tensor(1895.1654, grad_fn=) , actor= tensor(274.9843, grad_fn=) , critic= tensor(16201.8105, grad_fn=) , return= 174869.29062309302\n", + "probs of actions: tensor([0.3138, 0.3209, 0.3249, 0.3284, 0.0963, 0.0959, 0.3353, 0.0112, 0.1433,\n", + " 0.1432, 0.0112, 0.3350, 0.3338, 0.0402, 0.0951, 0.3291, 0.3269, 0.0037,\n", + " 0.1451, 0.0315, 0.1456, 0.0015, 0.0039, 0.0415, 0.3104],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "76000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 41, 41, 40, 40, 41, 15, 40, 47, 40, 30, 47, 24, 34, 40, 40, 26,\n", + " 26, 40, 40, 47, 40, 42, 31])\n", + "loss= tensor(1912.5856, grad_fn=) , actor= tensor(285.5188, grad_fn=) , critic= tensor(16270.6670, grad_fn=) , return= 175333.11594653182\n", + "probs of actions: tensor([0.1238, 0.2460, 0.0779, 0.0780, 0.2522, 0.2535, 0.0779, 0.0046, 0.2544,\n", + " 0.1657, 0.2540, 0.0057, 0.1672, 0.0078, 0.0294, 0.2484, 0.2471, 0.1230,\n", + " 0.1225, 0.2424, 0.2408, 0.1660, 0.2382, 0.0428, 0.0174],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "77000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 29, 40, 47, 11, 40, 23, 34, 40, 40, 47, 47, 40, 33, 26, 33, 41, 47,\n", + " 47, 40, 34, 33, 47, 40, 40])\n", + "loss= tensor(1928.1060, grad_fn=) , actor= tensor(307.9018, grad_fn=) , critic= tensor(16202.0410, grad_fn=) , return= 174740.97953235978\n", + "probs of actions: tensor([0.0445, 0.0096, 0.2188, 0.1804, 0.0024, 0.2225, 0.0101, 0.0340, 0.2251,\n", + " 0.2249, 0.1887, 0.1888, 0.2235, 0.0517, 0.1100, 0.0520, 0.0725, 0.1892,\n", + " 0.1887, 0.2163, 0.0351, 0.0527, 0.1879, 0.2110, 0.2102],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "78000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 26, 40, 47, 33, 24, 42, 47, 26, 42, 40, 40, 33, 26, 40, 47, 22,\n", + " 40, 41, 12, 26, 40, 34, 47])\n", + "loss= tensor(1886.1116, grad_fn=) , actor= tensor(282.9758, grad_fn=) , critic= tensor(16031.3574, grad_fn=) , return= 173600.36778473092\n", + "probs of actions: tensor([0.0583, 0.2815, 0.1469, 0.2873, 0.1748, 0.0470, 0.0062, 0.0417, 0.1795,\n", + " 0.1464, 0.0412, 0.2914, 0.2905, 0.0476, 0.1443, 0.2864, 0.1830, 0.0069,\n", + " 0.2820, 0.0554, 0.0063, 0.1411, 0.2743, 0.0285, 0.1823],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "79000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 26, 42, 29, 33, 41, 40, 45, 26, 26, 47, 40, 47, 40, 40, 26, 12, 42,\n", + " 26, 47, 47, 21, 44, 33, 40])\n", + "loss= tensor(1891.8264, grad_fn=) , actor= tensor(288.1180, grad_fn=) , critic= tensor(16037.0850, grad_fn=) , return= 174073.9673496968\n", + "probs of actions: tensor([0.2610, 0.1810, 0.0568, 0.0095, 0.0543, 0.0563, 0.2774, 0.0174, 0.1834,\n", + " 0.1828, 0.1220, 0.2777, 0.1226, 0.2763, 0.2754, 0.1804, 0.0060, 0.0547,\n", + " 0.1781, 0.1250, 0.1246, 0.0215, 0.0046, 0.0569, 0.2610],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "80000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 47, 42, 40, 41, 26, 47, 40, 27, 34, 27, 40, 40, 42, 47, 42, 24, 42,\n", + " 47, 43, 26, 47, 41, 40, 40])\n", + "loss= tensor(1913.2576, grad_fn=) , actor= tensor(279.7280, grad_fn=) , critic= tensor(16335.2969, grad_fn=) , return= 175455.47901343313\n", + "probs of actions: tensor([0.1579, 0.1823, 0.0742, 0.2287, 0.0520, 0.1609, 0.1912, 0.2324, 0.0541,\n", + " 0.0207, 0.0541, 0.2315, 0.2309, 0.0716, 0.1965, 0.0712, 0.0061, 0.0712,\n", + " 0.1966, 0.0257, 0.1554, 0.1969, 0.0500, 0.2200, 0.2189],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "81000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 21, 47, 26, 27, 47, 26, 40, 45, 40, 47, 40, 42, 40, 47, 37, 40,\n", + " 47, 47, 40, 14, 33, 40, 40])\n", + "loss= tensor(1912.6306, grad_fn=) , actor= tensor(282.3148, grad_fn=) , critic= tensor(16303.1572, grad_fn=) , return= 175091.17028973388\n", + "probs of actions: tensor([0.0339, 0.1361, 0.0126, 0.2733, 0.1359, 0.0688, 0.2817, 0.1351, 0.2151,\n", + " 0.0130, 0.2148, 0.2879, 0.2138, 0.0568, 0.2122, 0.2891, 0.0008, 0.2098,\n", + " 0.2884, 0.2875, 0.2073, 0.0093, 0.0553, 0.2035, 0.2028],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "82000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 47, 47, 45, 47, 26, 27, 47, 24, 27, 47, 40, 27, 42, 40, 47, 40, 33,\n", + " 27, 32, 27, 27, 33, 40, 42])\n", + "loss= tensor(1904.1316, grad_fn=) , actor= tensor(280.8685, grad_fn=) , critic= tensor(16232.6299, grad_fn=) , return= 174443.03946398242\n", + "probs of actions: tensor([0.1387, 0.2175, 0.2196, 0.0172, 0.2244, 0.1395, 0.0966, 0.2310, 0.0031,\n", + " 0.0965, 0.2347, 0.2657, 0.0961, 0.0394, 0.2628, 0.2365, 0.2608, 0.0561,\n", + " 0.0960, 0.0028, 0.0959, 0.0960, 0.0571, 0.2512, 0.0395],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "83000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 21, 23, 14, 40, 26, 33, 26, 26, 1, 26, 27, 27, 40, 40, 45, 40, 40,\n", + " 40, 27, 41, 33, 26, 33, 40])\n", + "loss= tensor(1865.8400, grad_fn=) , actor= tensor(332.0604, grad_fn=) , critic= tensor(15337.7949, grad_fn=) , return= 171097.08791489864\n", + "probs of actions: tensor([0.0089, 0.0131, 0.0042, 0.0099, 0.2956, 0.1859, 0.0428, 0.1852, 0.1845,\n", + " 0.0011, 0.1823, 0.0858, 0.0858, 0.2946, 0.2937, 0.0163, 0.2916, 0.2905,\n", + " 0.2891, 0.0861, 0.0270, 0.0450, 0.1771, 0.0454, 0.2798],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "84000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 33, 26, 33, 26, 27, 40, 26, 47, 29, 40, 31, 47, 31, 26, 42, 47, 40,\n", + " 26, 47, 28, 27, 47, 26, 47])\n", + "loss= tensor(1889.8198, grad_fn=) , actor= tensor(303.2254, grad_fn=) , critic= tensor(15865.9443, grad_fn=) , return= 173397.11764065275\n", + "probs of actions: tensor([0.1384, 0.0357, 0.1385, 0.0349, 0.1374, 0.1042, 0.2924, 0.1360, 0.2922,\n", + " 0.0056, 0.2910, 0.0086, 0.2967, 0.0087, 0.1328, 0.0159, 0.2977, 0.2832,\n", + " 0.1320, 0.2988, 0.0005, 0.1036, 0.2980, 0.1311, 0.2974],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "85000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 33, 40, 26, 40, 27, 33, 40, 33, 47, 40, 47, 40, 26, 47, 27, 26, 40,\n", + " 41, 40, 40, 26, 40, 40, 27])\n", + "loss= tensor(1859.9868, grad_fn=) , actor= tensor(219.4493, grad_fn=) , critic= tensor(16405.3750, grad_fn=) , return= 176029.38159228486\n", + "probs of actions: tensor([0.3258, 0.0398, 0.3337, 0.1268, 0.3377, 0.1206, 0.0381, 0.3403, 0.0381,\n", + " 0.2350, 0.3390, 0.2362, 0.3372, 0.1236, 0.2384, 0.1207, 0.1228, 0.3293,\n", + " 0.0280, 0.3264, 0.3250, 0.1227, 0.3216, 0.3194, 0.1211],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "86000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 40, 47, 40, 26, 45, 40, 27, 47, 47, 29, 27, 47, 40, 40, 26, 47, 27,\n", + " 26, 47, 47, 40, 40, 47, 47])\n", + "loss= tensor(1846.1295, grad_fn=) , actor= tensor(232.6173, grad_fn=) , critic= tensor(16135.1221, grad_fn=) , return= 174361.06408478122\n", + "probs of actions: tensor([0.0337, 0.4101, 0.2299, 0.4165, 0.0875, 0.0135, 0.4221, 0.1041, 0.2385,\n", + " 0.2390, 0.0059, 0.1042, 0.2419, 0.4176, 0.4165, 0.0853, 0.2438, 0.1046,\n", + " 0.0853, 0.2446, 0.2438, 0.4026, 0.4011, 0.2442, 0.2438],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "87000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 27, 40, 40, 27, 40, 40, 40, 40, 40, 40, 40, 40, 47, 40, 27,\n", + " 40, 40, 41, 40, 27, 36, 33])\n", + "loss= tensor(1796.7354, grad_fn=) , actor= tensor(130.5580, grad_fn=) , critic= tensor(16661.7734, grad_fn=) , return= 177059.3991693682\n", + "probs of actions: tensor([0.5556, 0.5635, 0.5693, 0.0840, 0.5779, 0.5808, 0.0824, 0.5841, 0.5846,\n", + " 0.5845, 0.5840, 0.5830, 0.5816, 0.5799, 0.5780, 0.1798, 0.5735, 0.0828,\n", + " 0.5688, 0.5656, 0.0299, 0.5611, 0.0844, 0.0009, 0.0242],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "88000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 31, 40, 47, 40, 40, 40, 47, 40, 47, 40, 40, 40, 40, 27, 27, 26, 40,\n", + " 30, 47, 40, 40, 41, 47, 40])\n", + "loss= tensor(1833.6692, grad_fn=) , actor= tensor(185.8749, grad_fn=) , critic= tensor(16477.9414, grad_fn=) , return= 175915.4351476879\n", + "probs of actions: tensor([0.4574, 0.0078, 0.4692, 0.1920, 0.4751, 0.4774, 0.4788, 0.1973, 0.4792,\n", + " 0.1996, 0.4779, 0.4768, 0.4751, 0.4731, 0.0815, 0.0819, 0.0788, 0.4626,\n", + " 0.0031, 0.2086, 0.4553, 0.4539, 0.0418, 0.2097, 0.4463],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "89000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 40, 40, 40, 40, 40, 40, 33, 47, 26, 40, 47, 40, 47, 40, 40, 40,\n", + " 40, 47, 34, 15, 27, 26, 40])\n", + "loss= tensor(1838.2657, grad_fn=) , actor= tensor(169.7902, grad_fn=) , critic= tensor(16684.7559, grad_fn=) , return= 176673.71289521185\n", + "probs of actions: tensor([0.5054, 0.1543, 0.5190, 0.5241, 0.5279, 0.5307, 0.5327, 0.5338, 0.0442,\n", + " 0.1608, 0.0573, 0.5318, 0.1634, 0.5281, 0.1649, 0.5240, 0.5218, 0.5190,\n", + " 0.5163, 0.1684, 0.0153, 0.0016, 0.0797, 0.0589, 0.4972],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "90000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 43, 22, 33, 40, 40, 40, 26, 40, 40, 40,\n", + " 40, 47, 40, 40, 40, 40, 40])\n", + "loss= tensor(1817.3181, grad_fn=) , actor= tensor(165.6376, grad_fn=) , critic= tensor(16516.8047, grad_fn=) , return= 176409.2336525403\n", + "probs of actions: tensor([0.5666, 0.5758, 0.5823, 0.5875, 0.5918, 0.5951, 0.5974, 0.5989, 0.0031,\n", + " 0.0014, 0.0412, 0.5974, 0.5957, 0.5939, 0.0548, 0.5893, 0.5861, 0.5837,\n", + " 0.5812, 0.1315, 0.5752, 0.5729, 0.5695, 0.5664, 0.5633],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "91000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 26, 34, 33, 26, 40, 31, 30, 40, 40, 33, 47, 47, 26, 47, 40, 40,\n", + " 40, 40, 40, 40, 40, 47, 40])\n", + "loss= tensor(1870.2925, grad_fn=) , actor= tensor(244.3312, grad_fn=) , critic= tensor(16259.6133, grad_fn=) , return= 175369.19985999353\n", + "probs of actions: tensor([0.5096, 0.5181, 0.0642, 0.0136, 0.0419, 0.0618, 0.5369, 0.0107, 0.0030,\n", + " 0.5378, 0.5369, 0.0415, 0.1689, 0.1695, 0.0604, 0.1717, 0.5244, 0.5225,\n", + " 0.5198, 0.5170, 0.5141, 0.5111, 0.5082, 0.1765, 0.5024],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "92000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 27, 40, 40, 40, 47, 47, 40, 47, 40, 47, 40, 40, 40, 40, 40, 40,\n", + " 47, 40, 33, 40, 40, 40, 47])\n", + "loss= tensor(1798.8101, grad_fn=) , actor= tensor(138.7418, grad_fn=) , critic= tensor(16600.6816, grad_fn=) , return= 176411.57653628782\n", + "probs of actions: tensor([0.0364, 0.6482, 0.0746, 0.6590, 0.6628, 0.6657, 0.1300, 0.1306, 0.6692,\n", + " 0.1321, 0.6685, 0.1339, 0.6658, 0.6642, 0.6618, 0.6593, 0.6567, 0.6540,\n", + " 0.1412, 0.6482, 0.0249, 0.6427, 0.6388, 0.6360, 0.1463],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "93000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 29, 47, 40, 40, 40, 40, 40, 47, 40, 45, 40, 27, 40, 40, 14, 40, 40,\n", + " 40, 47, 47, 47, 40, 40, 27])\n", + "loss= tensor(1842.4354, grad_fn=) , actor= tensor(182.3745, grad_fn=) , critic= tensor(16600.6094, grad_fn=) , return= 176912.17438242436\n", + "probs of actions: tensor([0.5827, 0.0064, 0.1461, 0.5997, 0.6035, 0.6060, 0.6077, 0.6087, 0.1504,\n", + " 0.6083, 0.0054, 0.6064, 0.1141, 0.6027, 0.6001, 0.0048, 0.5950, 0.5915,\n", + " 0.5897, 0.1623, 0.1630, 0.1636, 0.5800, 0.5776, 0.1177],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "94000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 40, 47, 47, 40, 27, 47, 34, 47, 40, 40, 47, 40, 47, 40, 27, 27, 40,\n", + " 40, 47, 40, 27, 40, 40, 40])\n", + "loss= tensor(1862.3518, grad_fn=) , actor= tensor(198.6171, grad_fn=) , critic= tensor(16637.3477, grad_fn=) , return= 176455.76268735938\n", + "probs of actions: tensor([0.0115, 0.5689, 0.1786, 0.1797, 0.5805, 0.0826, 0.1835, 0.0084, 0.1861,\n", + " 0.5836, 0.5829, 0.1902, 0.5791, 0.1929, 0.5746, 0.0826, 0.0831, 0.5657,\n", + " 0.5623, 0.2003, 0.5572, 0.0848, 0.5521, 0.5480, 0.5457],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "95000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 41, 40, 40, 40, 27, 40, 40, 40, 40, 40, 27, 40, 29, 47, 33, 40,\n", + " 40, 40, 40, 33, 47, 40, 40])\n", + "loss= tensor(1825.9248, grad_fn=) , actor= tensor(173.7553, grad_fn=) , critic= tensor(16521.6953, grad_fn=) , return= 176236.01518796984\n", + "probs of actions: tensor([0.6617, 0.1310, 0.0212, 0.6791, 0.6826, 0.6852, 0.0736, 0.6880, 0.6880,\n", + " 0.6877, 0.6868, 0.6855, 0.0735, 0.6817, 0.0034, 0.1412, 0.0094, 0.6718,\n", + " 0.6686, 0.6658, 0.6629, 0.0100, 0.1485, 0.6535, 0.6518],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "96000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 47, 40, 27, 40, 40, 47, 40, 40, 27, 40, 40, 40, 27, 40,\n", + " 47, 40, 40, 40, 47, 26, 47])\n", + "loss= tensor(1766.9015, grad_fn=) , actor= tensor(116.2880, grad_fn=) , critic= tensor(16506.1348, grad_fn=) , return= 176095.08973449864\n", + "probs of actions: tensor([0.6375, 0.6443, 0.6498, 0.6540, 0.1375, 0.6592, 0.0912, 0.6623, 0.6622,\n", + " 0.1415, 0.6605, 0.6597, 0.0907, 0.6559, 0.6531, 0.6510, 0.0919, 0.6460,\n", + " 0.1523, 0.6399, 0.6379, 0.6349, 0.1561, 0.0487, 0.1579],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "97000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 40, 47, 40, 40, 40, 40, 40, 40, 47, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 47, 40, 47, 40, 40, 40])\n", + "loss= tensor(1764.5128, grad_fn=) , actor= tensor(80.0327, grad_fn=) , critic= tensor(16844.8008, grad_fn=) , return= 177563.2480528031\n", + "probs of actions: tensor([0.0941, 0.7884, 0.0924, 0.7978, 0.8013, 0.8036, 0.8050, 0.8058, 0.8059,\n", + " 0.0939, 0.8043, 0.8036, 0.8020, 0.8001, 0.7980, 0.7958, 0.7934, 0.7910,\n", + " 0.7884, 0.1049, 0.7829, 0.1070, 0.7778, 0.7758, 0.7728],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "98000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 27, 40, 40, 40, 40, 47, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1727.2877, grad_fn=) , actor= tensor(57.6052, grad_fn=) , critic= tensor(16696.8242, grad_fn=) , return= 177141.1115374485\n", + "probs of actions: tensor([0.7979, 0.8035, 0.8083, 0.8120, 0.8148, 0.8168, 0.8181, 0.8187, 0.0270,\n", + " 0.8186, 0.8173, 0.8162, 0.8148, 0.1041, 0.8109, 0.8093, 0.8070, 0.8046,\n", + " 0.8021, 0.7996, 0.7972, 0.7945, 0.7920, 0.7895, 0.7870],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "99000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 40, 40, 27, 40, 40, 40, 40, 47, 40, 27, 34, 40, 40, 40, 40, 40,\n", + " 40, 40, 47, 47, 40, 27, 40])\n", + "loss= tensor(1801.8759, grad_fn=) , actor= tensor(135.9473, grad_fn=) , critic= tensor(16659.2852, grad_fn=) , return= 176966.73356347837\n", + "probs of actions: tensor([0.7679, 0.0799, 0.7791, 0.7839, 0.0582, 0.7899, 0.7913, 0.7921, 0.7923,\n", + " 0.0806, 0.7909, 0.0564, 0.0033, 0.7864, 0.7842, 0.7822, 0.7799, 0.7775,\n", + " 0.7750, 0.7725, 0.0917, 0.0927, 0.7646, 0.0613, 0.7595],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "100000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 47, 40, 40, 40, 40, 40])\n", + "loss= tensor(1731.7704, grad_fn=) , actor= tensor(51.3467, grad_fn=) , critic= tensor(16804.2363, grad_fn=) , return= 177503.2982092025\n", + "probs of actions: tensor([0.7841, 0.0680, 0.7951, 0.7997, 0.8028, 0.8051, 0.8067, 0.8075, 0.8077,\n", + " 0.8074, 0.8066, 0.8054, 0.8039, 0.8021, 0.8001, 0.7979, 0.7955, 0.7931,\n", + " 0.7906, 0.0772, 0.7851, 0.7830, 0.7801, 0.7773, 0.7746],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "101000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 41, 40, 47, 40, 47, 26, 40, 40, 40, 40, 42, 29, 40, 40, 40, 40,\n", + " 27, 42, 40, 40, 47, 27, 41])\n", + "loss= tensor(1852.2449, grad_fn=) , actor= tensor(189.2673, grad_fn=) , critic= tensor(16629.7754, grad_fn=) , return= 176670.9239291964\n", + "probs of actions: tensor([0.5960, 0.6030, 0.0374, 0.6120, 0.1225, 0.6168, 0.1240, 0.0420, 0.6190,\n", + " 0.6181, 0.6169, 0.6153, 0.0145, 0.0044, 0.6086, 0.6054, 0.6029, 0.6002,\n", + " 0.1174, 0.0152, 0.5902, 0.5879, 0.1414, 0.1199, 0.0356],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "102000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 47, 27, 27, 40, 47, 27, 40, 40, 27, 14, 27, 27, 42, 40, 40, 40, 41,\n", + " 30, 27, 40, 47, 40, 26, 40])\n", + "loss= tensor(1832.4404, grad_fn=) , actor= tensor(232.3969, grad_fn=) , critic= tensor(16000.4355, grad_fn=) , return= 174055.472254452\n", + "probs of actions: tensor([0.1605, 0.1400, 0.1584, 0.1587, 0.5240, 0.1440, 0.1580, 0.5274, 0.5273,\n", + " 0.1582, 0.0028, 0.1592, 0.1589, 0.0257, 0.5174, 0.5158, 0.5136, 0.0356,\n", + " 0.0022, 0.1601, 0.5032, 0.1625, 0.4978, 0.0447, 0.4936],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "103000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 26, 40, 40, 40, 41, 40, 40, 40, 40, 27, 40, 40, 41, 31, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1790.3743, grad_fn=) , actor= tensor(134.1126, grad_fn=) , critic= tensor(16562.6172, grad_fn=) , return= 176566.26552589564\n", + "probs of actions: tensor([0.7170, 0.0425, 0.7312, 0.7354, 0.7390, 0.0300, 0.7435, 0.7446, 0.7449,\n", + " 0.7446, 0.0581, 0.7426, 0.7403, 0.0288, 0.0049, 0.7339, 0.7306, 0.7281,\n", + " 0.7253, 0.7221, 0.7189, 0.7157, 0.7126, 0.7095, 0.7064],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "104000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 40, 47, 40, 40, 26, 40, 40, 40, 40, 40, 47, 47, 40, 40, 27, 47,\n", + " 47, 40, 40, 26, 40, 27, 47])\n", + "loss= tensor(1816.8452, grad_fn=) , actor= tensor(164.2193, grad_fn=) , critic= tensor(16526.2578, grad_fn=) , return= 176070.27907009126\n", + "probs of actions: tensor([0.0454, 0.0540, 0.5915, 0.1268, 0.5975, 0.5998, 0.0502, 0.6014, 0.6010,\n", + " 0.6002, 0.5990, 0.5972, 0.1367, 0.1379, 0.5905, 0.5880, 0.1078, 0.1431,\n", + " 0.1443, 0.5754, 0.5729, 0.0516, 0.5661, 0.1112, 0.1500],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "105000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 21, 40, 27, 40, 40, 40, 40, 40, 40, 27, 27, 40, 26, 40, 40,\n", + " 40, 43, 47, 40, 40, 41, 40])\n", + "loss= tensor(1798.8939, grad_fn=) , actor= tensor(169.2483, grad_fn=) , critic= tensor(16296.4561, grad_fn=) , return= 175451.07494659265\n", + "probs of actions: tensor([0.6185, 0.6266, 0.6325, 0.0021, 0.6412, 0.0829, 0.6464, 0.6474, 0.6478,\n", + " 0.6477, 0.6470, 0.6458, 0.0824, 0.0828, 0.6396, 0.0658, 0.6347, 0.6315,\n", + " 0.6293, 0.0008, 0.1034, 0.6208, 0.6185, 0.0526, 0.6122],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "106000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 26, 40, 40, 40, 40, 40, 47, 40, 47, 26, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 27, 47, 47])\n", + "loss= tensor(1767.8008, grad_fn=) , actor= tensor(120.3333, grad_fn=) , critic= tensor(16474.6738, grad_fn=) , return= 175847.413330327\n", + "probs of actions: tensor([0.5320, 0.5394, 0.5446, 0.0694, 0.5524, 0.5550, 0.5567, 0.5577, 0.5581,\n", + " 0.1329, 0.5569, 0.1350, 0.0665, 0.5529, 0.5504, 0.5483, 0.5461, 0.5437,\n", + " 0.5413, 0.5386, 0.5358, 0.5331, 0.0953, 0.1469, 0.1476],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "107000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 47, 40, 40, 40, 26, 40, 40, 27, 40, 27, 47, 27, 40, 26, 41, 47,\n", + " 32, 31, 36, 40, 41, 47, 40])\n", + "loss= tensor(1860.1967, grad_fn=) , actor= tensor(229.3316, grad_fn=) , critic= tensor(16308.6514, grad_fn=) , return= 175145.3786085621\n", + "probs of actions: tensor([0.5082, 0.1524, 0.1534, 0.5218, 0.5249, 0.5268, 0.0683, 0.5285, 0.5281,\n", + " 0.0868, 0.5263, 0.0871, 0.1672, 0.0875, 0.5184, 0.0678, 0.0781, 0.1734,\n", + " 0.0007, 0.0062, 0.0013, 0.4984, 0.0780, 0.1784, 0.4909],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "108000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 26, 40, 40, 40, 40, 26, 40, 21,\n", + " 26, 27, 40, 40, 41, 41, 40])\n", + "loss= tensor(1765.3293, grad_fn=) , actor= tensor(129.3890, grad_fn=) , critic= tensor(16359.4043, grad_fn=) , return= 175395.20752854593\n", + "probs of actions: tensor([0.5858, 0.5935, 0.5994, 0.6042, 0.6081, 0.6110, 0.6132, 0.6145, 0.6151,\n", + " 0.6151, 0.0603, 0.6135, 0.6117, 0.6101, 0.6082, 0.0609, 0.6037, 0.0027,\n", + " 0.0615, 0.0951, 0.5903, 0.5871, 0.0571, 0.0572, 0.5805],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "109000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 47, 27, 40, 27, 40, 27, 47, 40, 40, 26, 40, 26, 40,\n", + " 31, 40, 47, 41, 40, 33, 27])\n", + "loss= tensor(1825.9005, grad_fn=) , actor= tensor(172.9425, grad_fn=) , critic= tensor(16529.5801, grad_fn=) , return= 176613.785999152\n", + "probs of actions: tensor([0.5055, 0.5129, 0.5179, 0.5219, 0.5252, 0.0983, 0.1981, 0.5304, 0.1986,\n", + " 0.5310, 0.1990, 0.1022, 0.5284, 0.5274, 0.0542, 0.5238, 0.0546, 0.5193,\n", + " 0.0047, 0.5143, 0.1095, 0.0518, 0.5078, 0.0227, 0.2040],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "110000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 27, 40, 40, 27, 40, 41, 42, 40, 40, 47, 40, 40, 40, 40, 40, 27, 40,\n", + " 27, 27, 40, 40, 40, 27, 47])\n", + "loss= tensor(1795.3805, grad_fn=) , actor= tensor(152.8551, grad_fn=) , critic= tensor(16425.2539, grad_fn=) , return= 175585.96223232846\n", + "probs of actions: tensor([0.4511, 0.2412, 0.4613, 0.4644, 0.2438, 0.4683, 0.0448, 0.0169, 0.4702,\n", + " 0.4700, 0.1305, 0.4683, 0.4673, 0.4658, 0.4642, 0.4623, 0.2485, 0.4576,\n", + " 0.2494, 0.2500, 0.4498, 0.4474, 0.4458, 0.2507, 0.1414],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "111000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 27, 40, 47, 40, 27, 40, 27, 40, 47, 27, 47, 27, 40, 40, 40, 40, 47,\n", + " 14, 40, 40, 40, 41, 47, 29])\n", + "loss= tensor(1799.9324, grad_fn=) , actor= tensor(170.0046, grad_fn=) , critic= tensor(16299.2773, grad_fn=) , return= 175439.5604957522\n", + "probs of actions: tensor([0.4684, 0.2187, 0.4786, 0.1410, 0.4834, 0.2206, 0.4861, 0.2213, 0.4863,\n", + " 0.1466, 0.2219, 0.1487, 0.2224, 0.4805, 0.4787, 0.4767, 0.4743, 0.1547,\n", + " 0.0028, 0.4669, 0.4631, 0.4615, 0.0371, 0.1592, 0.0026],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "112000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 27, 27, 47, 40, 40, 40, 27, 30, 40, 40, 27, 40, 27, 27, 27, 40, 26,\n", + " 27, 47, 27, 47, 27, 47, 40])\n", + "loss= tensor(1793.4324, grad_fn=) , actor= tensor(200.7385, grad_fn=) , critic= tensor(15926.9385, grad_fn=) , return= 173589.84688154914\n", + "probs of actions: tensor([0.0201, 0.2191, 0.2198, 0.1482, 0.5013, 0.5030, 0.5040, 0.2218, 0.0019,\n", + " 0.5036, 0.5029, 0.2235, 0.5000, 0.2244, 0.2253, 0.2260, 0.4910, 0.0316,\n", + " 0.2280, 0.1627, 0.2286, 0.1638, 0.2295, 0.1650, 0.4724],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "113000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 21, 40, 40, 40, 41, 47, 40, 47, 40, 47, 40, 40, 47, 40, 40, 27,\n", + " 40, 40, 40, 26, 40, 27, 40])\n", + "loss= tensor(1837.4661, grad_fn=) , actor= tensor(167.6475, grad_fn=) , critic= tensor(16698.1855, grad_fn=) , return= 176816.81686913522\n", + "probs of actions: tensor([0.5647, 0.5729, 0.0036, 0.5825, 0.5865, 0.5890, 0.0330, 0.1210, 0.5924,\n", + " 0.1222, 0.5920, 0.1237, 0.5900, 0.5885, 0.1264, 0.5843, 0.5821, 0.1670,\n", + " 0.5764, 0.5728, 0.5706, 0.0343, 0.5656, 0.1714, 0.5601],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "114000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 40, 40, 47, 40, 27, 40, 27, 40, 33, 40, 27, 27, 27, 27, 47, 40, 31,\n", + " 41, 40, 27, 33, 40, 43, 47])\n", + "loss= tensor(1817.7230, grad_fn=) , actor= tensor(212.3707, grad_fn=) , critic= tensor(16053.5225, grad_fn=) , return= 174053.13101015033\n", + "probs of actions: tensor([0.0052, 0.3140, 0.3150, 0.1330, 0.3156, 0.3805, 0.3145, 0.3850, 0.3129,\n", + " 0.0424, 0.3111, 0.3895, 0.3910, 0.3912, 0.3915, 0.1413, 0.3021, 0.0069,\n", + " 0.0371, 0.2976, 0.3909, 0.0444, 0.2929, 0.0022, 0.1453],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "115000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 27, 40, 14, 40, 40, 40, 40, 27, 41, 40, 27, 40, 27, 33, 27, 41,\n", + " 40, 30, 27, 40, 40, 40, 40])\n", + "loss= tensor(1817.3916, grad_fn=) , actor= tensor(209.3783, grad_fn=) , critic= tensor(16080.1328, grad_fn=) , return= 174184.06228266636\n", + "probs of actions: tensor([0.0434, 0.4489, 0.2708, 0.4543, 0.0025, 0.4560, 0.4578, 0.4579, 0.4576,\n", + " 0.2810, 0.0367, 0.4543, 0.2837, 0.4507, 0.2852, 0.0487, 0.2874, 0.0362,\n", + " 0.4383, 0.0028, 0.2899, 0.4315, 0.4289, 0.4274, 0.4255],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "116000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 27, 40, 40, 40, 27, 40, 40, 27, 30, 40, 40, 40, 40, 41, 41, 40, 40,\n", + " 47, 33, 27, 26, 40, 27, 27])\n", + "loss= tensor(1842.9867, grad_fn=) , actor= tensor(183.5430, grad_fn=) , critic= tensor(16594.4375, grad_fn=) , return= 176824.65999462956\n", + "probs of actions: tensor([0.4862, 0.2171, 0.4962, 0.4990, 0.5011, 0.2199, 0.5034, 0.5037, 0.2218,\n", + " 0.0022, 0.5015, 0.5003, 0.4989, 0.4972, 0.0355, 0.0355, 0.4898, 0.4871,\n", + " 0.1428, 0.0406, 0.2304, 0.0377, 0.4731, 0.2324, 0.2331],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "117000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 47, 27, 40, 40, 40, 47, 47, 40, 47, 27, 40, 47, 40, 40, 40, 40, 27,\n", + " 33, 33, 40, 40, 40, 40, 31])\n", + "loss= tensor(1836.8593, grad_fn=) , actor= tensor(164.0345, grad_fn=) , critic= tensor(16728.2480, grad_fn=) , return= 177059.27358053933\n", + "probs of actions: tensor([0.4811, 0.1185, 0.1950, 0.4953, 0.4981, 0.5000, 0.1203, 0.1210, 0.5019,\n", + " 0.1223, 0.1994, 0.4995, 0.1249, 0.4966, 0.4947, 0.4920, 0.4894, 0.2044,\n", + " 0.0531, 0.0536, 0.4780, 0.4754, 0.4734, 0.4712, 0.0076],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "118000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 47, 40, 27, 40, 33, 40, 40, 40, 40, 27, 33, 27, 40, 40, 40, 33, 40,\n", + " 40, 27, 33, 47, 40, 27, 27])\n", + "loss= tensor(1831.8607, grad_fn=) , actor= tensor(182.2419, grad_fn=) , critic= tensor(16496.1875, grad_fn=) , return= 176417.07335892445\n", + "probs of actions: tensor([0.0442, 0.0715, 0.6047, 0.1649, 0.6130, 0.0327, 0.6175, 0.6185, 0.6189,\n", + " 0.6188, 0.1664, 0.0321, 0.1677, 0.6134, 0.6109, 0.6086, 0.0334, 0.6033,\n", + " 0.5999, 0.1736, 0.0347, 0.0804, 0.5877, 0.1768, 0.1778],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "119000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 40, 40, 40, 40, 27, 27, 41, 27, 27, 26, 40, 41, 40, 27, 26, 41, 27,\n", + " 40, 40, 33, 27, 40, 27, 40])\n", + "loss= tensor(1792.6290, grad_fn=) , actor= tensor(184.4319, grad_fn=) , critic= tensor(16081.9717, grad_fn=) , return= 174439.44495661423\n", + "probs of actions: tensor([0.2411, 0.5062, 0.5102, 0.5136, 0.5163, 0.2437, 0.2450, 0.0465, 0.2460,\n", + " 0.2471, 0.0374, 0.5187, 0.0450, 0.5163, 0.2494, 0.0378, 0.0449, 0.2522,\n", + " 0.5039, 0.5008, 0.0539, 0.2548, 0.4938, 0.2557, 0.4890],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "120000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 27, 40, 40, 27, 40, 41, 41, 40, 40, 27, 26, 33, 40, 27,\n", + " 31, 27, 33, 27, 40, 40, 41])\n", + "loss= tensor(1795.7332, grad_fn=) , actor= tensor(172.6869, grad_fn=) , critic= tensor(16230.4629, grad_fn=) , return= 174751.09257635282\n", + "probs of actions: tensor([0.5119, 0.5190, 0.5236, 0.5274, 0.2290, 0.5330, 0.5348, 0.2308, 0.5363,\n", + " 0.0500, 0.0498, 0.5351, 0.5341, 0.2338, 0.0392, 0.0616, 0.5255, 0.2369,\n", + " 0.0091, 0.2385, 0.0638, 0.2398, 0.5104, 0.5076, 0.0498],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "121000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 41, 27, 42, 40, 40, 40, 40, 40, 27, 26, 26, 27, 40, 27, 27, 40, 40,\n", + " 45, 40, 34, 33, 41, 40, 40])\n", + "loss= tensor(1837.2996, grad_fn=) , actor= tensor(217.4630, grad_fn=) , critic= tensor(16198.3652, grad_fn=) , return= 174944.20361316815\n", + "probs of actions: tensor([0.4088, 0.0868, 0.2855, 0.0072, 0.4225, 0.4241, 0.4252, 0.4258, 0.4260,\n", + " 0.2964, 0.0603, 0.0603, 0.2994, 0.4221, 0.2999, 0.3010, 0.4167, 0.4145,\n", + " 0.0012, 0.4111, 0.0034, 0.0504, 0.0775, 0.4032, 0.4017],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "122000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 27, 41, 27, 27, 40, 27, 41, 40, 27, 27, 40, 40, 27, 40, 41, 27, 40,\n", + " 27, 26, 27, 27, 40, 40, 41])\n", + "loss= tensor(1774.0065, grad_fn=) , actor= tensor(174.4910, grad_fn=) , critic= tensor(15995.1553, grad_fn=) , return= 173653.50497982252\n", + "probs of actions: tensor([0.0715, 0.2505, 0.1072, 0.2543, 0.2565, 0.3927, 0.2594, 0.1025, 0.3951,\n", + " 0.2627, 0.2638, 0.3941, 0.3933, 0.2652, 0.3912, 0.0980, 0.2672, 0.3860,\n", + " 0.2684, 0.0675, 0.2697, 0.2700, 0.3759, 0.3740, 0.0958],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "123000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 27, 40, 41, 41, 47, 40, 41, 27, 40, 40, 40, 27, 40, 26, 27, 40, 47,\n", + " 40, 27, 27, 40, 27, 27, 27])\n", + "loss= tensor(1855.0508, grad_fn=) , actor= tensor(206.6271, grad_fn=) , critic= tensor(16484.2363, grad_fn=) , return= 176237.45862479907\n", + "probs of actions: tensor([0.0085, 0.3147, 0.3031, 0.0981, 0.0971, 0.0745, 0.3065, 0.0944, 0.3346,\n", + " 0.3061, 0.3056, 0.3050, 0.3397, 0.3031, 0.0786, 0.3425, 0.2988, 0.0792,\n", + " 0.2962, 0.3439, 0.3446, 0.2918, 0.3443, 0.3448, 0.3446],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "124000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 27, 40, 40, 40, 27, 27, 26, 40, 27, 40, 27, 26, 40, 40, 40, 21, 27,\n", + " 33, 41, 41, 27, 47, 40, 26])\n", + "loss= tensor(1795.7566, grad_fn=) , actor= tensor(196.0376, grad_fn=) , critic= tensor(15997.1895, grad_fn=) , return= 174366.37444403183\n", + "probs of actions: tensor([0.1158, 0.3194, 0.3042, 0.3055, 0.3064, 0.3338, 0.3373, 0.1108, 0.3071,\n", + " 0.3439, 0.3061, 0.3467, 0.1091, 0.3036, 0.3023, 0.3011, 0.0039, 0.3530,\n", + " 0.0298, 0.0837, 0.0834, 0.3540, 0.0652, 0.2901, 0.1092],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "125000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 12, 40, 42, 27, 47, 40, 26, 27, 40, 26, 26, 27, 40, 27, 26, 47, 33,\n", + " 41, 31, 47, 41, 27, 27, 26])\n", + "loss= tensor(1860.6257, grad_fn=) , actor= tensor(256.6014, grad_fn=) , critic= tensor(16040.2432, grad_fn=) , return= 174329.78638846165\n", + "probs of actions: tensor([0.2661, 0.0026, 0.2540, 0.0182, 0.2776, 0.0648, 0.2564, 0.1693, 0.2875,\n", + " 0.2557, 0.1687, 0.1680, 0.2933, 0.2530, 0.2948, 0.1671, 0.0687, 0.0304,\n", + " 0.1115, 0.0215, 0.0700, 0.1099, 0.2991, 0.2998, 0.1655],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "126000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 41, 27, 26, 41, 26, 40, 47, 40, 33, 27, 31, 40, 27, 41, 27, 40, 27,\n", + " 40, 33, 27, 40, 41, 40, 40])\n", + "loss= tensor(1828.3358, grad_fn=) , actor= tensor(225.9854, grad_fn=) , critic= tensor(16023.5049, grad_fn=) , return= 174093.23869288695\n", + "probs of actions: tensor([0.1493, 0.1424, 0.2953, 0.1491, 0.1404, 0.1488, 0.2507, 0.0630, 0.2506,\n", + " 0.0254, 0.3151, 0.0148, 0.2488, 0.3178, 0.1321, 0.3197, 0.2452, 0.3211,\n", + " 0.2432, 0.0265, 0.3225, 0.2403, 0.1270, 0.2386, 0.2379],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "127000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 27, 47, 33, 40, 40, 26, 27, 27, 41, 30, 27, 27, 27, 31, 27, 40, 26,\n", + " 27, 41, 40, 47, 27, 40, 40])\n", + "loss= tensor(1828.9890, grad_fn=) , actor= tensor(237.2220, grad_fn=) , critic= tensor(15917.6689, grad_fn=) , return= 173522.42795004798\n", + "probs of actions: tensor([0.0746, 0.2669, 0.0745, 0.0312, 0.2450, 0.2456, 0.1599, 0.2825, 0.2844,\n", + " 0.1209, 0.0051, 0.2878, 0.2889, 0.2895, 0.0199, 0.2911, 0.2403, 0.1581,\n", + " 0.2927, 0.1148, 0.2362, 0.0808, 0.2929, 0.2340, 0.2328],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "128000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 26, 27, 27, 27, 27, 40, 41, 27, 47, 41, 47, 27, 27, 41, 26, 33, 27,\n", + " 26, 47, 33, 47, 26, 27, 27])\n", + "loss= tensor(1821.2272, grad_fn=) , actor= tensor(210.2656, grad_fn=) , critic= tensor(16109.6152, grad_fn=) , return= 174736.94251074977\n", + "probs of actions: tensor([0.1721, 0.1364, 0.3351, 0.3392, 0.3433, 0.3471, 0.1725, 0.1530, 0.3550,\n", + " 0.0718, 0.1504, 0.0725, 0.3604, 0.3620, 0.1475, 0.1321, 0.0326, 0.3644,\n", + " 0.1314, 0.0755, 0.0335, 0.0759, 0.1315, 0.3648, 0.3644],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "129000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 41, 42, 27, 33, 47, 33, 42, 26, 40, 41, 27, 33, 27, 41, 27, 33,\n", + " 40, 27, 41, 27, 27, 45, 27])\n", + "loss= tensor(1905.9048, grad_fn=) , actor= tensor(272.9779, grad_fn=) , critic= tensor(16329.2686, grad_fn=) , return= 175429.86184368798\n", + "probs of actions: tensor([0.1503, 0.2612, 0.1486, 0.0181, 0.2767, 0.0321, 0.0689, 0.0316, 0.0164,\n", + " 0.1301, 0.2652, 0.1411, 0.2922, 0.0313, 0.2946, 0.1381, 0.2964, 0.0318,\n", + " 0.2582, 0.2984, 0.1348, 0.2993, 0.2999, 0.0026, 0.2999],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "130000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 40, 27, 27, 27, 27, 27, 31, 27, 26, 33, 40, 27, 27, 27, 27, 41, 27,\n", + " 27, 40, 33, 27, 40, 27, 27])\n", + "loss= tensor(1772.0770, grad_fn=) , actor= tensor(189.8737, grad_fn=) , critic= tensor(15822.0332, grad_fn=) , return= 173634.74358787315\n", + "probs of actions: tensor([0.0378, 0.1834, 0.3735, 0.3792, 0.3849, 0.3898, 0.3940, 0.0172, 0.4006,\n", + " 0.1230, 0.0337, 0.1799, 0.4074, 0.4092, 0.4103, 0.4112, 0.1230, 0.4118,\n", + " 0.4128, 0.1747, 0.0349, 0.4128, 0.1731, 0.4121, 0.4124],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "131000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 41, 40, 27, 27, 27, 26, 21, 27, 26, 27, 40, 27, 26, 26, 41, 27, 43,\n", + " 26, 27, 33, 41, 42, 27, 41])\n", + "loss= tensor(1792.1548, grad_fn=) , actor= tensor(227.0417, grad_fn=) , critic= tensor(15651.1299, grad_fn=) , return= 172583.62956484198\n", + "probs of actions: tensor([0.2223, 0.1399, 0.2257, 0.3182, 0.3223, 0.3260, 0.1402, 0.0084, 0.3342,\n", + " 0.1396, 0.3376, 0.2269, 0.3392, 0.1393, 0.1392, 0.1303, 0.3422, 0.0020,\n", + " 0.1395, 0.3437, 0.0312, 0.1266, 0.0217, 0.3435, 0.1256],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "132000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 41, 40, 41, 40, 27, 41, 27, 27, 27, 31, 27, 31, 40, 40, 40, 27, 41,\n", + " 47, 41, 26, 27, 33, 27, 26])\n", + "loss= tensor(1858.6785, grad_fn=) , actor= tensor(221.9788, grad_fn=) , critic= tensor(16366.9971, grad_fn=) , return= 175876.2197315135\n", + "probs of actions: tensor([0.1781, 0.1778, 0.2303, 0.1785, 0.2328, 0.2173, 0.1783, 0.2205, 0.2219,\n", + " 0.2231, 0.0246, 0.2248, 0.0246, 0.2351, 0.2347, 0.2342, 0.2275, 0.1706,\n", + " 0.0618, 0.1684, 0.1690, 0.2300, 0.0325, 0.2305, 0.1683],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "133000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 21, 27, 26, 27, 40, 40, 33, 27, 29, 26, 40, 27, 26, 26, 47, 41, 30,\n", + " 26, 41, 41, 47, 27, 47, 27])\n", + "loss= tensor(1853.1644, grad_fn=) , actor= tensor(266.3891, grad_fn=) , critic= tensor(15867.7529, grad_fn=) , return= 173755.7018060816\n", + "probs of actions: tensor([0.1927, 0.0149, 0.1591, 0.2040, 0.1606, 0.2461, 0.2470, 0.0270, 0.1635,\n", + " 0.0078, 0.2072, 0.2483, 0.1657, 0.2074, 0.2074, 0.0587, 0.1846, 0.0065,\n", + " 0.2073, 0.1827, 0.1813, 0.0603, 0.1701, 0.0608, 0.1708],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "134000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 41, 26, 31, 42, 40, 27, 26, 40, 27, 41, 47, 27, 41, 42, 41, 27, 26,\n", + " 47, 41, 21, 27, 31, 26, 40])\n", + "loss= tensor(1868.1267, grad_fn=) , actor= tensor(251.1110, grad_fn=) , critic= tensor(16170.1572, grad_fn=) , return= 174597.7703709052\n", + "probs of actions: tensor([0.1936, 0.1934, 0.2071, 0.0326, 0.0332, 0.1830, 0.1435, 0.2100, 0.1835,\n", + " 0.1453, 0.1921, 0.1153, 0.1464, 0.1896, 0.0311, 0.1872, 0.1480, 0.2112,\n", + " 0.1181, 0.1824, 0.0147, 0.1502, 0.0329, 0.2100, 0.1773],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "135000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 41, 27, 40, 41, 26, 31, 27, 26, 41, 41, 26, 31, 40, 41, 27, 41, 40,\n", + " 47, 40, 21, 31, 47, 41, 26])\n", + "loss= tensor(1865.0452, grad_fn=) , actor= tensor(244.2262, grad_fn=) , critic= tensor(16208.1895, grad_fn=) , return= 175209.84335362393\n", + "probs of actions: tensor([0.1678, 0.1673, 0.1235, 0.1583, 0.1682, 0.2440, 0.0370, 0.1259, 0.2461,\n", + " 0.1665, 0.1654, 0.2477, 0.0365, 0.1588, 0.1625, 0.1286, 0.1614, 0.1573,\n", + " 0.1237, 0.1565, 0.0173, 0.0378, 0.1245, 0.1550, 0.2433],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "136000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 41, 26, 40, 41, 26, 40, 40, 26, 41, 26, 27, 31, 26, 27, 26, 27, 31,\n", + " 40, 26, 40, 26, 41, 12, 42])\n", + "loss= tensor(1816.2698, grad_fn=) , actor= tensor(226.1388, grad_fn=) , critic= tensor(15901.3096, grad_fn=) , return= 173357.5093136458\n", + "probs of actions: tensor([0.1492, 0.1485, 0.2076, 0.2131, 0.1490, 0.2104, 0.2164, 0.2172, 0.2126,\n", + " 0.1476, 0.2135, 0.1055, 0.0368, 0.2135, 0.1061, 0.2133, 0.1068, 0.0375,\n", + " 0.2142, 0.2128, 0.2129, 0.2122, 0.1393, 0.0032, 0.0369],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "137000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 29, 34, 40, 41, 40, 27, 40, 41, 27, 40, 41, 47, 27, 26, 41, 40, 27,\n", + " 27, 26, 40, 41, 41, 27, 26])\n", + "loss= tensor(1893.6824, grad_fn=) , actor= tensor(260.6649, grad_fn=) , critic= tensor(16330.1738, grad_fn=) , return= 175750.96304347963\n", + "probs of actions: tensor([0.1032, 0.0143, 0.0060, 0.2353, 0.1485, 0.2378, 0.1028, 0.2394, 0.1471,\n", + " 0.1034, 0.2404, 0.1454, 0.1373, 0.1040, 0.1951, 0.1432, 0.2378, 0.1054,\n", + " 0.1057, 0.1948, 0.2343, 0.1389, 0.1386, 0.1070, 0.1939],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "138000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 42, 47, 26, 26, 40, 40, 26, 40, 34, 42, 41, 26, 26, 27, 47, 40, 26,\n", + " 40, 41, 47, 27, 47, 29, 40])\n", + "loss= tensor(1868.1526, grad_fn=) , actor= tensor(249.1966, grad_fn=) , critic= tensor(16189.5586, grad_fn=) , return= 174821.62275223059\n", + "probs of actions: tensor([0.1323, 0.0484, 0.1009, 0.2222, 0.2222, 0.2376, 0.2387, 0.2258, 0.2397,\n", + " 0.0042, 0.0452, 0.1272, 0.2278, 0.2274, 0.1275, 0.1048, 0.2369, 0.2274,\n", + " 0.2357, 0.1226, 0.1054, 0.1299, 0.1057, 0.0148, 0.2307],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "139000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 26, 40, 26, 26, 26, 27, 27, 26, 27, 26, 41, 47, 40, 27, 40, 26,\n", + " 26, 41, 40, 40, 40, 26, 41])\n", + "loss= tensor(1775.8669, grad_fn=) , actor= tensor(199.5251, grad_fn=) , critic= tensor(15763.4189, grad_fn=) , return= 173175.58774098862\n", + "probs of actions: tensor([0.1529, 0.2134, 0.2135, 0.2013, 0.2165, 0.2168, 0.2180, 0.1524, 0.1529,\n", + " 0.2202, 0.1538, 0.2209, 0.1476, 0.1119, 0.2042, 0.1553, 0.2034, 0.2215,\n", + " 0.2209, 0.1425, 0.2007, 0.2003, 0.1998, 0.2202, 0.1397],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "140000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 40, 27, 27, 21, 26, 27, 26, 47, 27, 26, 34, 40, 27, 26, 26,\n", + " 40, 26, 21, 26, 40, 27, 27])\n", + "loss= tensor(1790.8506, grad_fn=) , actor= tensor(226.2778, grad_fn=) , critic= tensor(15645.7275, grad_fn=) , return= 172646.56784006523\n", + "probs of actions: tensor([0.2070, 0.2084, 0.2100, 0.2015, 0.2125, 0.2143, 0.0236, 0.2374, 0.2180,\n", + " 0.2388, 0.1002, 0.2194, 0.2393, 0.0026, 0.2026, 0.2216, 0.2389, 0.2386,\n", + " 0.2001, 0.2385, 0.0241, 0.2372, 0.1976, 0.2238, 0.2243],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "141000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 47, 30, 41, 27, 40, 41, 40, 40, 40, 27, 27, 33, 47, 46, 40, 47, 26,\n", + " 47, 42, 26, 47, 47, 40, 26])\n", + "loss= tensor(1941.0272, grad_fn=) , actor= tensor(288.6988, grad_fn=) , critic= tensor(16523.2852, grad_fn=) , return= 176421.35801890405\n", + "probs of actions: tensor([0.0990, 0.0991, 0.0077, 0.1126, 0.1608, 0.1804, 0.1105, 0.1813, 0.1815,\n", + " 0.1816, 0.1645, 0.1651, 0.0172, 0.1017, 0.0039, 0.1805, 0.1019, 0.2793,\n", + " 0.1022, 0.0371, 0.2778, 0.1026, 0.1025, 0.1767, 0.2756],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "142000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 41, 42, 40, 26, 26, 40, 40, 41, 46, 26, 26, 26, 26, 41, 27, 42,\n", + " 27, 31, 40, 26, 26, 41, 26])\n", + "loss= tensor(1853.9375, grad_fn=) , actor= tensor(236.4106, grad_fn=) , critic= tensor(16175.2695, grad_fn=) , return= 174796.67642981198\n", + "probs of actions: tensor([0.1495, 0.3033, 0.1491, 0.0400, 0.1654, 0.3130, 0.3143, 0.1664, 0.1667,\n", + " 0.1456, 0.0036, 0.3216, 0.3209, 0.3214, 0.3215, 0.1415, 0.1108, 0.0371,\n", + " 0.1114, 0.0251, 0.1644, 0.3188, 0.3177, 0.1365, 0.3166],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "143000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 26, 21, 26, 41, 26, 26, 40, 40, 33, 40, 26, 40, 26, 45, 40, 26, 21,\n", + " 26, 26, 26, 26, 29, 26, 26])\n", + "loss= tensor(1815.3651, grad_fn=) , actor= tensor(229.1577, grad_fn=) , critic= tensor(15862.0742, grad_fn=) , return= 173327.2007164591\n", + "probs of actions: tensor([0.0430, 0.3427, 0.0418, 0.3495, 0.1422, 0.3571, 0.3584, 0.1830, 0.1833,\n", + " 0.0154, 0.1835, 0.3666, 0.1835, 0.3673, 0.0041, 0.1828, 0.3666, 0.0414,\n", + " 0.3645, 0.3640, 0.3632, 0.3624, 0.0108, 0.3609, 0.3599],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "144000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 40, 26, 40, 41, 26, 21, 40, 40, 26, 21, 40, 26, 41, 40, 26,\n", + " 26, 27, 36, 26, 40, 26, 41])\n", + "loss= tensor(1774.4768, grad_fn=) , actor= tensor(200.9467, grad_fn=) , critic= tensor(15735.3018, grad_fn=) , return= 172776.91393252029\n", + "probs of actions: tensor([0.3857, 0.3962, 0.4005, 0.1679, 0.4095, 0.1685, 0.1358, 0.4192, 0.0352,\n", + " 0.1689, 0.1689, 0.4256, 0.0352, 0.1687, 0.4265, 0.1306, 0.1680, 0.4254,\n", + " 0.4240, 0.0927, 0.0006, 0.4217, 0.1665, 0.4200, 0.1267],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "145000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 42, 27, 26, 41, 31, 40, 40, 26, 33, 41, 26, 26, 41, 40, 40, 47, 40,\n", + " 41, 42, 40, 26, 40, 40, 26])\n", + "loss= tensor(1881.8998, grad_fn=) , actor= tensor(242.2607, grad_fn=) , critic= tensor(16396.3906, grad_fn=) , return= 176114.39049432072\n", + "probs of actions: tensor([0.2080, 0.0345, 0.0682, 0.3298, 0.2092, 0.0147, 0.2118, 0.2124, 0.3422,\n", + " 0.0147, 0.2060, 0.3459, 0.3456, 0.2037, 0.2133, 0.2130, 0.0383, 0.2124,\n", + " 0.1992, 0.0307, 0.2113, 0.3462, 0.2104, 0.2100, 0.3448],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "146000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 21, 47, 40, 21, 47, 26, 26, 26, 40, 40, 26, 42, 40, 26, 41, 40, 41,\n", + " 26, 41, 40, 26, 40, 21, 26])\n", + "loss= tensor(1840.2689, grad_fn=) , actor= tensor(222.4758, grad_fn=) , critic= tensor(16177.9307, grad_fn=) , return= 174905.63755760866\n", + "probs of actions: tensor([0.2720, 0.0414, 0.0422, 0.2478, 0.0405, 0.0412, 0.2887, 0.2888, 0.2904,\n", + " 0.2536, 0.2541, 0.2939, 0.0362, 0.2544, 0.2950, 0.1879, 0.2534, 0.1858,\n", + " 0.2953, 0.1847, 0.2510, 0.2947, 0.2497, 0.0420, 0.2930],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "147000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 41, 21, 26, 41, 41, 40, 26, 42, 40, 41, 41, 47, 26, 31, 20, 27,\n", + " 27, 21, 26, 26, 27, 26, 40])\n", + "loss= tensor(1868.6079, grad_fn=) , actor= tensor(263.3314, grad_fn=) , critic= tensor(16052.7646, grad_fn=) , return= 173694.52031096208\n", + "probs of actions: tensor([0.2305, 0.2341, 0.1602, 0.0322, 0.3064, 0.1600, 0.1589, 0.2417, 0.3159,\n", + " 0.0388, 0.2430, 0.1561, 0.1555, 0.0481, 0.3207, 0.0167, 0.0005, 0.0931,\n", + " 0.0934, 0.0324, 0.3189, 0.3188, 0.0947, 0.3180, 0.2370],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "148000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 27, 40, 26, 26, 26, 40, 26, 26, 40, 31, 41, 41, 40, 15, 40, 41, 47,\n", + " 27, 41, 41, 40, 26, 27, 29])\n", + "loss= tensor(1845.4052, grad_fn=) , actor= tensor(233.6910, grad_fn=) , critic= tensor(16117.1406, grad_fn=) , return= 174909.18033659185\n", + "probs of actions: tensor([0.2367, 0.0977, 0.2414, 0.3000, 0.3007, 0.3026, 0.2463, 0.3066, 0.3068,\n", + " 0.2479, 0.0152, 0.1837, 0.1826, 0.2483, 0.0009, 0.2475, 0.1795, 0.0428,\n", + " 0.0969, 0.1783, 0.1768, 0.2447, 0.3087, 0.0988, 0.0069],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "149000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 47, 40, 27, 26, 40, 27, 42, 41, 27, 40, 41, 41, 40, 43, 40, 40,\n", + " 40, 42, 24, 30, 41, 40, 40])\n", + "loss= tensor(1891.6482, grad_fn=) , actor= tensor(266.2405, grad_fn=) , critic= tensor(16254.0771, grad_fn=) , return= 175086.6123071372\n", + "probs of actions: tensor([0.2227, 0.2264, 0.0574, 0.2863, 0.0989, 0.2294, 0.2907, 0.0984, 0.0334,\n", + " 0.1714, 0.0984, 0.2936, 0.1694, 0.1688, 0.2933, 0.0018, 0.2922, 0.2913,\n", + " 0.2904, 0.0333, 0.0007, 0.0062, 0.1626, 0.2849, 0.2842],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "150000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 26, 40, 26, 27, 41, 27, 27, 41, 26, 40, 40, 40, 27, 41,\n", + " 40, 26, 41, 41, 26, 40, 40])\n", + "loss= tensor(1804.2336, grad_fn=) , actor= tensor(191.9213, grad_fn=) , critic= tensor(16123.1221, grad_fn=) , return= 174594.1017927382\n", + "probs of actions: tensor([0.2694, 0.2734, 0.2753, 0.2769, 0.2926, 0.2795, 0.2954, 0.0673, 0.1879,\n", + " 0.0669, 0.0671, 0.1857, 0.2999, 0.2826, 0.2824, 0.2821, 0.0678, 0.1817,\n", + " 0.2800, 0.2996, 0.1797, 0.1783, 0.2987, 0.2762, 0.2752],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "151000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 26, 30, 41, 26, 41, 31, 47, 26, 26, 26, 27, 40, 31, 27, 40, 26,\n", + " 27, 40, 41, 42, 26, 40, 26])\n", + "loss= tensor(1841.7231, grad_fn=) , actor= tensor(242.5875, grad_fn=) , critic= tensor(15991.3564, grad_fn=) , return= 174294.21941357598\n", + "probs of actions: tensor([0.3028, 0.2117, 0.3134, 0.0061, 0.1621, 0.3191, 0.1615, 0.0270, 0.0539,\n", + " 0.3250, 0.3243, 0.3250, 0.0794, 0.2184, 0.0269, 0.0796, 0.2179, 0.3254,\n", + " 0.0803, 0.2163, 0.1516, 0.0543, 0.3230, 0.2145, 0.3215],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "152000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 40, 41, 26, 41, 26, 40, 41, 31, 41, 42, 41, 26, 26, 41, 26, 41,\n", + " 26, 26, 42, 47, 41, 26, 42])\n", + "loss= tensor(1808.7111, grad_fn=) , actor= tensor(203.7681, grad_fn=) , critic= tensor(16049.4297, grad_fn=) , return= 174239.2172456826\n", + "probs of actions: tensor([0.3219, 0.3294, 0.2295, 0.1634, 0.3377, 0.1633, 0.3420, 0.2354, 0.1606,\n", + " 0.0245, 0.1596, 0.0440, 0.1578, 0.3486, 0.3479, 0.1562, 0.3486, 0.1551,\n", + " 0.3480, 0.3470, 0.0438, 0.0465, 0.1517, 0.3457, 0.0441],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "153000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 40, 40, 41, 26, 26, 26, 40, 40, 31, 26, 47, 40, 26, 40, 26, 47,\n", + " 26, 40, 41, 26, 26, 26, 42])\n", + "loss= tensor(1781.1829, grad_fn=) , actor= tensor(181.1041, grad_fn=) , critic= tensor(16000.7871, grad_fn=) , return= 173982.72772832582\n", + "probs of actions: tensor([0.3921, 0.4014, 0.2300, 0.2312, 0.1462, 0.4150, 0.4168, 0.4196, 0.2353,\n", + " 0.2357, 0.0179, 0.4255, 0.0290, 0.2367, 0.4272, 0.2368, 0.4270, 0.0297,\n", + " 0.4265, 0.2364, 0.1347, 0.4247, 0.4235, 0.4226, 0.0325],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "154000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 26, 40, 41, 40, 26, 40, 26, 27, 27, 40, 40, 26, 26, 40, 26, 40,\n", + " 47, 27, 27, 26, 40, 41, 40])\n", + "loss= tensor(1775.1333, grad_fn=) , actor= tensor(185.5826, grad_fn=) , critic= tensor(15895.5078, grad_fn=) , return= 173457.91717338667\n", + "probs of actions: tensor([0.1372, 0.4157, 0.4182, 0.2295, 0.1319, 0.2313, 0.4333, 0.2327, 0.4386,\n", + " 0.0606, 0.0604, 0.2343, 0.2344, 0.4437, 0.4430, 0.2346, 0.4438, 0.2345,\n", + " 0.0362, 0.0607, 0.0609, 0.4407, 0.2330, 0.1190, 0.2324],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "155000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 42, 40, 26, 45, 40, 40, 26, 41, 26, 42, 26, 26, 26, 26, 26, 41, 40,\n", + " 41, 26, 40, 40, 47, 27, 41])\n", + "loss= tensor(1820.6405, grad_fn=) , actor= tensor(214.1809, grad_fn=) , critic= tensor(16064.5957, grad_fn=) , return= 174302.4089736139\n", + "probs of actions: tensor([0.2338, 0.0310, 0.2388, 0.3356, 0.0035, 0.2429, 0.2438, 0.3459, 0.1905,\n", + " 0.3501, 0.0269, 0.3529, 0.3527, 0.3537, 0.3544, 0.3549, 0.1820, 0.2483,\n", + " 0.1802, 0.3561, 0.2477, 0.2472, 0.0305, 0.0827, 0.1766],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "156000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 41, 41, 26, 41, 41, 41, 26, 41, 41, 40, 26, 41, 40, 40, 41, 41, 26,\n", + " 26, 40, 26, 34, 47, 40, 26])\n", + "loss= tensor(1815.7988, grad_fn=) , actor= tensor(175.9978, grad_fn=) , critic= tensor(16398.0098, grad_fn=) , return= 175865.9625763251\n", + "probs of actions: tensor([0.2578, 0.2691, 0.2692, 0.2673, 0.2717, 0.2708, 0.2707, 0.2734, 0.2705,\n", + " 0.2686, 0.2327, 0.2778, 0.2665, 0.2340, 0.2342, 0.2622, 0.2610, 0.2809,\n", + " 0.2804, 0.2343, 0.2815, 0.0037, 0.0295, 0.2334, 0.2815],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "157000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 40, 26, 26, 26, 26, 41, 26, 26, 41, 26, 26, 41, 40, 26, 26, 40,\n", + " 40, 47, 40, 26, 40, 26, 26])\n", + "loss= tensor(1757.1736, grad_fn=) , actor= tensor(156.7266, grad_fn=) , critic= tensor(16004.4688, grad_fn=) , return= 174512.55694260038\n", + "probs of actions: tensor([0.2824, 0.3214, 0.3244, 0.2913, 0.2919, 0.2938, 0.2956, 0.2124, 0.2993,\n", + " 0.2994, 0.2092, 0.3023, 0.3020, 0.2060, 0.3391, 0.3044, 0.3041, 0.3386,\n", + " 0.3384, 0.0225, 0.3375, 0.3058, 0.3366, 0.3061, 0.3056],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "158000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 27, 41, 33, 40, 47, 33, 26, 26, 40, 40, 40, 41, 41, 41, 26,\n", + " 40, 40, 26, 40, 40, 41, 26])\n", + "loss= tensor(1839.6133, grad_fn=) , actor= tensor(214.5186, grad_fn=) , critic= tensor(16250.9453, grad_fn=) , return= 175452.95076145054\n", + "probs of actions: tensor([0.2782, 0.2818, 0.2828, 0.0337, 0.2050, 0.0179, 0.3952, 0.0153, 0.0173,\n", + " 0.2896, 0.2902, 0.4014, 0.4019, 0.4021, 0.1939, 0.1930, 0.1922, 0.2941,\n", + " 0.4016, 0.4010, 0.2950, 0.3998, 0.3987, 0.1877, 0.2959],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "159000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 40, 26, 41, 40, 40, 40, 40, 40, 40, 26, 40, 26, 40, 40, 40, 41,\n", + " 40, 41, 41, 40, 26, 27, 40])\n", + "loss= tensor(1784.6456, grad_fn=) , actor= tensor(135.2896, grad_fn=) , critic= tensor(16493.5605, grad_fn=) , return= 176270.23881614313\n", + "probs of actions: tensor([0.2493, 0.4109, 0.4151, 0.2537, 0.1808, 0.4241, 0.4264, 0.4283, 0.4298,\n", + " 0.4309, 0.4317, 0.2580, 0.4321, 0.2589, 0.4319, 0.4317, 0.4312, 0.1704,\n", + " 0.4301, 0.1694, 0.1689, 0.4270, 0.2611, 0.0332, 0.4231],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "160000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 40, 26, 40, 26, 40, 26, 42, 40, 40, 26, 40, 34, 21, 40, 40, 40,\n", + " 41, 27, 40, 40, 40, 40, 41])\n", + "loss= tensor(1806.3583, grad_fn=) , actor= tensor(196.1551, grad_fn=) , critic= tensor(16102.0312, grad_fn=) , return= 174562.73485341395\n", + "probs of actions: tensor([0.1517, 0.5782, 0.5841, 0.1502, 0.5926, 0.1492, 0.5994, 0.1488, 0.0150,\n", + " 0.6056, 0.6062, 0.1492, 0.6060, 0.0022, 0.0059, 0.6037, 0.6026, 0.6014,\n", + " 0.1237, 0.0310, 0.5963, 0.5937, 0.5921, 0.5903, 0.1235],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "161000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 40, 41, 26, 26, 26, 42, 40, 40, 40, 27, 40, 40, 41, 41, 40, 40, 40,\n", + " 40, 26, 47, 41, 40, 40, 26])\n", + "loss= tensor(1837.1879, grad_fn=) , actor= tensor(192.2179, grad_fn=) , critic= tensor(16449.6992, grad_fn=) , return= 176384.9830840993\n", + "probs of actions: tensor([0.0478, 0.5686, 0.1234, 0.1430, 0.1422, 0.1419, 0.0156, 0.5921, 0.5935,\n", + " 0.5945, 0.0419, 0.5947, 0.5946, 0.1163, 0.1161, 0.5921, 0.5908, 0.5891,\n", + " 0.5871, 0.1465, 0.0214, 0.1152, 0.5787, 0.5766, 0.1492],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "162000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 40, 26, 34, 26, 40, 40, 41, 40, 41, 41, 26, 41, 40, 40, 40, 40,\n", + " 40, 40, 40, 47, 41, 21, 41])\n", + "loss= tensor(1837.2493, grad_fn=) , actor= tensor(186.3007, grad_fn=) , critic= tensor(16509.4844, grad_fn=) , return= 176401.37510268125\n", + "probs of actions: tensor([0.1637, 0.5306, 0.5352, 0.1585, 0.0023, 0.1580, 0.5474, 0.5496, 0.1553,\n", + " 0.5513, 0.1541, 0.1536, 0.1601, 0.1533, 0.5488, 0.5477, 0.5460, 0.5441,\n", + " 0.5422, 0.5402, 0.5381, 0.0227, 0.1505, 0.0062, 0.1509],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "163000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 41, 40, 26, 45, 31, 40, 40, 40, 40, 40, 40, 26, 27, 40, 40, 41, 40,\n", + " 40, 33, 41, 26, 40, 40, 40])\n", + "loss= tensor(1832.1873, grad_fn=) , actor= tensor(195.7904, grad_fn=) , critic= tensor(16363.9678, grad_fn=) , return= 175574.12777369528\n", + "probs of actions: tensor([0.1698, 0.1482, 0.5510, 0.1697, 0.0032, 0.0142, 0.5641, 0.5663, 0.5677,\n", + " 0.5685, 0.5689, 0.5689, 0.1717, 0.0299, 0.5665, 0.5651, 0.1376, 0.5621,\n", + " 0.5604, 0.0244, 0.1372, 0.1777, 0.5524, 0.5497, 0.5481],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "164000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 26, 40, 40, 26, 40, 40, 41, 40, 26, 40, 40, 40, 40, 26, 40, 41, 26,\n", + " 41, 40, 40, 33, 42, 40, 40])\n", + "loss= tensor(1783.5676, grad_fn=) , actor= tensor(156.7158, grad_fn=) , critic= tensor(16268.5176, grad_fn=) , return= 175284.21246672017\n", + "probs of actions: tensor([0.0536, 0.1850, 0.4586, 0.4625, 0.1856, 0.4675, 0.4703, 0.1788, 0.4731,\n", + " 0.1874, 0.4740, 0.4744, 0.4742, 0.4737, 0.1900, 0.4719, 0.1730, 0.1918,\n", + " 0.1727, 0.4653, 0.4640, 0.0315, 0.0264, 0.4589, 0.4575],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "165000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 26, 40, 41, 26, 40, 41, 41, 26, 27, 40, 26, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 26, 27, 40, 40])\n", + "loss= tensor(1783.1741, grad_fn=) , actor= tensor(151.8043, grad_fn=) , critic= tensor(16313.6973, grad_fn=) , return= 175373.71760378085\n", + "probs of actions: tensor([0.5183, 0.5287, 0.1544, 0.5374, 0.1268, 0.1538, 0.5473, 0.1244, 0.1237,\n", + " 0.1544, 0.0600, 0.5528, 0.1558, 0.5517, 0.5510, 0.5501, 0.5486, 0.5468,\n", + " 0.5450, 0.5430, 0.5410, 0.1604, 0.0626, 0.5340, 0.5316],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "166000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 41, 41, 40, 26, 26, 40, 26, 40, 41, 26, 47, 40, 40, 27, 45, 26, 40,\n", + " 31, 41, 40, 42, 40, 47, 41])\n", + "loss= tensor(1839.5549, grad_fn=) , actor= tensor(222.4634, grad_fn=) , critic= tensor(16170.9141, grad_fn=) , return= 174784.08718165575\n", + "probs of actions: tensor([0.4810, 0.1817, 0.1815, 0.4990, 0.1387, 0.1381, 0.5075, 0.1387, 0.5108,\n", + " 0.1769, 0.1395, 0.0259, 0.5125, 0.5121, 0.0571, 0.0020, 0.1425, 0.5076,\n", + " 0.0111, 0.1722, 0.5019, 0.0295, 0.4987, 0.0285, 0.1702],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "167000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 40, 27, 27, 40, 41, 40, 40, 26, 26, 40, 41, 40, 40, 26, 40, 41, 40,\n", + " 41, 41, 26, 40, 40, 41, 27])\n", + "loss= tensor(1819.2957, grad_fn=) , actor= tensor(175.1033, grad_fn=) , critic= tensor(16441.9238, grad_fn=) , return= 176233.82998489548\n", + "probs of actions: tensor([0.1727, 0.5466, 0.0559, 0.0554, 0.5586, 0.1666, 0.5643, 0.5661, 0.1011,\n", + " 0.1011, 0.5682, 0.1624, 0.5680, 0.5672, 0.1033, 0.5646, 0.1603, 0.5611,\n", + " 0.1599, 0.1596, 0.1068, 0.5529, 0.5499, 0.1588, 0.0571],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "168000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 27, 40, 40, 41, 15, 40, 41, 40, 26, 42, 40,\n", + " 41, 41, 41, 40, 40, 41, 33])\n", + "loss= tensor(1822.7017, grad_fn=) , actor= tensor(176.1692, grad_fn=) , critic= tensor(16465.3242, grad_fn=) , return= 176311.08940041385\n", + "probs of actions: tensor([6.2581e-01, 6.3640e-01, 6.4128e-01, 6.4532e-01, 6.4882e-01, 6.5173e-01,\n", + " 6.5407e-01, 3.5064e-02, 6.5684e-01, 6.5810e-01, 1.5045e-01, 2.9266e-04,\n", + " 6.5635e-01, 1.4901e-01, 6.5517e-01, 8.4492e-02, 2.0835e-02, 6.4954e-01,\n", + " 1.4843e-01, 1.4839e-01, 1.4838e-01, 6.4160e-01, 6.3940e-01, 1.4846e-01,\n", + " 1.8527e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "169000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 41, 41, 40, 40, 41, 40, 41, 27, 40, 40, 40, 40, 40, 26, 41, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1783.5663, grad_fn=) , actor= tensor(122.0094, grad_fn=) , critic= tensor(16615.5684, grad_fn=) , return= 176755.54804074854\n", + "probs of actions: tensor([0.6984, 0.1599, 0.1585, 0.7174, 0.7209, 0.1546, 0.7264, 0.1522, 0.0177,\n", + " 0.7305, 0.7314, 0.7314, 0.7311, 0.7305, 0.0582, 0.1483, 0.7268, 0.7254,\n", + " 0.7237, 0.7220, 0.7202, 0.7183, 0.7164, 0.7145, 0.7126],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "170000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 41, 40, 41, 40, 40, 40, 41, 27, 40, 40, 40, 26, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 41, 40])\n", + "loss= tensor(1768.3745, grad_fn=) , actor= tensor(108.4962, grad_fn=) , critic= tensor(16598.7832, grad_fn=) , return= 176699.68420092599\n", + "probs of actions: tensor([0.7659, 0.7759, 0.1195, 0.7844, 0.1166, 0.7907, 0.7931, 0.7950, 0.1123,\n", + " 0.0138, 0.7973, 0.7976, 0.7972, 0.0413, 0.7954, 0.7944, 0.7933, 0.7917,\n", + " 0.7901, 0.7883, 0.7866, 0.7847, 0.7829, 0.1122, 0.7791],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "171000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 40, 40, 40, 40, 40, 40, 40, 40, 40, 26, 41, 40, 26, 40, 40, 40, 40,\n", + " 40, 33, 47, 40, 40, 40, 40])\n", + "loss= tensor(1765.5317, grad_fn=) , actor= tensor(116.9100, grad_fn=) , critic= tensor(16486.2168, grad_fn=) , return= 176274.72712499282\n", + "probs of actions: tensor([0.0473, 0.7811, 0.7858, 0.7893, 0.7924, 0.7949, 0.7969, 0.7986, 0.7997,\n", + " 0.8003, 0.0433, 0.1112, 0.7996, 0.0443, 0.7976, 0.7962, 0.7948, 0.7931,\n", + " 0.7914, 0.0065, 0.0159, 0.7853, 0.7841, 0.7820, 0.7800],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "172000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1698.4899, grad_fn=) , actor= tensor(21.3196, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.8217, 0.8296, 0.8336, 0.8370, 0.8398, 0.8420, 0.8438, 0.8452, 0.8461,\n", + " 0.8466, 0.8466, 0.8463, 0.8458, 0.8449, 0.8439, 0.8427, 0.8413, 0.8396,\n", + " 0.8378, 0.8361, 0.8343, 0.8324, 0.8306, 0.8288, 0.8269],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "173000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 26, 40, 40, 40, 40])\n", + "loss= tensor(1713.3519, grad_fn=) , actor= tensor(40.2122, grad_fn=) , critic= tensor(16731.3965, grad_fn=) , return= 177138.79585040457\n", + "probs of actions: tensor([0.9240, 0.9283, 0.9310, 0.9332, 0.9349, 0.9363, 0.9375, 0.9384, 0.9389,\n", + " 0.9392, 0.0318, 0.9391, 0.9388, 0.9383, 0.9377, 0.9370, 0.9362, 0.9352,\n", + " 0.9342, 0.9331, 0.0173, 0.9310, 0.9293, 0.9284, 0.9274],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "174000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 45, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1731.3750, grad_fn=) , actor= tensor(53.0585, grad_fn=) , critic= tensor(16783.1641, grad_fn=) , return= 177482.95067308572\n", + "probs of actions: tensor([9.3725e-01, 9.4093e-01, 9.4331e-01, 9.4524e-01, 9.4680e-01, 9.4810e-01,\n", + " 9.4915e-01, 9.4990e-01, 9.5038e-01, 9.5063e-01, 9.5067e-01, 9.5054e-01,\n", + " 9.5027e-01, 9.4986e-01, 1.0446e-04, 9.4870e-01, 9.4810e-01, 9.4722e-01,\n", + " 9.4631e-01, 9.4537e-01, 9.4440e-01, 9.4344e-01, 9.4248e-01, 9.4151e-01,\n", + " 9.4053e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "175000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1681.2494, grad_fn=) , actor= tensor(4.0791, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9597, 0.9623, 0.9641, 0.9656, 0.9668, 0.9678, 0.9686, 0.9692, 0.9695,\n", + " 0.9698, 0.9698, 0.9698, 0.9696, 0.9693, 0.9690, 0.9686, 0.9681, 0.9676,\n", + " 0.9670, 0.9664, 0.9657, 0.9650, 0.9644, 0.9637, 0.9630],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "176000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1679.7400, grad_fn=) , actor= tensor(2.5697, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9739, 0.9758, 0.9771, 0.9781, 0.9789, 0.9797, 0.9802, 0.9806, 0.9808,\n", + " 0.9810, 0.9810, 0.9810, 0.9809, 0.9807, 0.9805, 0.9802, 0.9799, 0.9795,\n", + " 0.9791, 0.9786, 0.9782, 0.9777, 0.9773, 0.9768, 0.9763],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "177000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 41, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1709.6743, grad_fn=) , actor= tensor(32.0133, grad_fn=) , critic= tensor(16776.6094, grad_fn=) , return= 177445.17195993662\n", + "probs of actions: tensor([0.9786, 0.9801, 0.9812, 0.9821, 0.9828, 0.0099, 0.9838, 0.9841, 0.9843,\n", + " 0.9844, 0.9844, 0.9844, 0.9842, 0.9841, 0.9839, 0.9836, 0.9833, 0.9830,\n", + " 0.9826, 0.9822, 0.9818, 0.9814, 0.9810, 0.9806, 0.9801],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "178000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1681.4163, grad_fn=) , actor= tensor(4.2460, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9594, 0.9619, 0.9636, 0.9649, 0.9660, 0.9668, 0.9675, 0.9680, 0.9683,\n", + " 0.9684, 0.9684, 0.9683, 0.9680, 0.9677, 0.9673, 0.9668, 0.9662, 0.9656,\n", + " 0.9649, 0.9642, 0.9635, 0.9627, 0.9620, 0.9613, 0.9605],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "179000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1681.0416, grad_fn=) , actor= tensor(3.8714, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9631, 0.9654, 0.9669, 0.9681, 0.9691, 0.9699, 0.9705, 0.9709, 0.9711,\n", + " 0.9712, 0.9712, 0.9710, 0.9708, 0.9704, 0.9700, 0.9696, 0.9690, 0.9684,\n", + " 0.9677, 0.9671, 0.9664, 0.9657, 0.9649, 0.9642, 0.9635],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "180000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 27, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1707.4657, grad_fn=) , actor= tensor(39.2841, grad_fn=) , critic= tensor(16681.8164, grad_fn=) , return= 177082.22192801943\n", + "probs of actions: tensor([0.9767, 0.9782, 0.9793, 0.9802, 0.9809, 0.9815, 0.9819, 0.0028, 0.9823,\n", + " 0.9823, 0.9823, 0.9822, 0.9820, 0.9818, 0.9815, 0.9812, 0.9808, 0.9803,\n", + " 0.9799, 0.9794, 0.9789, 0.9784, 0.9778, 0.9773, 0.9768],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "181000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.3868, grad_fn=) , actor= tensor(1.2166, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9877, 0.9885, 0.9892, 0.9898, 0.9902, 0.9905, 0.9908, 0.9910, 0.9911,\n", + " 0.9911, 0.9911, 0.9910, 0.9909, 0.9908, 0.9906, 0.9904, 0.9902, 0.9900,\n", + " 0.9897, 0.9894, 0.9891, 0.9888, 0.9885, 0.9882, 0.9879],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "182000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.2117, grad_fn=) , actor= tensor(1.0413, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9893, 0.9901, 0.9907, 0.9912, 0.9916, 0.9919, 0.9921, 0.9923, 0.9923,\n", + " 0.9924, 0.9924, 0.9923, 0.9922, 0.9921, 0.9920, 0.9918, 0.9917, 0.9914,\n", + " 0.9912, 0.9910, 0.9907, 0.9905, 0.9902, 0.9899, 0.9897],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "183000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.3103, grad_fn=) , actor= tensor(1.1400, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9884, 0.9893, 0.9899, 0.9904, 0.9908, 0.9911, 0.9914, 0.9915, 0.9916,\n", + " 0.9916, 0.9916, 0.9916, 0.9915, 0.9914, 0.9912, 0.9910, 0.9908, 0.9906,\n", + " 0.9904, 0.9901, 0.9898, 0.9895, 0.9893, 0.9890, 0.9887],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "184000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.6622, grad_fn=) , actor= tensor(1.4920, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9851, 0.9861, 0.9869, 0.9875, 0.9880, 0.9884, 0.9887, 0.9888, 0.9890,\n", + " 0.9890, 0.9890, 0.9889, 0.9888, 0.9886, 0.9885, 0.9882, 0.9880, 0.9877,\n", + " 0.9874, 0.9871, 0.9868, 0.9864, 0.9861, 0.9857, 0.9854],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "185000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.8478, grad_fn=) , actor= tensor(1.6774, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9831, 0.9843, 0.9852, 0.9859, 0.9864, 0.9869, 0.9872, 0.9875, 0.9876,\n", + " 0.9876, 0.9876, 0.9876, 0.9874, 0.9873, 0.9871, 0.9868, 0.9866, 0.9863,\n", + " 0.9860, 0.9856, 0.9852, 0.9849, 0.9845, 0.9841, 0.9837],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "186000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.1857, grad_fn=) , actor= tensor(1.0153, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9898, 0.9905, 0.9911, 0.9915, 0.9919, 0.9921, 0.9923, 0.9925, 0.9925,\n", + " 0.9926, 0.9925, 0.9925, 0.9924, 0.9923, 0.9921, 0.9919, 0.9918, 0.9916,\n", + " 0.9913, 0.9911, 0.9908, 0.9906, 0.9903, 0.9900, 0.9897],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "187000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.7488, grad_fn=) , actor= tensor(0.5785, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9941, 0.9945, 0.9949, 0.9951, 0.9954, 0.9955, 0.9957, 0.9957, 0.9958,\n", + " 0.9958, 0.9958, 0.9957, 0.9957, 0.9956, 0.9955, 0.9954, 0.9953, 0.9952,\n", + " 0.9950, 0.9949, 0.9947, 0.9946, 0.9944, 0.9942, 0.9941],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "188000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.8217, grad_fn=) , actor= tensor(0.6514, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9934, 0.9938, 0.9942, 0.9945, 0.9948, 0.9950, 0.9951, 0.9952, 0.9952,\n", + " 0.9953, 0.9952, 0.9952, 0.9951, 0.9951, 0.9950, 0.9948, 0.9947, 0.9946,\n", + " 0.9944, 0.9943, 0.9941, 0.9939, 0.9937, 0.9936, 0.9934],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "189000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.4650, grad_fn=) , actor= tensor(0.2947, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9969, 0.9971, 0.9973, 0.9975, 0.9976, 0.9977, 0.9978, 0.9978, 0.9979,\n", + " 0.9979, 0.9979, 0.9979, 0.9978, 0.9978, 0.9977, 0.9977, 0.9976, 0.9976,\n", + " 0.9975, 0.9974, 0.9973, 0.9972, 0.9971, 0.9970, 0.9970],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "190000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.6260, grad_fn=) , actor= tensor(1.4556, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9858, 0.9866, 0.9874, 0.9879, 0.9883, 0.9887, 0.9889, 0.9891, 0.9892,\n", + " 0.9892, 0.9892, 0.9891, 0.9890, 0.9888, 0.9886, 0.9884, 0.9882, 0.9879,\n", + " 0.9876, 0.9873, 0.9870, 0.9867, 0.9863, 0.9860, 0.9857],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "191000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1679.5273, grad_fn=) , actor= tensor(2.3570, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9774, 0.9786, 0.9796, 0.9804, 0.9810, 0.9815, 0.9819, 0.9821, 0.9823,\n", + " 0.9823, 0.9823, 0.9822, 0.9821, 0.9819, 0.9817, 0.9814, 0.9811, 0.9808,\n", + " 0.9804, 0.9800, 0.9796, 0.9791, 0.9787, 0.9783, 0.9779],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "192000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1678.3643, grad_fn=) , actor= tensor(1.1939, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9882, 0.9889, 0.9895, 0.9899, 0.9903, 0.9906, 0.9908, 0.9910, 0.9911,\n", + " 0.9911, 0.9911, 0.9911, 0.9910, 0.9909, 0.9907, 0.9906, 0.9904, 0.9902,\n", + " 0.9900, 0.9898, 0.9895, 0.9893, 0.9890, 0.9888, 0.9885],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "193000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.5890, grad_fn=) , actor= tensor(0.4187, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9956, 0.9959, 0.9962, 0.9964, 0.9966, 0.9967, 0.9968, 0.9969, 0.9969,\n", + " 0.9970, 0.9970, 0.9969, 0.9969, 0.9969, 0.9968, 0.9967, 0.9967, 0.9966,\n", + " 0.9965, 0.9964, 0.9963, 0.9962, 0.9961, 0.9960, 0.9958],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "194000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.4910, grad_fn=) , actor= tensor(0.3207, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9966, 0.9968, 0.9971, 0.9972, 0.9974, 0.9975, 0.9976, 0.9976, 0.9977,\n", + " 0.9977, 0.9977, 0.9977, 0.9976, 0.9976, 0.9976, 0.9975, 0.9974, 0.9974,\n", + " 0.9973, 0.9972, 0.9971, 0.9971, 0.9970, 0.9969, 0.9968],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "195000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.6536, grad_fn=) , actor= tensor(0.4833, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9949, 0.9953, 0.9956, 0.9958, 0.9960, 0.9962, 0.9963, 0.9964, 0.9964,\n", + " 0.9965, 0.9965, 0.9965, 0.9964, 0.9964, 0.9963, 0.9962, 0.9962, 0.9961,\n", + " 0.9960, 0.9959, 0.9958, 0.9956, 0.9955, 0.9954, 0.9953],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "196000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 26, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1708.3685, grad_fn=) , actor= tensor(40.6316, grad_fn=) , critic= tensor(16677.3691, grad_fn=) , return= 177042.01841294605\n", + "probs of actions: tensor([9.9534e-01, 9.9567e-01, 9.9597e-01, 9.9621e-01, 9.9640e-01, 9.9655e-01,\n", + " 9.9666e-01, 9.9673e-01, 9.9678e-01, 9.9680e-01, 9.9681e-01, 9.9679e-01,\n", + " 6.8827e-04, 9.9673e-01, 9.9664e-01, 9.9658e-01, 9.9651e-01, 9.9643e-01,\n", + " 9.9635e-01, 9.9625e-01, 9.9614e-01, 9.9603e-01, 9.9592e-01, 9.9581e-01,\n", + " 9.9569e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "197000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.5894, grad_fn=) , actor= tensor(0.4191, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9955, 0.9958, 0.9961, 0.9964, 0.9965, 0.9967, 0.9968, 0.9969, 0.9969,\n", + " 0.9969, 0.9970, 0.9969, 0.9969, 0.9969, 0.9968, 0.9968, 0.9967, 0.9966,\n", + " 0.9966, 0.9965, 0.9964, 0.9963, 0.9962, 0.9961, 0.9960],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "198000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.3210, grad_fn=) , actor= tensor(0.1508, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9983, 0.9985, 0.9986, 0.9987, 0.9988, 0.9988, 0.9989, 0.9989, 0.9989,\n", + " 0.9989, 0.9989, 0.9989, 0.9989, 0.9989, 0.9989, 0.9988, 0.9988, 0.9988,\n", + " 0.9988, 0.9987, 0.9987, 0.9986, 0.9986, 0.9985, 0.9985],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "199000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.3020, grad_fn=) , actor= tensor(0.1317, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9985, 0.9986, 0.9988, 0.9988, 0.9989, 0.9990, 0.9990, 0.9990, 0.9991,\n", + " 0.9991, 0.9991, 0.9991, 0.9991, 0.9990, 0.9990, 0.9990, 0.9990, 0.9989,\n", + " 0.9989, 0.9989, 0.9988, 0.9988, 0.9988, 0.9987, 0.9987],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "199675 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n", + " 40, 40, 40, 40, 40, 40, 40])\n", + "loss= tensor(1677.2588, grad_fn=) , actor= tensor(0.0885, grad_fn=) , critic= tensor(16771.7031, grad_fn=) , return= 177431.33359946805\n", + "probs of actions: tensor([0.9990, 0.9991, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994, 0.9994,\n", + " 0.9994, 0.9994, 0.9994, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9993,\n", + " 0.9993, 0.9992, 0.9992, 0.9992, 0.9992, 0.9991, 0.9991],\n", + " grad_fn=)\n", + "shouldBreak: True\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver(print_step=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hi'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# neuralNet.load(name=name)\n", + "\"hi\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'mean'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m prices \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(game\u001b[38;5;241m.\u001b[39mprices)\u001b[38;5;241m.\u001b[39mT\n\u001b[0;32m 4\u001b[0m demandPotential \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(game\u001b[38;5;241m.\u001b[39mdemandPotential)\u001b[38;5;241m.\u001b[39mT\n\u001b[1;32m----> 5\u001b[0m learning \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(\u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreturns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean\u001b[49m(axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m),columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mentry\u001b[39m\u001b[38;5;124m'\u001b[39m])\n", + "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'mean'" + ] + } + ], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-5.ipynb b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-5.ipynb new file mode 100644 index 0000000..1cd7a4b --- /dev/null +++ b/learningAgents/naive_policy_gradient/ActorCritic/simulations lr=10^-5.ipynb @@ -0,0 +1,8840 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningActorCritic import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from neuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 0.0000, 200.0000, 128.5000]), 0, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.00001)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 5, 11, 1, 10, 26, 33, 37, 20, 7, 16, 8, 43, 35, 17, 22, 44, 3, 31,\n", + " 37, 28, 1, 32, 35, 10, 22])\n", + "loss= tensor(1841.0200, grad_fn=) , actor= tensor(438.4904, grad_fn=) , critic= tensor(14025.2969, grad_fn=) , return= 163616.28649997927\n", + "probs of actions: tensor([0.0183, 0.0205, 0.0200, 0.0187, 0.0219, 0.0170, 0.0214, 0.0186, 0.0215,\n", + " 0.0189, 0.0192, 0.0231, 0.0206, 0.0177, 0.0174, 0.0219, 0.0222, 0.0219,\n", + " 0.0217, 0.0194, 0.0202, 0.0174, 0.0203, 0.0190, 0.0177],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "1000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 9, 28, 17, 42, 32, 49, 13, 38, 34, 3, 16, 18, 42, 31, 33, 31, 27, 19,\n", + " 4, 18, 23, 16, 42, 48, 8])\n", + "loss= tensor(1915.4424, grad_fn=) , actor= tensor(445.8429, grad_fn=) , critic= tensor(14695.9951, grad_fn=) , return= 167401.12935040085\n", + "probs of actions: tensor([0.0192, 0.0199, 0.0181, 0.0252, 0.0171, 0.0215, 0.0211, 0.0184, 0.0204,\n", + " 0.0225, 0.0191, 0.0188, 0.0250, 0.0218, 0.0172, 0.0219, 0.0188, 0.0194,\n", + " 0.0192, 0.0187, 0.0191, 0.0189, 0.0247, 0.0179, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "2000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 17, 37, 8, 29, 6, 2, 34, 26, 14, 9, 36, 41, 40, 48, 39, 23, 46,\n", + " 47, 35, 42, 34, 4, 1, 34])\n", + "loss= tensor(1928.5093, grad_fn=) , actor= tensor(448.4833, grad_fn=) , critic= tensor(14800.2598, grad_fn=) , return= 168003.9453300291\n", + "probs of actions: tensor([0.0193, 0.0182, 0.0215, 0.0193, 0.0216, 0.0250, 0.0217, 0.0205, 0.0222,\n", + " 0.0180, 0.0186, 0.0170, 0.0199, 0.0195, 0.0178, 0.0203, 0.0191, 0.0258,\n", + " 0.0206, 0.0204, 0.0244, 0.0206, 0.0193, 0.0201, 0.0207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "3000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 37, 16, 29, 23, 39, 7, 10, 16, 13, 17, 4, 20, 42, 29, 28, 44, 7,\n", + " 15, 26, 2, 9, 46, 8, 6])\n", + "loss= tensor(1821.1069, grad_fn=) , actor= tensor(432.0691, grad_fn=) , critic= tensor(13890.3779, grad_fn=) , return= 163521.44210654518\n", + "probs of actions: tensor([0.0215, 0.0217, 0.0186, 0.0216, 0.0193, 0.0203, 0.0211, 0.0188, 0.0189,\n", + " 0.0207, 0.0179, 0.0193, 0.0188, 0.0243, 0.0222, 0.0196, 0.0217, 0.0211,\n", + " 0.0192, 0.0225, 0.0220, 0.0182, 0.0253, 0.0190, 0.0251],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "4000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 25, 19, 4, 13, 30, 24, 17, 38, 11, 12, 49, 28, 47, 4, 10, 34, 3,\n", + " 5, 3, 25, 4, 17, 4, 3])\n", + "loss= tensor(1802.2604, grad_fn=) , actor= tensor(431.6848, grad_fn=) , critic= tensor(13705.7549, grad_fn=) , return= 162439.274742895\n", + "probs of actions: tensor([0.0218, 0.0187, 0.0194, 0.0190, 0.0211, 0.0171, 0.0188, 0.0180, 0.0181,\n", + " 0.0208, 0.0205, 0.0212, 0.0195, 0.0203, 0.0192, 0.0189, 0.0208, 0.0218,\n", + " 0.0186, 0.0217, 0.0197, 0.0193, 0.0175, 0.0194, 0.0215],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "5000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 7, 1, 32, 27, 35, 11, 27, 42, 15, 29, 7, 10, 43, 20, 17, 42, 20,\n", + " 41, 38, 5, 28, 19, 47, 12])\n", + "loss= tensor(1883.2595, grad_fn=) , actor= tensor(442.7367, grad_fn=) , critic= tensor(14405.2275, grad_fn=) , return= 165999.28424226813\n", + "probs of actions: tensor([0.0204, 0.0212, 0.0203, 0.0170, 0.0193, 0.0206, 0.0208, 0.0191, 0.0245,\n", + " 0.0194, 0.0217, 0.0210, 0.0188, 0.0233, 0.0187, 0.0177, 0.0242, 0.0188,\n", + " 0.0192, 0.0183, 0.0187, 0.0195, 0.0198, 0.0204, 0.0205],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "6000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 3, 39, 18, 46, 1, 17, 28, 14, 7, 20, 8, 19, 35, 35, 42, 13, 30,\n", + " 46, 16, 18, 36, 40, 45, 15])\n", + "loss= tensor(1874.8060, grad_fn=) , actor= tensor(441.5386, grad_fn=) , critic= tensor(14332.6748, grad_fn=) , return= 165751.44643155174\n", + "probs of actions: tensor([0.0208, 0.0229, 0.0205, 0.0191, 0.0266, 0.0206, 0.0182, 0.0196, 0.0179,\n", + " 0.0210, 0.0188, 0.0191, 0.0193, 0.0205, 0.0206, 0.0238, 0.0207, 0.0170,\n", + " 0.0258, 0.0188, 0.0191, 0.0171, 0.0205, 0.0216, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "7000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 2, 46, 43, 27, 13, 36, 13, 6, 45, 12, 33, 41, 3, 28, 31, 40, 44,\n", + " 27, 41, 34, 6, 0, 5, 37])\n", + "loss= tensor(1900.0621, grad_fn=) , actor= tensor(439.0699, grad_fn=) , critic= tensor(14609.9219, grad_fn=) , return= 166266.6478999277\n", + "probs of actions: tensor([0.0208, 0.0212, 0.0267, 0.0236, 0.0195, 0.0210, 0.0173, 0.0209, 0.0244,\n", + " 0.0213, 0.0207, 0.0173, 0.0195, 0.0218, 0.0194, 0.0222, 0.0202, 0.0215,\n", + " 0.0192, 0.0191, 0.0204, 0.0246, 0.0205, 0.0185, 0.0220],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "8000 adversary: AdversaryModes.myopic\n", + " actions: tensor([19, 11, 25, 21, 19, 18, 28, 5, 12, 25, 20, 0, 36, 13, 4, 13, 32, 10,\n", + " 1, 22, 10, 0, 10, 0, 18])\n", + "loss= tensor(1730.1833, grad_fn=) , actor= tensor(423.2611, grad_fn=) , critic= tensor(13069.2227, grad_fn=) , return= 159244.5191206299\n", + "probs of actions: tensor([0.0192, 0.0209, 0.0189, 0.0171, 0.0192, 0.0189, 0.0197, 0.0187, 0.0205,\n", + " 0.0191, 0.0188, 0.0206, 0.0172, 0.0206, 0.0191, 0.0206, 0.0171, 0.0188,\n", + " 0.0207, 0.0176, 0.0188, 0.0203, 0.0188, 0.0203, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "9000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 24, 30, 15, 35, 49, 37, 16, 43, 26, 39, 48, 46, 23, 16, 43, 13, 2,\n", + " 16, 2, 23, 15, 19, 43, 30])\n", + "loss= tensor(1928.3333, grad_fn=) , actor= tensor(442.6327, grad_fn=) , critic= tensor(14857.0059, grad_fn=) , return= 167751.0460719431\n", + "probs of actions: tensor([0.0207, 0.0188, 0.0173, 0.0192, 0.0205, 0.0215, 0.0218, 0.0190, 0.0237,\n", + " 0.0225, 0.0208, 0.0179, 0.0265, 0.0194, 0.0192, 0.0232, 0.0206, 0.0214,\n", + " 0.0193, 0.0215, 0.0191, 0.0193, 0.0195, 0.0225, 0.0169],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "10000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 40, 29, 29, 13, 16, 47, 41, 28, 36, 14, 11, 9, 31, 45, 45, 20, 3,\n", + " 32, 32, 45, 37, 38, 31, 23])\n", + "loss= tensor(1965.2454, grad_fn=) , actor= tensor(455.0303, grad_fn=) , critic= tensor(15102.1504, grad_fn=) , return= 169986.19309467057\n", + "probs of actions: tensor([0.0197, 0.0189, 0.0211, 0.0212, 0.0211, 0.0192, 0.0203, 0.0199, 0.0197,\n", + " 0.0173, 0.0174, 0.0209, 0.0189, 0.0220, 0.0218, 0.0218, 0.0187, 0.0212,\n", + " 0.0171, 0.0171, 0.0219, 0.0220, 0.0188, 0.0224, 0.0191],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "11000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 39, 40, 26, 8, 19, 13, 30, 38, 34, 28, 33, 39, 5, 9, 41, 28, 2,\n", + " 39, 21, 23, 6, 45, 24, 46])\n", + "loss= tensor(1885.0649, grad_fn=) , actor= tensor(442.0079, grad_fn=) , critic= tensor(14430.5693, grad_fn=) , return= 166053.59068675802\n", + "probs of actions: tensor([0.0204, 0.0203, 0.0189, 0.0220, 0.0191, 0.0192, 0.0212, 0.0170, 0.0184,\n", + " 0.0204, 0.0196, 0.0177, 0.0203, 0.0188, 0.0187, 0.0193, 0.0193, 0.0213,\n", + " 0.0203, 0.0175, 0.0191, 0.0246, 0.0219, 0.0187, 0.0257],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "12000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 29, 28, 39, 20, 38, 15, 2, 21, 27, 20, 42, 29, 41, 36, 43, 16, 11,\n", + " 36, 48, 12, 8, 9, 46, 41])\n", + "loss= tensor(1908.7898, grad_fn=) , actor= tensor(443.9398, grad_fn=) , critic= tensor(14648.5000, grad_fn=) , return= 167051.1810766661\n", + "probs of actions: tensor([0.0240, 0.0213, 0.0196, 0.0203, 0.0185, 0.0184, 0.0193, 0.0213, 0.0169,\n", + " 0.0190, 0.0187, 0.0238, 0.0220, 0.0195, 0.0174, 0.0231, 0.0188, 0.0210,\n", + " 0.0173, 0.0182, 0.0203, 0.0188, 0.0184, 0.0255, 0.0188],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "13000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 14, 1, 6, 48, 40, 3, 13, 30, 36, 5, 3, 29, 38, 8, 41, 45, 18,\n", + " 2, 2, 4, 31, 47, 41, 9])\n", + "loss= tensor(1787.9695, grad_fn=) , actor= tensor(429.3466, grad_fn=) , critic= tensor(13586.2275, grad_fn=) , return= 161345.56800325614\n", + "probs of actions: tensor([0.0265, 0.0171, 0.0202, 0.0244, 0.0178, 0.0193, 0.0218, 0.0213, 0.0170,\n", + " 0.0176, 0.0188, 0.0214, 0.0219, 0.0185, 0.0190, 0.0193, 0.0218, 0.0187,\n", + " 0.0215, 0.0215, 0.0191, 0.0220, 0.0210, 0.0188, 0.0185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "14000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 14, 15, 22, 2, 9, 30, 0, 39, 45, 5, 35, 29, 40, 14, 14, 13, 7,\n", + " 42, 30, 1, 18, 23, 39, 2])\n", + "loss= tensor(1822.8562, grad_fn=) , actor= tensor(438.0766, grad_fn=) , critic= tensor(13847.7969, grad_fn=) , return= 163206.38262850035\n", + "probs of actions: tensor([0.0175, 0.0171, 0.0194, 0.0172, 0.0213, 0.0191, 0.0170, 0.0199, 0.0203,\n", + " 0.0216, 0.0188, 0.0206, 0.0220, 0.0200, 0.0177, 0.0177, 0.0210, 0.0209,\n", + " 0.0238, 0.0169, 0.0202, 0.0187, 0.0190, 0.0202, 0.0217],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "15000 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 33, 39, 40, 41, 47, 4, 15, 18, 7, 34, 18, 0, 44, 43, 7, 36, 44,\n", + " 35, 12, 46, 47, 1, 37, 3])\n", + "loss= tensor(1897.0870, grad_fn=) , actor= tensor(444.8632, grad_fn=) , critic= tensor(14522.2383, grad_fn=) , return= 167070.94416338188\n", + "probs of actions: tensor([0.0212, 0.0176, 0.0205, 0.0190, 0.0203, 0.0203, 0.0189, 0.0192, 0.0191,\n", + " 0.0207, 0.0209, 0.0190, 0.0200, 0.0214, 0.0230, 0.0207, 0.0174, 0.0214,\n", + " 0.0206, 0.0203, 0.0259, 0.0210, 0.0202, 0.0219, 0.0208],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "16000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 8, 22, 23, 28, 32, 4, 9, 39, 17, 35, 45, 14, 24, 19, 17, 37, 34,\n", + " 22, 49, 24, 46, 20, 7, 8])\n", + "loss= tensor(1933.6365, grad_fn=) , actor= tensor(454.6879, grad_fn=) , critic= tensor(14789.4854, grad_fn=) , return= 168418.9950107892\n", + "probs of actions: tensor([0.0191, 0.0197, 0.0172, 0.0196, 0.0192, 0.0171, 0.0189, 0.0189, 0.0204,\n", + " 0.0184, 0.0208, 0.0215, 0.0172, 0.0188, 0.0195, 0.0181, 0.0219, 0.0209,\n", + " 0.0177, 0.0212, 0.0189, 0.0257, 0.0189, 0.0211, 0.0191],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "17000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 2, 6, 10, 7, 28, 48, 46, 32, 41, 18, 6, 4, 37, 24, 3, 8, 14,\n", + " 28, 20, 34, 43, 20, 8, 26])\n", + "loss= tensor(1832.6095, grad_fn=) , actor= tensor(434.6769, grad_fn=) , critic= tensor(13979.3262, grad_fn=) , return= 163375.21154336008\n", + "probs of actions: tensor([0.0215, 0.0209, 0.0241, 0.0187, 0.0209, 0.0193, 0.0178, 0.0268, 0.0171,\n", + " 0.0199, 0.0189, 0.0241, 0.0192, 0.0218, 0.0191, 0.0211, 0.0189, 0.0174,\n", + " 0.0190, 0.0188, 0.0210, 0.0226, 0.0188, 0.0189, 0.0222],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "18000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 47, 30, 18, 34, 25, 37, 18, 31, 11, 9, 20, 27, 7, 8, 37, 0, 32,\n", + " 46, 47, 7, 20, 25, 19, 1])\n", + "loss= tensor(1886.5879, grad_fn=) , actor= tensor(444.3498, grad_fn=) , critic= tensor(14422.3809, grad_fn=) , return= 166901.9263648142\n", + "probs of actions: tensor([0.0191, 0.0199, 0.0171, 0.0189, 0.0208, 0.0192, 0.0216, 0.0188, 0.0214,\n", + " 0.0210, 0.0187, 0.0189, 0.0185, 0.0207, 0.0190, 0.0219, 0.0197, 0.0172,\n", + " 0.0262, 0.0210, 0.0207, 0.0190, 0.0199, 0.0199, 0.0197],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "19000 adversary: AdversaryModes.myopic\n", + " actions: tensor([11, 31, 25, 3, 49, 30, 24, 11, 35, 42, 25, 49, 21, 33, 28, 3, 1, 49,\n", + " 10, 29, 15, 19, 22, 32, 45])\n", + "loss= tensor(1860.6570, grad_fn=) , actor= tensor(436.6444, grad_fn=) , critic= tensor(14240.1260, grad_fn=) , return= 164613.2509887727\n", + "probs of actions: tensor([0.0208, 0.0209, 0.0190, 0.0219, 0.0221, 0.0170, 0.0192, 0.0210, 0.0212,\n", + " 0.0245, 0.0194, 0.0216, 0.0173, 0.0178, 0.0189, 0.0209, 0.0197, 0.0213,\n", + " 0.0192, 0.0222, 0.0194, 0.0197, 0.0177, 0.0171, 0.0218],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "20000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 3, 17, 39, 45, 8, 33, 13, 46, 21, 9, 41, 36, 41, 5, 43, 13, 32,\n", + " 49, 17, 48, 49, 16, 14, 38])\n", + "loss= tensor(1908.5088, grad_fn=) , actor= tensor(447.4297, grad_fn=) , critic= tensor(14610.7910, grad_fn=) , return= 166923.25892509386\n", + "probs of actions: tensor([0.0189, 0.0222, 0.0190, 0.0206, 0.0211, 0.0194, 0.0176, 0.0214, 0.0273,\n", + " 0.0174, 0.0187, 0.0196, 0.0174, 0.0194, 0.0192, 0.0234, 0.0211, 0.0171,\n", + " 0.0214, 0.0186, 0.0181, 0.0213, 0.0183, 0.0174, 0.0185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "21000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 8, 9, 22, 30, 35, 37, 20, 23, 43, 21, 13, 28, 0, 13, 24, 46, 2,\n", + " 49, 43, 13, 1, 5, 48, 29])\n", + "loss= tensor(1823.4005, grad_fn=) , actor= tensor(433.1458, grad_fn=) , critic= tensor(13902.5469, grad_fn=) , return= 163377.64076419594\n", + "probs of actions: tensor([0.0172, 0.0195, 0.0192, 0.0171, 0.0169, 0.0214, 0.0218, 0.0187, 0.0195,\n", + " 0.0238, 0.0173, 0.0213, 0.0191, 0.0196, 0.0212, 0.0189, 0.0263, 0.0211,\n", + " 0.0215, 0.0227, 0.0212, 0.0195, 0.0190, 0.0182, 0.0223],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "22000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 9, 23, 33, 23, 45, 22, 8, 31, 42, 37, 35, 40, 39, 8, 25, 13, 8, 34,\n", + " 7, 24, 28, 0, 29, 21, 10])\n", + "loss= tensor(1917.3474, grad_fn=) , actor= tensor(445.6436, grad_fn=) , critic= tensor(14717.0371, grad_fn=) , return= 167430.36083366\n", + "probs of actions: tensor([0.0194, 0.0196, 0.0177, 0.0196, 0.0212, 0.0171, 0.0192, 0.0210, 0.0247,\n", + " 0.0219, 0.0215, 0.0200, 0.0204, 0.0191, 0.0196, 0.0212, 0.0191, 0.0209,\n", + " 0.0206, 0.0190, 0.0189, 0.0194, 0.0220, 0.0179, 0.0192],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "23000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 39, 14, 49, 19, 34, 13, 0, 28, 5, 1, 7, 42, 31, 33, 30, 11, 47,\n", + " 35, 8, 14, 7, 19, 48, 27])\n", + "loss= tensor(1823.8759, grad_fn=) , actor= tensor(433.9156, grad_fn=) , critic= tensor(13899.6016, grad_fn=) , return= 163434.1037724541\n", + "probs of actions: tensor([0.0194, 0.0206, 0.0166, 0.0221, 0.0199, 0.0208, 0.0216, 0.0197, 0.0193,\n", + " 0.0191, 0.0198, 0.0206, 0.0246, 0.0213, 0.0180, 0.0167, 0.0212, 0.0205,\n", + " 0.0211, 0.0191, 0.0173, 0.0207, 0.0199, 0.0182, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "24000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 40, 42, 49, 33, 39, 21, 48, 0, 35, 24, 43, 44, 38, 26, 44, 35, 24,\n", + " 28, 27, 39, 44, 12, 6, 11])\n", + "loss= tensor(2058.6829, grad_fn=) , actor= tensor(464.6200, grad_fn=) , critic= tensor(15940.6279, grad_fn=) , return= 173603.72877182407\n", + "probs of actions: tensor([0.0191, 0.0196, 0.0245, 0.0221, 0.0180, 0.0205, 0.0173, 0.0180, 0.0195,\n", + " 0.0212, 0.0193, 0.0238, 0.0218, 0.0178, 0.0221, 0.0217, 0.0212, 0.0192,\n", + " 0.0192, 0.0186, 0.0203, 0.0217, 0.0203, 0.0241, 0.0211],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "25000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 21, 23, 37, 37, 33, 22, 45, 19, 13, 30, 17, 45, 33, 44, 5, 44, 29,\n", + " 43, 13, 11, 19, 23, 25, 6])\n", + "loss= tensor(1975.9393, grad_fn=) , actor= tensor(454.7791, grad_fn=) , critic= tensor(15211.6025, grad_fn=) , return= 170458.56906061425\n", + "probs of actions: tensor([0.0205, 0.0177, 0.0193, 0.0217, 0.0217, 0.0180, 0.0171, 0.0213, 0.0199,\n", + " 0.0217, 0.0168, 0.0185, 0.0216, 0.0182, 0.0218, 0.0191, 0.0217, 0.0219,\n", + " 0.0232, 0.0215, 0.0212, 0.0199, 0.0188, 0.0199, 0.0242],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "26000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 12, 0, 46, 23, 16, 48, 37, 21, 30, 10, 9, 34, 35, 48, 12, 38, 31,\n", + " 15, 42, 11, 22, 49, 34, 20])\n", + "loss= tensor(1920.7616, grad_fn=) , actor= tensor(448.5723, grad_fn=) , critic= tensor(14721.8936, grad_fn=) , return= 167418.42101552102\n", + "probs of actions: tensor([0.0205, 0.0209, 0.0197, 0.0277, 0.0191, 0.0187, 0.0182, 0.0219, 0.0175,\n", + " 0.0168, 0.0190, 0.0185, 0.0211, 0.0217, 0.0184, 0.0204, 0.0177, 0.0216,\n", + " 0.0192, 0.0241, 0.0212, 0.0179, 0.0211, 0.0209, 0.0188],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "27000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 15, 26, 25, 31, 26, 17, 26, 49, 39, 30, 11, 31, 8, 42, 28, 41,\n", + " 0, 28, 26, 6, 28, 42, 5])\n", + "loss= tensor(1888.3153, grad_fn=) , actor= tensor(441.7247, grad_fn=) , critic= tensor(14465.9053, grad_fn=) , return= 165576.94910312156\n", + "probs of actions: tensor([0.0195, 0.0195, 0.0193, 0.0221, 0.0189, 0.0211, 0.0222, 0.0187, 0.0223,\n", + " 0.0218, 0.0204, 0.0167, 0.0211, 0.0214, 0.0192, 0.0240, 0.0192, 0.0187,\n", + " 0.0193, 0.0194, 0.0224, 0.0241, 0.0193, 0.0236, 0.0189],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "28000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 4, 26, 38, 30, 6, 49, 0, 12, 44, 4, 2, 43, 19, 44, 36, 15, 26, 8,\n", + " 38, 41, 48, 34, 42, 29, 22])\n", + "loss= tensor(1872.0626, grad_fn=) , actor= tensor(443.5731, grad_fn=) , critic= tensor(14284.8945, grad_fn=) , return= 165555.9700239287\n", + "probs of actions: tensor([0.0185, 0.0221, 0.0176, 0.0171, 0.0240, 0.0220, 0.0194, 0.0201, 0.0215,\n", + " 0.0188, 0.0203, 0.0242, 0.0203, 0.0215, 0.0173, 0.0197, 0.0227, 0.0191,\n", + " 0.0179, 0.0185, 0.0185, 0.0209, 0.0235, 0.0219, 0.0176],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "29000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 19, 41, 27, 29, 39, 23, 10, 23, 48, 19, 27, 41, 2, 45, 12, 13, 16,\n", + " 4, 40, 14, 1, 2, 25, 6])\n", + "loss= tensor(1874.7354, grad_fn=) , actor= tensor(438.9819, grad_fn=) , critic= tensor(14357.5342, grad_fn=) , return= 165755.9838163509\n", + "probs of actions: tensor([0.0247, 0.0205, 0.0198, 0.0190, 0.0211, 0.0204, 0.0191, 0.0189, 0.0189,\n", + " 0.0182, 0.0204, 0.0186, 0.0188, 0.0203, 0.0219, 0.0201, 0.0213, 0.0189,\n", + " 0.0192, 0.0212, 0.0175, 0.0197, 0.0205, 0.0200, 0.0237],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "30000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 18, 46, 41, 6, 4, 41, 27, 19, 15, 12, 32, 47, 3, 14, 26, 41, 9,\n", + " 17, 46, 7, 44, 45, 21, 6])\n", + "loss= tensor(1659.1284, grad_fn=) , actor= tensor(409.4039, grad_fn=) , critic= tensor(12497.2441, grad_fn=) , return= 165843.63977476256\n", + "probs of actions: tensor([0.0188, 0.0185, 0.0277, 0.0197, 0.0235, 0.0187, 0.0196, 0.0190, 0.0200,\n", + " 0.0200, 0.0201, 0.0176, 0.0208, 0.0203, 0.0172, 0.0223, 0.0185, 0.0181,\n", + " 0.0182, 0.0270, 0.0203, 0.0214, 0.0220, 0.0182, 0.0234],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "31000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 43, 34, 39, 23, 9, 30, 22, 0, 13, 29, 34, 32, 44, 34, 48, 13, 24,\n", + " 2, 28, 37, 14, 3, 32, 31])\n", + "loss= tensor(1491.3158, grad_fn=) , actor= tensor(379.5098, grad_fn=) , critic= tensor(11118.0605, grad_fn=) , return= 167253.1760877543\n", + "probs of actions: tensor([0.0178, 0.0244, 0.0206, 0.0204, 0.0192, 0.0188, 0.0170, 0.0170, 0.0196,\n", + " 0.0218, 0.0216, 0.0210, 0.0176, 0.0217, 0.0210, 0.0185, 0.0215, 0.0188,\n", + " 0.0205, 0.0197, 0.0223, 0.0175, 0.0201, 0.0177, 0.0221],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "32000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 35, 22, 46, 42, 39, 13, 10, 4, 16, 28, 23, 47, 29, 24, 35, 13, 30,\n", + " 26, 15, 21, 15, 6, 4, 24])\n", + "loss= tensor(1307.8320, grad_fn=) , actor= tensor(344.6603, grad_fn=) , critic= tensor(9631.7168, grad_fn=) , return= 167681.11508826012\n", + "probs of actions: tensor([0.0211, 0.0217, 0.0167, 0.0276, 0.0241, 0.0205, 0.0217, 0.0185, 0.0184,\n", + " 0.0194, 0.0197, 0.0189, 0.0206, 0.0218, 0.0189, 0.0214, 0.0214, 0.0168,\n", + " 0.0222, 0.0203, 0.0179, 0.0202, 0.0231, 0.0188, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "33000 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 3, 26, 3, 46, 2, 3, 29, 1, 45, 43, 40, 41, 8, 4, 18, 34, 22,\n", + " 16, 2, 17, 3, 40, 26, 44])\n", + "loss= tensor(989.6292, grad_fn=) , actor= tensor(285.4749, grad_fn=) , critic= tensor(7041.5430, grad_fn=) , return= 158955.8309164098\n", + "probs of actions: tensor([0.0206, 0.0216, 0.0215, 0.0213, 0.0277, 0.0202, 0.0211, 0.0216, 0.0195,\n", + " 0.0217, 0.0239, 0.0204, 0.0190, 0.0192, 0.0187, 0.0186, 0.0213, 0.0174,\n", + " 0.0193, 0.0205, 0.0182, 0.0200, 0.0213, 0.0223, 0.0217],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "34000 adversary: AdversaryModes.myopic\n", + " actions: tensor([11, 43, 34, 4, 49, 45, 37, 23, 24, 35, 20, 9, 38, 16, 11, 2, 7, 11,\n", + " 20, 30, 16, 21, 23, 28, 3])\n", + "loss= tensor(909.7036, grad_fn=) , actor= tensor(268.7522, grad_fn=) , critic= tensor(6409.5132, grad_fn=) , return= 165811.346475109\n", + "probs of actions: tensor([0.0203, 0.0243, 0.0206, 0.0184, 0.0218, 0.0215, 0.0217, 0.0192, 0.0192,\n", + " 0.0215, 0.0188, 0.0184, 0.0180, 0.0191, 0.0206, 0.0205, 0.0203, 0.0207,\n", + " 0.0190, 0.0168, 0.0192, 0.0182, 0.0188, 0.0194, 0.0200],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "35000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 15, 47, 1, 4, 32, 49, 16, 13, 24, 2, 31, 14, 33, 31, 23, 12, 4,\n", + " 16, 38, 7, 10, 18, 26, 47])\n", + "loss= tensor(672.1748, grad_fn=) , actor= tensor(212.6306, grad_fn=) , critic= tensor(4595.4424, grad_fn=) , return= 160537.90697926408\n", + "probs of actions: tensor([0.0192, 0.0200, 0.0197, 0.0194, 0.0183, 0.0178, 0.0216, 0.0189, 0.0217,\n", + " 0.0191, 0.0204, 0.0216, 0.0173, 0.0182, 0.0218, 0.0191, 0.0199, 0.0186,\n", + " 0.0193, 0.0183, 0.0201, 0.0183, 0.0182, 0.0224, 0.0205],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "36000 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 18, 8, 41, 19, 18, 15, 1, 46, 21, 14, 5, 29, 23, 41, 40, 13, 48,\n", + " 7, 25, 14, 7, 34, 43, 4])\n", + "loss= tensor(533.7891, grad_fn=) , actor= tensor(177.6163, grad_fn=) , critic= tensor(3561.7288, grad_fn=) , return= 163829.68968062036\n", + "probs of actions: tensor([0.0206, 0.0182, 0.0193, 0.0202, 0.0201, 0.0182, 0.0199, 0.0192, 0.0277,\n", + " 0.0180, 0.0173, 0.0189, 0.0217, 0.0192, 0.0191, 0.0210, 0.0213, 0.0187,\n", + " 0.0198, 0.0198, 0.0177, 0.0200, 0.0210, 0.0229, 0.0184],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "37000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 12, 49, 49, 47, 39, 5, 16, 48, 20, 29, 29, 10, 20, 26, 24, 2, 20,\n", + " 39, 23, 39, 41, 42, 45, 49])\n", + "loss= tensor(434.5030, grad_fn=) , actor= tensor(137.7788, grad_fn=) , critic= tensor(2967.2422, grad_fn=) , return= 166445.08527129568\n", + "probs of actions: tensor([0.0180, 0.0205, 0.0218, 0.0217, 0.0199, 0.0210, 0.0191, 0.0192, 0.0185,\n", + " 0.0188, 0.0217, 0.0217, 0.0184, 0.0191, 0.0222, 0.0192, 0.0207, 0.0191,\n", + " 0.0209, 0.0192, 0.0209, 0.0184, 0.0245, 0.0221, 0.0209],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "38000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 25, 30, 1, 35, 28, 11, 10, 38, 30, 8, 5, 47, 17, 36, 36, 30, 6,\n", + " 39, 27, 26, 35, 32, 12, 15])\n", + "loss= tensor(314.4874, grad_fn=) , actor= tensor(99.3235, grad_fn=) , critic= tensor(2151.6387, grad_fn=) , return= 167573.53333659927\n", + "probs of actions: tensor([0.0213, 0.0190, 0.0173, 0.0190, 0.0216, 0.0196, 0.0200, 0.0183, 0.0178,\n", + " 0.0169, 0.0190, 0.0190, 0.0205, 0.0186, 0.0173, 0.0173, 0.0168, 0.0234,\n", + " 0.0208, 0.0186, 0.0222, 0.0213, 0.0178, 0.0196, 0.0195],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "39000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 31, 23, 38, 18, 33, 22, 32, 43, 43, 47, 20, 18, 45, 15, 44, 46, 3,\n", + " 14, 48, 45, 36, 31, 34, 0])\n", + "loss= tensor(275.4543, grad_fn=) , actor= tensor(75.1413, grad_fn=) , critic= tensor(2003.1295, grad_fn=) , return= 172185.8602933205\n", + "probs of actions: tensor([0.0209, 0.0212, 0.0197, 0.0177, 0.0183, 0.0179, 0.0169, 0.0177, 0.0243,\n", + " 0.0242, 0.0204, 0.0186, 0.0184, 0.0220, 0.0197, 0.0218, 0.0273, 0.0198,\n", + " 0.0176, 0.0186, 0.0222, 0.0174, 0.0219, 0.0212, 0.0191],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "40000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 28, 6, 8, 49, 3, 44, 23, 30, 39, 25, 1, 9, 48, 42, 39, 37, 12,\n", + " 25, 14, 7, 21, 45, 30, 23])\n", + "loss= tensor(183.9205, grad_fn=) , actor= tensor(22.8967, grad_fn=) , critic= tensor(1610.2380, grad_fn=) , return= 164693.85387563444\n", + "probs of actions: tensor([0.0201, 0.0197, 0.0237, 0.0193, 0.0219, 0.0204, 0.0218, 0.0198, 0.0173,\n", + " 0.0208, 0.0196, 0.0189, 0.0183, 0.0185, 0.0248, 0.0207, 0.0222, 0.0193,\n", + " 0.0199, 0.0177, 0.0197, 0.0181, 0.0224, 0.0171, 0.0195],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "41000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 43, 36, 15, 25, 11, 14, 5, 46, 21, 7, 37, 20, 14, 19, 31, 14, 37,\n", + " 49, 29, 13, 15, 34, 29, 36])\n", + "loss= tensor(170.4114, grad_fn=) , actor= tensor(7.7582, grad_fn=) , critic= tensor(1626.5325, grad_fn=) , return= 166086.17931114073\n", + "probs of actions: tensor([0.0180, 0.0241, 0.0180, 0.0196, 0.0193, 0.0201, 0.0170, 0.0193, 0.0282,\n", + " 0.0178, 0.0197, 0.0223, 0.0187, 0.0174, 0.0203, 0.0216, 0.0175, 0.0224,\n", + " 0.0213, 0.0225, 0.0215, 0.0195, 0.0211, 0.0228, 0.0174],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "42000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 49, 3, 35, 36, 28, 36, 49, 47, 18, 19, 26, 41, 25, 41, 27, 25, 5,\n", + " 9, 27, 8, 35, 17, 19, 36])\n", + "loss= tensor(195.5405, grad_fn=) , actor= tensor(7.5094, grad_fn=) , critic= tensor(1880.3108, grad_fn=) , return= 168518.11830023554\n", + "probs of actions: tensor([0.0178, 0.0220, 0.0207, 0.0217, 0.0179, 0.0197, 0.0178, 0.0216, 0.0203,\n", + " 0.0181, 0.0201, 0.0220, 0.0193, 0.0198, 0.0192, 0.0187, 0.0199, 0.0191,\n", + " 0.0181, 0.0186, 0.0190, 0.0214, 0.0185, 0.0204, 0.0174],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "43000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 16, 26, 35, 3, 43, 13, 31, 22, 23, 28, 27, 44, 1, 34, 8, 1, 48,\n", + " 2, 2, 10, 31, 13, 19, 47])\n", + "loss= tensor(159.0778, grad_fn=) , actor= tensor(-17.1848, grad_fn=) , critic= tensor(1762.6260, grad_fn=) , return= 160960.75612400635\n", + "probs of actions: tensor([0.0194, 0.0188, 0.0216, 0.0219, 0.0204, 0.0243, 0.0215, 0.0214, 0.0170,\n", + " 0.0196, 0.0197, 0.0187, 0.0219, 0.0187, 0.0214, 0.0190, 0.0187, 0.0185,\n", + " 0.0204, 0.0205, 0.0179, 0.0218, 0.0213, 0.0205, 0.0205],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "44000 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 37, 45, 33, 46, 19, 34, 43, 3, 44, 13, 40, 3, 22, 39, 34, 1, 39,\n", + " 20, 13, 31, 32, 47, 14, 15])\n", + "loss= tensor(168.7587, grad_fn=) , actor= tensor(5.1170, grad_fn=) , critic= tensor(1636.4167, grad_fn=) , return= 168299.2889690755\n", + "probs of actions: tensor([0.0201, 0.0223, 0.0217, 0.0181, 0.0284, 0.0205, 0.0212, 0.0240, 0.0199,\n", + " 0.0217, 0.0215, 0.0210, 0.0196, 0.0174, 0.0210, 0.0213, 0.0187, 0.0210,\n", + " 0.0187, 0.0214, 0.0219, 0.0175, 0.0206, 0.0179, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "45000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 45, 29, 26, 38, 4, 13, 14, 18, 39, 0, 8, 42, 24, 17, 30, 25, 16,\n", + " 0, 8, 40, 16, 6, 8, 1])\n", + "loss= tensor(158.5508, grad_fn=) , actor= tensor(-6.7261, grad_fn=) , critic= tensor(1652.7694, grad_fn=) , return= 164231.13739922878\n", + "probs of actions: tensor([0.0246, 0.0215, 0.0211, 0.0220, 0.0181, 0.0177, 0.0216, 0.0170, 0.0181,\n", + " 0.0210, 0.0182, 0.0190, 0.0250, 0.0197, 0.0188, 0.0168, 0.0203, 0.0187,\n", + " 0.0180, 0.0189, 0.0221, 0.0185, 0.0238, 0.0189, 0.0185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "46000 adversary: AdversaryModes.myopic\n", + " actions: tensor([14, 42, 44, 7, 47, 49, 19, 45, 10, 15, 49, 28, 37, 4, 33, 25, 49, 42,\n", + " 34, 22, 38, 32, 35, 34, 38])\n", + "loss= tensor(181.8573, grad_fn=) , actor= tensor(14.8150, grad_fn=) , critic= tensor(1670.4225, grad_fn=) , return= 169649.66140320848\n", + "probs of actions: tensor([0.0168, 0.0247, 0.0216, 0.0198, 0.0203, 0.0216, 0.0204, 0.0218, 0.0183,\n", + " 0.0195, 0.0213, 0.0196, 0.0225, 0.0178, 0.0178, 0.0202, 0.0211, 0.0242,\n", + " 0.0219, 0.0178, 0.0185, 0.0175, 0.0218, 0.0219, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "47000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 37, 46, 11, 21, 13, 36, 49, 3, 5, 0, 17, 49, 35, 3, 0, 43, 41,\n", + " 46, 6, 39, 36, 22, 13, 23])\n", + "loss= tensor(144.3128, grad_fn=) , actor= tensor(-3.2418, grad_fn=) , critic= tensor(1475.5464, grad_fn=) , return= 164752.38630558626\n", + "probs of actions: tensor([0.0181, 0.0223, 0.0285, 0.0200, 0.0171, 0.0216, 0.0180, 0.0214, 0.0194,\n", + " 0.0194, 0.0178, 0.0190, 0.0212, 0.0223, 0.0190, 0.0177, 0.0233, 0.0190,\n", + " 0.0275, 0.0235, 0.0211, 0.0177, 0.0180, 0.0213, 0.0193],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "48000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 14, 17, 36, 31, 32, 22, 20, 30, 1, 2, 2, 8, 48, 6, 42, 46, 1,\n", + " 40, 21, 20, 28, 19, 36, 8])\n", + "loss= tensor(141.5515, grad_fn=) , actor= tensor(-5.5010, grad_fn=) , critic= tensor(1470.5240, grad_fn=) , return= 164331.70570786938\n", + "probs of actions: tensor([0.0215, 0.0169, 0.0198, 0.0182, 0.0218, 0.0177, 0.0173, 0.0183, 0.0170,\n", + " 0.0185, 0.0201, 0.0201, 0.0191, 0.0181, 0.0234, 0.0248, 0.0278, 0.0185,\n", + " 0.0219, 0.0182, 0.0187, 0.0194, 0.0205, 0.0177, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "49000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 16, 49, 37, 35, 49, 14, 24, 46, 48, 31, 47, 5, 40, 7, 7, 1, 46,\n", + " 15, 35, 29, 17, 20, 44, 42])\n", + "loss= tensor(184.5074, grad_fn=) , actor= tensor(1.6765, grad_fn=) , critic= tensor(1828.3092, grad_fn=) , return= 166700.2658170475\n", + "probs of actions: tensor([0.0220, 0.0185, 0.0220, 0.0226, 0.0223, 0.0218, 0.0172, 0.0194, 0.0287,\n", + " 0.0181, 0.0220, 0.0206, 0.0196, 0.0215, 0.0196, 0.0198, 0.0184, 0.0277,\n", + " 0.0195, 0.0220, 0.0226, 0.0193, 0.0186, 0.0219, 0.0242],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "50000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 12, 14, 13, 33, 24, 35, 25, 21, 6, 35, 44, 12, 38, 40, 33, 47, 3,\n", + " 39, 13, 47, 10, 44, 36, 6])\n", + "loss= tensor(161.0556, grad_fn=) , actor= tensor(6.1217, grad_fn=) , critic= tensor(1549.3389, grad_fn=) , return= 167844.0506657742\n", + "probs of actions: tensor([0.0194, 0.0198, 0.0168, 0.0219, 0.0181, 0.0196, 0.0222, 0.0196, 0.0174,\n", + " 0.0228, 0.0221, 0.0219, 0.0193, 0.0181, 0.0218, 0.0184, 0.0206, 0.0186,\n", + " 0.0210, 0.0216, 0.0206, 0.0180, 0.0218, 0.0178, 0.0230],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "51000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 31, 42, 11, 21, 22, 27, 48, 40, 7, 37, 35, 38, 18, 34, 33, 6, 47,\n", + " 31, 43, 19, 5, 46, 7, 12])\n", + "loss= tensor(178.2914, grad_fn=) , actor= tensor(11.6150, grad_fn=) , critic= tensor(1666.7643, grad_fn=) , return= 169043.55358287552\n", + "probs of actions: tensor([0.0192, 0.0215, 0.0246, 0.0197, 0.0172, 0.0173, 0.0185, 0.0179, 0.0214,\n", + " 0.0197, 0.0232, 0.0221, 0.0180, 0.0181, 0.0233, 0.0184, 0.0227, 0.0208,\n", + " 0.0223, 0.0232, 0.0206, 0.0194, 0.0273, 0.0196, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "52000 adversary: AdversaryModes.myopic\n", + " actions: tensor([19, 8, 12, 36, 12, 33, 13, 26, 17, 43, 39, 8, 18, 12, 29, 7, 7, 49,\n", + " 17, 15, 5, 23, 30, 48, 13])\n", + "loss= tensor(148.6699, grad_fn=) , actor= tensor(-9.2286, grad_fn=) , critic= tensor(1578.9846, grad_fn=) , return= 163228.46314106006\n", + "probs of actions: tensor([0.0202, 0.0192, 0.0195, 0.0183, 0.0194, 0.0182, 0.0217, 0.0219, 0.0196,\n", + " 0.0243, 0.0212, 0.0191, 0.0182, 0.0191, 0.0226, 0.0195, 0.0196, 0.0214,\n", + " 0.0192, 0.0195, 0.0193, 0.0185, 0.0170, 0.0183, 0.0214],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "53000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 10, 11, 46, 25, 29, 25, 22, 49, 28, 31, 20, 7, 5, 9, 49, 40, 23,\n", + " 4, 49, 20, 10, 8, 33, 37])\n", + "loss= tensor(163.3779, grad_fn=) , actor= tensor(-6.3010, grad_fn=) , critic= tensor(1696.7886, grad_fn=) , return= 164279.33761105852\n", + "probs of actions: tensor([0.0198, 0.0177, 0.0195, 0.0288, 0.0194, 0.0220, 0.0195, 0.0173, 0.0213,\n", + " 0.0197, 0.0221, 0.0185, 0.0195, 0.0191, 0.0179, 0.0212, 0.0224, 0.0186,\n", + " 0.0178, 0.0211, 0.0187, 0.0179, 0.0189, 0.0188, 0.0235],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "54000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 42, 18, 34, 30, 21, 22, 35, 36, 19, 33, 47, 41, 28, 48, 35, 8, 26,\n", + " 21, 15, 49, 39, 0, 28, 42])\n", + "loss= tensor(197.3581, grad_fn=) , actor= tensor(10.7786, grad_fn=) , critic= tensor(1865.7949, grad_fn=) , return= 169925.1875110434\n", + "probs of actions: tensor([0.0212, 0.0244, 0.0179, 0.0228, 0.0173, 0.0172, 0.0174, 0.0218, 0.0181,\n", + " 0.0203, 0.0187, 0.0211, 0.0193, 0.0196, 0.0182, 0.0218, 0.0192, 0.0223,\n", + " 0.0177, 0.0195, 0.0209, 0.0211, 0.0167, 0.0196, 0.0239],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "55000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 33, 46, 38, 47, 11, 39, 6, 24, 31, 11, 13, 34, 13, 20, 5, 45, 38,\n", + " 7, 3, 27, 26, 20, 38, 49])\n", + "loss= tensor(171.9998, grad_fn=) , actor= tensor(-8.8947, grad_fn=) , critic= tensor(1808.9449, grad_fn=) , return= 164414.8314343879\n", + "probs of actions: tensor([0.0180, 0.0191, 0.0287, 0.0181, 0.0207, 0.0195, 0.0217, 0.0225, 0.0195,\n", + " 0.0220, 0.0196, 0.0217, 0.0236, 0.0217, 0.0184, 0.0194, 0.0222, 0.0182,\n", + " 0.0193, 0.0180, 0.0182, 0.0222, 0.0186, 0.0184, 0.0207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "56000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 11, 39, 14, 42, 39, 22, 25, 18, 33, 24, 40, 42, 6, 39, 45, 4, 40,\n", + " 27, 11, 18, 48, 33, 3, 25])\n", + "loss= tensor(178.8660, grad_fn=) , actor= tensor(7.8844, grad_fn=) , critic= tensor(1709.8162, grad_fn=) , return= 168875.12754362615\n", + "probs of actions: tensor([0.0217, 0.0194, 0.0219, 0.0170, 0.0249, 0.0218, 0.0173, 0.0201, 0.0178,\n", + " 0.0187, 0.0198, 0.0223, 0.0244, 0.0223, 0.0216, 0.0223, 0.0174, 0.0229,\n", + " 0.0181, 0.0197, 0.0178, 0.0183, 0.0191, 0.0180, 0.0207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "57000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 38, 39, 20, 46, 5, 29, 37, 25, 29, 21, 13, 12, 7, 36, 24, 46, 9,\n", + " 31, 14, 33, 15, 12, 0, 40])\n", + "loss= tensor(175.9867, grad_fn=) , actor= tensor(-3.8084, grad_fn=) , critic= tensor(1797.9515, grad_fn=) , return= 166185.60936823874\n", + "probs of actions: tensor([0.0187, 0.0182, 0.0218, 0.0178, 0.0293, 0.0195, 0.0222, 0.0231, 0.0201,\n", + " 0.0225, 0.0171, 0.0216, 0.0185, 0.0191, 0.0179, 0.0198, 0.0284, 0.0178,\n", + " 0.0223, 0.0175, 0.0189, 0.0198, 0.0185, 0.0163, 0.0233],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "58000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 46, 41, 34, 45, 46, 32, 0, 11, 17, 32, 18, 12, 14, 44, 49, 5, 20,\n", + " 21, 21, 20, 17, 2, 21, 43])\n", + "loss= tensor(182.1005, grad_fn=) , actor= tensor(-3.2656, grad_fn=) , critic= tensor(1853.6617, grad_fn=) , return= 165672.68771371376\n", + "probs of actions: tensor([0.0218, 0.0289, 0.0202, 0.0225, 0.0220, 0.0293, 0.0186, 0.0165, 0.0194,\n", + " 0.0194, 0.0186, 0.0178, 0.0183, 0.0173, 0.0226, 0.0208, 0.0195, 0.0185,\n", + " 0.0175, 0.0176, 0.0185, 0.0191, 0.0194, 0.0176, 0.0235],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "59000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 40, 17, 31, 36, 37, 46, 15, 21, 38, 23, 37, 49, 27, 5, 47, 4, 35,\n", + " 42, 49, 39, 39, 38, 9, 24])\n", + "loss= tensor(179.4053, grad_fn=) , actor= tensor(16.3394, grad_fn=) , critic= tensor(1630.6589, grad_fn=) , return= 171373.3976270093\n", + "probs of actions: tensor([0.0181, 0.0214, 0.0199, 0.0219, 0.0184, 0.0229, 0.0294, 0.0197, 0.0169,\n", + " 0.0187, 0.0193, 0.0232, 0.0208, 0.0181, 0.0193, 0.0212, 0.0174, 0.0218,\n", + " 0.0240, 0.0207, 0.0215, 0.0215, 0.0191, 0.0175, 0.0196],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "60000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 30, 30, 9, 12, 40, 19, 26, 37, 38, 47, 39, 12, 28, 24, 4, 15, 33,\n", + " 29, 10, 30, 8, 36, 33, 2])\n", + "loss= tensor(173.0837, grad_fn=) , actor= tensor(4.2399, grad_fn=) , critic= tensor(1688.4377, grad_fn=) , return= 168472.3527457471\n", + "probs of actions: tensor([0.0190, 0.0176, 0.0176, 0.0183, 0.0186, 0.0220, 0.0201, 0.0224, 0.0234,\n", + " 0.0189, 0.0209, 0.0218, 0.0184, 0.0197, 0.0197, 0.0173, 0.0198, 0.0188,\n", + " 0.0228, 0.0178, 0.0171, 0.0190, 0.0181, 0.0191, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "61000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 32, 45, 31, 15, 15, 15, 47, 23, 34, 23, 27, 1, 0, 36, 11, 17, 43,\n", + " 38, 39, 21, 17, 4, 1, 25])\n", + "loss= tensor(169.1821, grad_fn=) , actor= tensor(-1.0698, grad_fn=) , critic= tensor(1702.5190, grad_fn=) , return= 166512.14578005718\n", + "probs of actions: tensor([0.0208, 0.0189, 0.0220, 0.0222, 0.0198, 0.0197, 0.0198, 0.0207, 0.0195,\n", + " 0.0228, 0.0194, 0.0181, 0.0174, 0.0166, 0.0182, 0.0195, 0.0191, 0.0241,\n", + " 0.0192, 0.0217, 0.0178, 0.0190, 0.0173, 0.0173, 0.0212],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "62000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 46, 30, 2, 41, 3, 23, 42, 27, 38, 12, 40, 9, 46, 38, 21, 25, 45,\n", + " 35, 37, 5, 15, 32, 44, 49])\n", + "loss= tensor(174.7134, grad_fn=) , actor= tensor(0.4474, grad_fn=) , critic= tensor(1742.6599, grad_fn=) , return= 166038.22605107978\n", + "probs of actions: tensor([0.0170, 0.0287, 0.0179, 0.0189, 0.0205, 0.0189, 0.0195, 0.0241, 0.0183,\n", + " 0.0188, 0.0185, 0.0228, 0.0176, 0.0284, 0.0189, 0.0175, 0.0208, 0.0226,\n", + " 0.0220, 0.0236, 0.0190, 0.0200, 0.0189, 0.0228, 0.0200],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "63000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 16, 31, 3, 25, 25, 48, 47, 23, 5, 30, 45, 44, 25, 7, 28, 17, 37,\n", + " 15, 45, 5, 39, 16, 31, 32])\n", + "loss= tensor(172.1354, grad_fn=) , actor= tensor(3.7013, grad_fn=) , critic= tensor(1684.3408, grad_fn=) , return= 167176.22007122388\n", + "probs of actions: tensor([0.0232, 0.0191, 0.0220, 0.0190, 0.0204, 0.0205, 0.0182, 0.0208, 0.0196,\n", + " 0.0190, 0.0175, 0.0225, 0.0229, 0.0209, 0.0188, 0.0198, 0.0193, 0.0236,\n", + " 0.0199, 0.0226, 0.0190, 0.0215, 0.0190, 0.0226, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "64000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 22, 49, 8, 5, 26, 31, 11, 43, 44, 24, 7, 18, 27, 7, 14, 25, 44,\n", + " 36, 26, 44, 5, 8, 4, 13])\n", + "loss= tensor(161.6287, grad_fn=) , actor= tensor(-0.1314, grad_fn=) , critic= tensor(1617.6010, grad_fn=) , return= 166187.90074429265\n", + "probs of actions: tensor([0.0186, 0.0173, 0.0205, 0.0190, 0.0191, 0.0224, 0.0225, 0.0193, 0.0252,\n", + " 0.0230, 0.0198, 0.0188, 0.0180, 0.0180, 0.0187, 0.0172, 0.0210, 0.0230,\n", + " 0.0183, 0.0227, 0.0230, 0.0191, 0.0188, 0.0174, 0.0216],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "65000 adversary: AdversaryModes.myopic\n", + " actions: tensor([48, 25, 45, 42, 49, 45, 21, 23, 16, 18, 41, 48, 48, 30, 49, 33, 38, 46,\n", + " 22, 36, 45, 44, 16, 46, 3])\n", + "loss= tensor(204.7411, grad_fn=) , actor= tensor(28.5896, grad_fn=) , critic= tensor(1761.5150, grad_fn=) , return= 174778.47415797063\n", + "probs of actions: tensor([0.0182, 0.0200, 0.0219, 0.0242, 0.0204, 0.0222, 0.0169, 0.0194, 0.0192,\n", + " 0.0179, 0.0199, 0.0180, 0.0180, 0.0175, 0.0201, 0.0190, 0.0191, 0.0285,\n", + " 0.0179, 0.0183, 0.0225, 0.0230, 0.0189, 0.0280, 0.0179],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "66000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 13, 22, 42, 21, 37, 43, 16, 19, 0, 10, 43, 11, 10, 32, 47, 21, 34,\n", + " 22, 42, 11, 34, 46, 25, 19])\n", + "loss= tensor(156.6537, grad_fn=) , actor= tensor(4.4798, grad_fn=) , critic= tensor(1521.7388, grad_fn=) , return= 167319.240999509\n", + "probs of actions: tensor([0.0221, 0.0217, 0.0174, 0.0242, 0.0170, 0.0234, 0.0253, 0.0190, 0.0197,\n", + " 0.0163, 0.0178, 0.0251, 0.0191, 0.0178, 0.0192, 0.0213, 0.0174, 0.0237,\n", + " 0.0178, 0.0235, 0.0192, 0.0238, 0.0279, 0.0211, 0.0202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "67000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 42, 34, 8, 20, 11, 17, 21, 14, 23, 4, 33, 5, 46, 13, 37, 40, 43,\n", + " 16, 42, 7, 11, 16, 11, 42])\n", + "loss= tensor(155.0979, grad_fn=) , actor= tensor(-8.6337, grad_fn=) , critic= tensor(1637.3159, grad_fn=) , return= 163640.17203540896\n", + "probs of actions: tensor([0.0195, 0.0244, 0.0225, 0.0187, 0.0188, 0.0187, 0.0195, 0.0167, 0.0169,\n", + " 0.0192, 0.0168, 0.0189, 0.0186, 0.0293, 0.0213, 0.0238, 0.0234, 0.0244,\n", + " 0.0192, 0.0236, 0.0186, 0.0190, 0.0193, 0.0190, 0.0234],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "68000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 21, 18, 20, 8, 0, 13, 29, 45, 4, 34, 16, 32, 49, 17, 8, 6, 42,\n", + " 46, 29, 33, 28, 17, 39, 23])\n", + "loss= tensor(142.6272, grad_fn=) , actor= tensor(-2.6666, grad_fn=) , critic= tensor(1452.9377, grad_fn=) , return= 164980.19933304304\n", + "probs of actions: tensor([0.0166, 0.0168, 0.0179, 0.0187, 0.0186, 0.0161, 0.0214, 0.0220, 0.0224,\n", + " 0.0167, 0.0234, 0.0192, 0.0190, 0.0197, 0.0195, 0.0186, 0.0214, 0.0237,\n", + " 0.0288, 0.0229, 0.0192, 0.0193, 0.0193, 0.0216, 0.0192],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "69000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 3, 6, 24, 20, 27, 22, 12, 3, 6, 25, 17, 47, 4, 37, 33, 43, 29,\n", + " 46, 30, 45, 32, 28, 49, 15])\n", + "loss= tensor(136.4992, grad_fn=) , actor= tensor(0.6350, grad_fn=) , critic= tensor(1358.6421, grad_fn=) , return= 165645.54603775014\n", + "probs of actions: tensor([0.0188, 0.0189, 0.0214, 0.0197, 0.0186, 0.0183, 0.0170, 0.0183, 0.0182,\n", + " 0.0212, 0.0207, 0.0194, 0.0214, 0.0167, 0.0240, 0.0190, 0.0248, 0.0228,\n", + " 0.0290, 0.0176, 0.0227, 0.0189, 0.0194, 0.0195, 0.0198],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "70000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 4, 39, 5, 41, 49, 16, 35, 48, 46, 46, 29, 31, 31, 4, 20, 2, 14, 49,\n", + " 32, 48, 21, 46, 29, 42, 29])\n", + "loss= tensor(171.8711, grad_fn=) , actor= tensor(7.4633, grad_fn=) , critic= tensor(1644.0784, grad_fn=) , return= 168148.91052389162\n", + "probs of actions: tensor([0.0162, 0.0221, 0.0189, 0.0212, 0.0200, 0.0189, 0.0228, 0.0181, 0.0303,\n", + " 0.0303, 0.0222, 0.0228, 0.0228, 0.0164, 0.0192, 0.0186, 0.0172, 0.0196,\n", + " 0.0190, 0.0183, 0.0172, 0.0291, 0.0232, 0.0236, 0.0233],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "71000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 47, 46, 39, 40, 2, 26, 8, 27, 31, 7, 27, 16, 35, 33, 26, 15, 34,\n", + " 20, 46, 46, 30, 46, 35, 1])\n", + "loss= tensor(169.7214, grad_fn=) , actor= tensor(12.7777, grad_fn=) , critic= tensor(1569.4374, grad_fn=) , return= 170314.88923566823\n", + "probs of actions: tensor([0.0222, 0.0207, 0.0304, 0.0222, 0.0218, 0.0183, 0.0226, 0.0187, 0.0180,\n", + " 0.0226, 0.0187, 0.0180, 0.0190, 0.0230, 0.0187, 0.0229, 0.0197, 0.0239,\n", + " 0.0193, 0.0294, 0.0292, 0.0175, 0.0291, 0.0228, 0.0162],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "72000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 37, 49, 27, 37, 15, 44, 43, 5, 25, 6, 17, 9, 43, 25, 12, 16, 29,\n", + " 32, 4, 8, 26, 25, 10, 44])\n", + "loss= tensor(168.1289, grad_fn=) , actor= tensor(-10.2398, grad_fn=) , critic= tensor(1783.6870, grad_fn=) , return= 164287.3537799196\n", + "probs of actions: tensor([0.0213, 0.0241, 0.0203, 0.0185, 0.0241, 0.0195, 0.0232, 0.0262, 0.0188,\n", + " 0.0205, 0.0210, 0.0193, 0.0171, 0.0258, 0.0208, 0.0183, 0.0188, 0.0231,\n", + " 0.0190, 0.0164, 0.0183, 0.0230, 0.0211, 0.0174, 0.0232],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "73000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 2, 20, 11, 27, 7, 23, 2, 0, 10, 12, 35, 10, 3, 12, 45, 43, 25, 19,\n", + " 7, 8, 15, 8, 30, 19, 34])\n", + "loss= tensor(126.5955, grad_fn=) , actor= tensor(-23.6533, grad_fn=) , critic= tensor(1502.4883, grad_fn=) , return= 158171.60380491914\n", + "probs of actions: tensor([0.0185, 0.0191, 0.0185, 0.0184, 0.0189, 0.0198, 0.0184, 0.0160, 0.0173,\n", + " 0.0182, 0.0231, 0.0173, 0.0177, 0.0182, 0.0223, 0.0250, 0.0210, 0.0205,\n", + " 0.0188, 0.0181, 0.0196, 0.0181, 0.0175, 0.0208, 0.0240],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "74000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 32, 1, 2, 7, 36, 36, 18, 31, 49, 19, 8, 31, 26, 41, 27, 36, 2,\n", + " 14, 46, 30, 6, 11, 36, 11])\n", + "loss= tensor(160.5511, grad_fn=) , actor= tensor(-0.3360, grad_fn=) , critic= tensor(1608.8701, grad_fn=) , return= 165618.27136156376\n", + "probs of actions: tensor([0.0211, 0.0194, 0.0159, 0.0184, 0.0189, 0.0186, 0.0186, 0.0181, 0.0225,\n", + " 0.0199, 0.0206, 0.0180, 0.0226, 0.0224, 0.0204, 0.0182, 0.0184, 0.0185,\n", + " 0.0171, 0.0295, 0.0177, 0.0209, 0.0189, 0.0183, 0.0189],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "75000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 3, 26, 6, 2, 16, 18, 13, 37, 39, 36, 30, 8, 43, 49, 48, 45, 4,\n", + " 8, 18, 34, 30, 30, 10, 13])\n", + "loss= tensor(149.2485, grad_fn=) , actor= tensor(0.6087, grad_fn=) , critic= tensor(1486.3972, grad_fn=) , return= 165168.98516148922\n", + "probs of actions: tensor([0.0180, 0.0186, 0.0220, 0.0207, 0.0183, 0.0189, 0.0181, 0.0212, 0.0250,\n", + " 0.0215, 0.0186, 0.0178, 0.0179, 0.0260, 0.0198, 0.0180, 0.0224, 0.0163,\n", + " 0.0178, 0.0182, 0.0240, 0.0177, 0.0177, 0.0172, 0.0210],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "76000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 29, 28, 49, 10, 9, 29, 31, 10, 37, 0, 49, 32, 47, 37, 23, 0, 10,\n", + " 9, 37, 22, 45, 38, 35, 39])\n", + "loss= tensor(158.1055, grad_fn=) , actor= tensor(-4.2451, grad_fn=) , critic= tensor(1623.5054, grad_fn=) , return= 165476.7375666863\n", + "probs of actions: tensor([0.0183, 0.0215, 0.0199, 0.0201, 0.0170, 0.0174, 0.0222, 0.0225, 0.0171,\n", + " 0.0252, 0.0156, 0.0198, 0.0193, 0.0216, 0.0254, 0.0199, 0.0155, 0.0171,\n", + " 0.0168, 0.0254, 0.0169, 0.0223, 0.0196, 0.0230, 0.0212],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "77000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 24, 23, 29, 25, 26, 18, 35, 10, 30, 46, 1, 41, 5, 41, 25, 16, 35,\n", + " 42, 37, 17, 32, 43, 25, 40])\n", + "loss= tensor(164.3653, grad_fn=) , actor= tensor(3.9541, grad_fn=) , critic= tensor(1604.1121, grad_fn=) , return= 167759.39796337122\n", + "probs of actions: tensor([0.0204, 0.0206, 0.0204, 0.0217, 0.0208, 0.0220, 0.0181, 0.0232, 0.0170,\n", + " 0.0181, 0.0312, 0.0153, 0.0211, 0.0184, 0.0209, 0.0214, 0.0188, 0.0230,\n", + " 0.0252, 0.0257, 0.0189, 0.0194, 0.0250, 0.0217, 0.0229],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "78000 adversary: AdversaryModes.myopic\n", + " actions: tensor([48, 32, 47, 27, 38, 36, 36, 43, 22, 1, 12, 33, 48, 2, 21, 47, 45, 38,\n", + " 44, 40, 30, 5, 45, 46, 42])\n", + "loss= tensor(183.9906, grad_fn=) , actor= tensor(10.0013, grad_fn=) , critic= tensor(1739.8933, grad_fn=) , return= 169053.37637446614\n", + "probs of actions: tensor([0.0180, 0.0198, 0.0209, 0.0184, 0.0190, 0.0188, 0.0188, 0.0268, 0.0167,\n", + " 0.0151, 0.0184, 0.0181, 0.0179, 0.0181, 0.0163, 0.0216, 0.0224, 0.0192,\n", + " 0.0233, 0.0226, 0.0180, 0.0183, 0.0224, 0.0295, 0.0249],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "79000 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 29, 43, 13, 47, 44, 23, 39, 15, 30, 43, 0, 19, 5, 34, 45, 0, 45,\n", + " 46, 29, 0, 45, 4, 31, 44])\n", + "loss= tensor(166.8772, grad_fn=) , actor= tensor(-5.7545, grad_fn=) , critic= tensor(1726.3162, grad_fn=) , return= 164565.8149098789\n", + "probs of actions: tensor([0.0188, 0.0214, 0.0269, 0.0214, 0.0211, 0.0231, 0.0202, 0.0218, 0.0194,\n", + " 0.0182, 0.0263, 0.0155, 0.0200, 0.0182, 0.0238, 0.0224, 0.0154, 0.0224,\n", + " 0.0297, 0.0229, 0.0154, 0.0224, 0.0163, 0.0229, 0.0232],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "80000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 49, 4, 46, 24, 13, 3, 42, 24, 30, 36, 17, 27, 23, 27, 29, 48, 26,\n", + " 6, 14, 8, 18, 37, 43, 4])\n", + "loss= tensor(170.9584, grad_fn=) , actor= tensor(1.5600, grad_fn=) , critic= tensor(1693.9834, grad_fn=) , return= 167131.49495158557\n", + "probs of actions: tensor([0.0272, 0.0201, 0.0159, 0.0308, 0.0211, 0.0214, 0.0181, 0.0265, 0.0211,\n", + " 0.0183, 0.0189, 0.0191, 0.0181, 0.0200, 0.0181, 0.0227, 0.0179, 0.0219,\n", + " 0.0199, 0.0172, 0.0177, 0.0183, 0.0257, 0.0247, 0.0165],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "81000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 6, 43, 34, 20, 11, 39, 43, 7, 21, 2, 18, 46, 4, 20, 35, 21, 5, 21,\n", + " 44, 13, 15, 46, 33, 20, 40])\n", + "loss= tensor(149.7687, grad_fn=) , actor= tensor(-8.8053, grad_fn=) , critic= tensor(1585.7401, grad_fn=) , return= 163527.3111330365\n", + "probs of actions: tensor([0.0198, 0.0271, 0.0229, 0.0190, 0.0184, 0.0220, 0.0263, 0.0188, 0.0158,\n", + " 0.0178, 0.0182, 0.0303, 0.0164, 0.0195, 0.0228, 0.0164, 0.0180, 0.0163,\n", + " 0.0232, 0.0210, 0.0189, 0.0292, 0.0185, 0.0197, 0.0230],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "82000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 43, 18, 13, 17, 20, 8, 18, 35, 42, 11, 25, 42, 25, 41, 6, 28, 35,\n", + " 8, 27, 19, 4, 39, 17, 7])\n", + "loss= tensor(165.0793, grad_fn=) , actor= tensor(-0.0034, grad_fn=) , critic= tensor(1650.8274, grad_fn=) , return= 167058.39421052547\n", + "probs of actions: tensor([0.0210, 0.0268, 0.0180, 0.0214, 0.0193, 0.0192, 0.0179, 0.0181, 0.0228,\n", + " 0.0262, 0.0183, 0.0217, 0.0261, 0.0218, 0.0209, 0.0194, 0.0196, 0.0227,\n", + " 0.0179, 0.0181, 0.0205, 0.0164, 0.0214, 0.0188, 0.0188],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "83000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 22, 46, 44, 39, 19, 29, 27, 13, 44, 12, 42, 9, 31, 45, 34, 43, 41,\n", + " 14, 49, 25, 6, 45, 21, 15])\n", + "loss= tensor(179.2297, grad_fn=) , actor= tensor(11.0110, grad_fn=) , critic= tensor(1682.1869, grad_fn=) , return= 171031.64188000277\n", + "probs of actions: tensor([0.0214, 0.0168, 0.0311, 0.0229, 0.0220, 0.0200, 0.0223, 0.0182, 0.0211,\n", + " 0.0233, 0.0185, 0.0264, 0.0165, 0.0234, 0.0225, 0.0240, 0.0256, 0.0208,\n", + " 0.0173, 0.0194, 0.0221, 0.0192, 0.0225, 0.0169, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "84000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 45, 39, 30, 44, 25, 37, 26, 39, 10, 1, 34, 30, 49, 43, 24, 18, 8,\n", + " 35, 35, 36, 31, 33, 42, 47])\n", + "loss= tensor(185.0962, grad_fn=) , actor= tensor(6.9207, grad_fn=) , critic= tensor(1781.7554, grad_fn=) , return= 169423.24781269926\n", + "probs of actions: tensor([0.0184, 0.0219, 0.0220, 0.0184, 0.0231, 0.0212, 0.0262, 0.0216, 0.0218,\n", + " 0.0169, 0.0144, 0.0244, 0.0180, 0.0195, 0.0257, 0.0214, 0.0181, 0.0178,\n", + " 0.0227, 0.0227, 0.0188, 0.0239, 0.0186, 0.0256, 0.0221],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "85000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 42, 32, 47, 16, 5, 35, 10, 42, 42, 32, 24, 27, 23, 25, 43, 48, 19,\n", + " 48, 46, 19, 46, 3, 23, 37])\n", + "loss= tensor(187.0367, grad_fn=) , actor= tensor(12.3523, grad_fn=) , critic= tensor(1746.8442, grad_fn=) , return= 170231.53193699775\n", + "probs of actions: tensor([0.0200, 0.0265, 0.0198, 0.0215, 0.0188, 0.0180, 0.0231, 0.0170, 0.0270,\n", + " 0.0266, 0.0197, 0.0209, 0.0181, 0.0195, 0.0214, 0.0258, 0.0174, 0.0208,\n", + " 0.0174, 0.0301, 0.0208, 0.0300, 0.0167, 0.0193, 0.0266],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "86000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 44, 11, 34, 18, 44, 42, 0, 34, 17, 32, 39, 8, 4, 28, 9, 42, 23,\n", + " 47, 45, 10, 28, 33, 17, 40])\n", + "loss= tensor(155.4264, grad_fn=) , actor= tensor(-4.8902, grad_fn=) , critic= tensor(1603.1661, grad_fn=) , return= 165436.11473693146\n", + "probs of actions: tensor([0.0192, 0.0230, 0.0178, 0.0235, 0.0178, 0.0234, 0.0270, 0.0151, 0.0241,\n", + " 0.0192, 0.0200, 0.0219, 0.0177, 0.0159, 0.0200, 0.0164, 0.0267, 0.0194,\n", + " 0.0221, 0.0225, 0.0169, 0.0197, 0.0187, 0.0189, 0.0235],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "87000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 27, 31, 38, 33, 31, 21, 34, 48, 31, 6, 24, 2, 3, 48, 47, 22, 44,\n", + " 26, 31, 49, 33, 17, 43, 42])\n", + "loss= tensor(174.1426, grad_fn=) , actor= tensor(5.4291, grad_fn=) , critic= tensor(1687.1351, grad_fn=) , return= 168739.0900386048\n", + "probs of actions: tensor([0.0215, 0.0189, 0.0236, 0.0189, 0.0185, 0.0238, 0.0158, 0.0237, 0.0177,\n", + " 0.0241, 0.0187, 0.0208, 0.0177, 0.0172, 0.0177, 0.0220, 0.0171, 0.0235,\n", + " 0.0216, 0.0242, 0.0192, 0.0188, 0.0190, 0.0254, 0.0256],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "88000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 6, 17, 24, 35, 20, 24, 39, 16, 1, 29, 45, 19, 26, 22, 36, 18, 34, 35,\n", + " 29, 14, 45, 41, 21, 4, 35])\n", + "loss= tensor(162.3127, grad_fn=) , actor= tensor(0.3053, grad_fn=) , critic= tensor(1620.0732, grad_fn=) , return= 167542.3842471594\n", + "probs of actions: tensor([0.0188, 0.0196, 0.0207, 0.0230, 0.0196, 0.0207, 0.0225, 0.0190, 0.0142,\n", + " 0.0232, 0.0223, 0.0202, 0.0220, 0.0173, 0.0187, 0.0177, 0.0246, 0.0229,\n", + " 0.0240, 0.0171, 0.0224, 0.0207, 0.0166, 0.0158, 0.0226],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "89000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 33, 16, 10, 21, 16, 17, 21, 18, 7, 24, 3, 7, 38, 36, 2, 13, 6,\n", + " 28, 16, 24, 0, 47, 46, 34])\n", + "loss= tensor(138.1586, grad_fn=) , actor= tensor(-22.1848, grad_fn=) , critic= tensor(1603.4333, grad_fn=) , return= 159977.5083696295\n", + "probs of actions: tensor([0.0204, 0.0184, 0.0190, 0.0164, 0.0155, 0.0191, 0.0194, 0.0156, 0.0175,\n", + " 0.0185, 0.0208, 0.0172, 0.0186, 0.0192, 0.0187, 0.0175, 0.0206, 0.0188,\n", + " 0.0199, 0.0190, 0.0209, 0.0148, 0.0218, 0.0295, 0.0248],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "90000 adversary: AdversaryModes.myopic\n", + " actions: tensor([14, 24, 6, 26, 11, 4, 37, 34, 35, 44, 11, 0, 20, 49, 6, 0, 14, 21,\n", + " 19, 42, 35, 38, 3, 29, 21])\n", + "loss= tensor(137.3146, grad_fn=) , actor= tensor(-11.4876, grad_fn=) , critic= tensor(1488.0225, grad_fn=) , return= 162968.8331233808\n", + "probs of actions: tensor([0.0163, 0.0209, 0.0186, 0.0220, 0.0177, 0.0152, 0.0269, 0.0241, 0.0232,\n", + " 0.0239, 0.0178, 0.0148, 0.0202, 0.0188, 0.0185, 0.0148, 0.0172, 0.0161,\n", + " 0.0201, 0.0266, 0.0229, 0.0195, 0.0167, 0.0244, 0.0165],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "91000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 35, 41, 41, 49, 33, 16, 40, 45, 44, 5, 28, 25, 44, 7, 43, 20, 39,\n", + " 17, 20, 40, 16, 18, 36, 18])\n", + "loss= tensor(189.0925, grad_fn=) , actor= tensor(10.1037, grad_fn=) , critic= tensor(1789.8884, grad_fn=) , return= 171335.52643785565\n", + "probs of actions: tensor([0.0184, 0.0230, 0.0226, 0.0224, 0.0190, 0.0187, 0.0190, 0.0221, 0.0225,\n", + " 0.0241, 0.0176, 0.0203, 0.0214, 0.0242, 0.0183, 0.0272, 0.0202, 0.0220,\n", + " 0.0188, 0.0204, 0.0235, 0.0188, 0.0176, 0.0186, 0.0175],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "92000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 29, 19, 3, 22, 48, 42, 49, 28, 38, 7, 37, 0, 27, 21, 33, 42, 47,\n", + " 43, 25, 33, 43, 20, 36, 16])\n", + "loss= tensor(170.7755, grad_fn=) , actor= tensor(13.0770, grad_fn=) , critic= tensor(1576.9852, grad_fn=) , return= 170508.17940129395\n", + "probs of actions: tensor([0.0190, 0.0221, 0.0197, 0.0176, 0.0174, 0.0174, 0.0274, 0.0189, 0.0200,\n", + " 0.0192, 0.0181, 0.0273, 0.0144, 0.0178, 0.0160, 0.0186, 0.0270, 0.0222,\n", + " 0.0269, 0.0218, 0.0187, 0.0267, 0.0202, 0.0186, 0.0188],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "93000 adversary: AdversaryModes.myopic\n", + " actions: tensor([10, 44, 18, 39, 14, 8, 38, 42, 34, 42, 35, 19, 2, 37, 17, 14, 21, 24,\n", + " 49, 5, 8, 42, 36, 43, 43])\n", + "loss= tensor(167.0188, grad_fn=) , actor= tensor(-5.7878, grad_fn=) , critic= tensor(1728.0663, grad_fn=) , return= 165044.40819416282\n", + "probs of actions: tensor([0.0161, 0.0234, 0.0173, 0.0226, 0.0168, 0.0167, 0.0192, 0.0279, 0.0243,\n", + " 0.0280, 0.0229, 0.0196, 0.0171, 0.0277, 0.0190, 0.0173, 0.0160, 0.0218,\n", + " 0.0186, 0.0173, 0.0167, 0.0272, 0.0184, 0.0266, 0.0265],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "94000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 37, 9, 49, 35, 29, 27, 46, 46, 30, 40, 24, 15, 13, 7, 32, 40, 17,\n", + " 44, 47, 47, 23, 19, 16, 24])\n", + "loss= tensor(180.5013, grad_fn=) , actor= tensor(11.2213, grad_fn=) , critic= tensor(1692.7993, grad_fn=) , return= 171138.27706654908\n", + "probs of actions: tensor([0.0203, 0.0274, 0.0173, 0.0188, 0.0230, 0.0225, 0.0180, 0.0334, 0.0332,\n", + " 0.0185, 0.0227, 0.0217, 0.0188, 0.0201, 0.0181, 0.0204, 0.0234, 0.0191,\n", + " 0.0237, 0.0217, 0.0217, 0.0197, 0.0200, 0.0189, 0.0215],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "95000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 35, 3, 48, 25, 29, 32, 14, 14, 48, 37, 46, 31, 39, 41, 22, 11, 25,\n", + " 34, 25, 47, 49, 24, 44, 45])\n", + "loss= tensor(176.8337, grad_fn=) , actor= tensor(6.4618, grad_fn=) , critic= tensor(1703.7190, grad_fn=) , return= 168686.52732218316\n", + "probs of actions: tensor([0.0206, 0.0228, 0.0180, 0.0174, 0.0210, 0.0229, 0.0204, 0.0168, 0.0169,\n", + " 0.0173, 0.0284, 0.0327, 0.0247, 0.0227, 0.0219, 0.0174, 0.0176, 0.0217,\n", + " 0.0252, 0.0218, 0.0217, 0.0184, 0.0218, 0.0238, 0.0231],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "96000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 36, 35, 17, 28, 4, 47, 44, 30, 26, 8, 44, 15, 7, 18, 19, 27, 28,\n", + " 40, 18, 34, 2, 44, 18, 47])\n", + "loss= tensor(171.2012, grad_fn=) , actor= tensor(-6.2736, grad_fn=) , critic= tensor(1774.7484, grad_fn=) , return= 165992.84118559185\n", + "probs of actions: tensor([0.0289, 0.0187, 0.0227, 0.0194, 0.0202, 0.0145, 0.0215, 0.0240, 0.0187,\n", + " 0.0222, 0.0165, 0.0242, 0.0187, 0.0182, 0.0175, 0.0199, 0.0177, 0.0197,\n", + " 0.0234, 0.0174, 0.0255, 0.0167, 0.0241, 0.0174, 0.0217],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "97000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 5, 15, 44, 47, 47, 39, 44, 34, 46, 7, 41, 37, 34, 13, 6, 42, 11, 26,\n", + " 20, 1, 1, 32, 38, 46, 17])\n", + "loss= tensor(177.9435, grad_fn=) , actor= tensor(-3.0755, grad_fn=) , critic= tensor(1810.1891, grad_fn=) , return= 166897.0072768241\n", + "probs of actions: tensor([0.0171, 0.0181, 0.0236, 0.0215, 0.0216, 0.0230, 0.0239, 0.0246, 0.0334,\n", + " 0.0180, 0.0224, 0.0284, 0.0249, 0.0203, 0.0177, 0.0284, 0.0177, 0.0224,\n", + " 0.0202, 0.0132, 0.0132, 0.0206, 0.0197, 0.0314, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "98000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 28, 44, 23, 4, 24, 35, 21, 37, 40, 36, 35, 8, 32, 13, 10, 33, 37,\n", + " 18, 36, 47, 48, 37, 49, 9])\n", + "loss= tensor(163.5287, grad_fn=) , actor= tensor(7.2847, grad_fn=) , critic= tensor(1562.4399, grad_fn=) , return= 169966.7077092455\n", + "probs of actions: tensor([0.0203, 0.0203, 0.0238, 0.0201, 0.0144, 0.0217, 0.0232, 0.0158, 0.0283,\n", + " 0.0225, 0.0185, 0.0232, 0.0162, 0.0209, 0.0202, 0.0164, 0.0185, 0.0284,\n", + " 0.0176, 0.0185, 0.0218, 0.0172, 0.0284, 0.0188, 0.0160],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "99000 adversary: AdversaryModes.myopic\n", + " actions: tensor([10, 43, 0, 42, 29, 27, 48, 48, 41, 42, 46, 30, 19, 25, 38, 21, 33, 27,\n", + " 17, 44, 16, 15, 41, 24, 17])\n", + "loss= tensor(193.3470, grad_fn=) , actor= tensor(14.9550, grad_fn=) , critic= tensor(1783.9204, grad_fn=) , return= 171241.74156074892\n", + "probs of actions: tensor([0.0159, 0.0295, 0.0137, 0.0291, 0.0229, 0.0181, 0.0171, 0.0172, 0.0224,\n", + " 0.0285, 0.0331, 0.0186, 0.0194, 0.0212, 0.0194, 0.0163, 0.0186, 0.0179,\n", + " 0.0191, 0.0244, 0.0187, 0.0186, 0.0213, 0.0221, 0.0191],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "100000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 18, 20, 46, 43, 29, 5, 29, 5, 27, 13, 34, 15, 29, 34, 6, 27, 31,\n", + " 36, 40, 15, 4, 43, 31, 25])\n", + "loss= tensor(160.6172, grad_fn=) , actor= tensor(-2.1541, grad_fn=) , critic= tensor(1627.7135, grad_fn=) , return= 166944.9604730261\n", + "probs of actions: tensor([0.0236, 0.0176, 0.0199, 0.0337, 0.0288, 0.0232, 0.0171, 0.0237, 0.0171,\n", + " 0.0178, 0.0203, 0.0250, 0.0186, 0.0242, 0.0251, 0.0174, 0.0178, 0.0245,\n", + " 0.0185, 0.0237, 0.0187, 0.0148, 0.0270, 0.0246, 0.0217],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "101000 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 22, 9, 20, 31, 19, 9, 43, 9, 30, 17, 36, 23, 45, 27, 49, 5, 43,\n", + " 4, 14, 46, 47, 47, 2, 32])\n", + "loss= tensor(152.1700, grad_fn=) , actor= tensor(-2.8171, grad_fn=) , critic= tensor(1549.8713, grad_fn=) , return= 165679.2221469027\n", + "probs of actions: tensor([0.0175, 0.0169, 0.0170, 0.0199, 0.0240, 0.0194, 0.0166, 0.0290, 0.0164,\n", + " 0.0188, 0.0190, 0.0183, 0.0197, 0.0227, 0.0182, 0.0187, 0.0172, 0.0277,\n", + " 0.0146, 0.0174, 0.0314, 0.0217, 0.0217, 0.0162, 0.0208],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "102000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 19, 28, 31, 25, 39, 32, 39, 49, 28, 22, 20, 20, 5, 36, 13, 32, 24,\n", + " 25, 38, 32, 9, 5, 0, 37])\n", + "loss= tensor(186.5589, grad_fn=) , actor= tensor(-0.5863, grad_fn=) , critic= tensor(1871.4526, grad_fn=) , return= 168509.7507745542\n", + "probs of actions: tensor([0.0196, 0.0196, 0.0207, 0.0241, 0.0206, 0.0228, 0.0209, 0.0228, 0.0188,\n", + " 0.0203, 0.0173, 0.0202, 0.0203, 0.0171, 0.0181, 0.0207, 0.0207, 0.0217,\n", + " 0.0214, 0.0200, 0.0205, 0.0158, 0.0171, 0.0137, 0.0283],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "103000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 37, 16, 25, 28, 3, 37, 1, 7, 0, 8, 5, 21, 16, 31, 30, 29, 47,\n", + " 20, 8, 5, 25, 18, 30, 37])\n", + "loss= tensor(139.1435, grad_fn=) , actor= tensor(-17.8740, grad_fn=) , critic= tensor(1570.1750, grad_fn=) , return= 161396.55490863262\n", + "probs of actions: tensor([0.0242, 0.0285, 0.0189, 0.0206, 0.0205, 0.0169, 0.0286, 0.0124, 0.0180,\n", + " 0.0137, 0.0160, 0.0169, 0.0157, 0.0188, 0.0249, 0.0185, 0.0254, 0.0219,\n", + " 0.0201, 0.0160, 0.0170, 0.0216, 0.0174, 0.0184, 0.0286],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "104000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 3, 49, 14, 12, 45, 46, 6, 19, 26, 23, 32, 8, 28, 26, 15, 46, 18, 48,\n", + " 5, 11, 25, 32, 23, 44, 41])\n", + "loss= tensor(159.2495, grad_fn=) , actor= tensor(-8.2472, grad_fn=) , critic= tensor(1674.9668, grad_fn=) , return= 164045.64965423138\n", + "probs of actions: tensor([0.0172, 0.0191, 0.0162, 0.0169, 0.0221, 0.0337, 0.0171, 0.0190, 0.0228,\n", + " 0.0200, 0.0208, 0.0161, 0.0203, 0.0229, 0.0186, 0.0326, 0.0172, 0.0174,\n", + " 0.0170, 0.0169, 0.0216, 0.0205, 0.0197, 0.0251, 0.0220],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "105000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 18, 3, 24, 36, 5, 37, 48, 46, 6, 22, 8, 44, 20, 18, 46, 33, 30,\n", + " 47, 40, 37, 15, 49, 46, 43])\n", + "loss= tensor(159.0660, grad_fn=) , actor= tensor(1.5244, grad_fn=) , critic= tensor(1575.4154, grad_fn=) , return= 166599.90560249242\n", + "probs of actions: tensor([0.0237, 0.0171, 0.0168, 0.0214, 0.0186, 0.0168, 0.0296, 0.0175, 0.0335,\n", + " 0.0169, 0.0173, 0.0159, 0.0253, 0.0203, 0.0171, 0.0326, 0.0191, 0.0183,\n", + " 0.0214, 0.0241, 0.0296, 0.0184, 0.0185, 0.0315, 0.0264],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "106000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 34, 2, 13, 23, 26, 6, 26, 9, 26, 37, 45, 9, 14, 45, 32, 34, 17,\n", + " 39, 26, 38, 43, 6, 11, 16])\n", + "loss= tensor(150.6793, grad_fn=) , actor= tensor(-0.3975, grad_fn=) , critic= tensor(1510.7684, grad_fn=) , return= 167122.22822072144\n", + "probs of actions: tensor([0.0199, 0.0255, 0.0156, 0.0209, 0.0200, 0.0229, 0.0166, 0.0230, 0.0156,\n", + " 0.0231, 0.0300, 0.0222, 0.0154, 0.0167, 0.0222, 0.0210, 0.0268, 0.0186,\n", + " 0.0224, 0.0232, 0.0205, 0.0267, 0.0170, 0.0168, 0.0192],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "107000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 9, 47, 28, 33, 43, 49, 13, 45, 0, 26, 0, 9, 6, 3, 9, 14, 40,\n", + " 39, 32, 38, 16, 22, 10, 22])\n", + "loss= tensor(144.3371, grad_fn=) , actor= tensor(-11.5860, grad_fn=) , critic= tensor(1559.2310, grad_fn=) , return= 164723.84009665519\n", + "probs of actions: tensor([0.0299, 0.0161, 0.0210, 0.0205, 0.0187, 0.0290, 0.0185, 0.0205, 0.0223,\n", + " 0.0131, 0.0232, 0.0130, 0.0152, 0.0165, 0.0156, 0.0151, 0.0168, 0.0245,\n", + " 0.0226, 0.0206, 0.0209, 0.0189, 0.0174, 0.0162, 0.0174],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "108000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 3, 42, 46, 1, 5, 15, 48, 25, 30, 33, 45, 32, 37, 28, 46, 39, 34,\n", + " 45, 37, 5, 32, 40, 39, 16])\n", + "loss= tensor(170.1032, grad_fn=) , actor= tensor(11.2588, grad_fn=) , critic= tensor(1588.4441, grad_fn=) , return= 169913.69286535704\n", + "probs of actions: tensor([0.0208, 0.0168, 0.0287, 0.0343, 0.0117, 0.0166, 0.0180, 0.0173, 0.0209,\n", + " 0.0188, 0.0190, 0.0225, 0.0207, 0.0306, 0.0203, 0.0331, 0.0228, 0.0268,\n", + " 0.0226, 0.0306, 0.0167, 0.0206, 0.0248, 0.0226, 0.0190],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "109000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 25, 37, 22, 36, 40, 19, 49, 20, 44, 46, 29, 49, 13, 5, 2, 19, 43,\n", + " 32, 45, 39, 39, 48, 43, 31])\n", + "loss= tensor(173.2718, grad_fn=) , actor= tensor(8.0618, grad_fn=) , critic= tensor(1652.1007, grad_fn=) , return= 170262.4143091618\n", + "probs of actions: tensor([0.0251, 0.0205, 0.0302, 0.0165, 0.0185, 0.0232, 0.0192, 0.0182, 0.0194,\n", + " 0.0255, 0.0342, 0.0259, 0.0181, 0.0204, 0.0165, 0.0155, 0.0193, 0.0280,\n", + " 0.0205, 0.0227, 0.0227, 0.0227, 0.0174, 0.0273, 0.0253],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "110000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 36, 45, 35, 47, 39, 43, 9, 7, 6, 34, 44, 35, 31, 22, 48, 0, 37,\n", + " 10, 8, 29, 16, 37, 41, 4])\n", + "loss= tensor(173.5088, grad_fn=) , actor= tensor(0.6065, grad_fn=) , critic= tensor(1729.0223, grad_fn=) , return= 168773.6062358134\n", + "probs of actions: tensor([0.0249, 0.0187, 0.0224, 0.0234, 0.0215, 0.0232, 0.0294, 0.0152, 0.0179,\n", + " 0.0157, 0.0273, 0.0262, 0.0234, 0.0250, 0.0171, 0.0173, 0.0126, 0.0309,\n", + " 0.0163, 0.0152, 0.0267, 0.0192, 0.0309, 0.0223, 0.0138],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "111000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 4, 29, 38, 4, 12, 10, 36, 37, 48, 47, 12, 34, 42, 27, 14, 3, 33,\n", + " 49, 34, 36, 35, 34, 40, 15])\n", + "loss= tensor(160.5262, grad_fn=) , actor= tensor(8.5747, grad_fn=) , critic= tensor(1519.5146, grad_fn=) , return= 168640.8258318563\n", + "probs of actions: tensor([0.0207, 0.0130, 0.0247, 0.0208, 0.0132, 0.0158, 0.0160, 0.0184, 0.0311,\n", + " 0.0171, 0.0220, 0.0159, 0.0274, 0.0282, 0.0173, 0.0166, 0.0150, 0.0188,\n", + " 0.0179, 0.0274, 0.0183, 0.0231, 0.0276, 0.0251, 0.0182],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "112000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 30, 15, 7, 12, 1, 36, 28, 39, 19, 10, 49, 11, 37, 7, 1, 6, 49,\n", + " 13, 14, 38, 37, 38, 7, 20])\n", + "loss= tensor(138.1606, grad_fn=) , actor= tensor(-10.9895, grad_fn=) , critic= tensor(1491.5016, grad_fn=) , return= 163527.93342048532\n", + "probs of actions: tensor([0.0313, 0.0193, 0.0176, 0.0179, 0.0159, 0.0114, 0.0184, 0.0208, 0.0233,\n", + " 0.0193, 0.0160, 0.0180, 0.0161, 0.0312, 0.0177, 0.0115, 0.0157, 0.0180,\n", + " 0.0198, 0.0168, 0.0213, 0.0312, 0.0213, 0.0178, 0.0205],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "113000 adversary: AdversaryModes.myopic\n", + " actions: tensor([48, 24, 47, 4, 37, 21, 47, 41, 41, 16, 28, 10, 32, 0, 3, 35, 20, 17,\n", + " 26, 32, 11, 42, 30, 40, 17])\n", + "loss= tensor(164.2776, grad_fn=) , actor= tensor(-0.3286, grad_fn=) , critic= tensor(1646.0619, grad_fn=) , return= 167140.21765069122\n", + "probs of actions: tensor([0.0175, 0.0220, 0.0216, 0.0128, 0.0313, 0.0147, 0.0219, 0.0238, 0.0238,\n", + " 0.0189, 0.0208, 0.0159, 0.0211, 0.0124, 0.0150, 0.0234, 0.0203, 0.0183,\n", + " 0.0247, 0.0208, 0.0160, 0.0280, 0.0186, 0.0246, 0.0183],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "114000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 42, 25, 28, 46, 22, 34, 1, 10, 5, 45, 3, 36, 28, 36, 29, 19, 26,\n", + " 25, 33, 20, 32, 37, 20, 47])\n", + "loss= tensor(163.2494, grad_fn=) , actor= tensor(-2.9160, grad_fn=) , critic= tensor(1661.6536, grad_fn=) , return= 166485.78149847538\n", + "probs of actions: tensor([0.0213, 0.0294, 0.0197, 0.0211, 0.0361, 0.0164, 0.0262, 0.0114, 0.0159,\n", + " 0.0160, 0.0230, 0.0151, 0.0182, 0.0208, 0.0182, 0.0266, 0.0194, 0.0244,\n", + " 0.0205, 0.0191, 0.0205, 0.0209, 0.0319, 0.0206, 0.0221],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "115000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 34, 7, 28, 43, 38, 3, 41, 6, 26, 12, 42, 48, 9, 25, 4, 7, 23,\n", + " 48, 21, 43, 31, 26, 31, 35])\n", + "loss= tensor(156.3106, grad_fn=) , actor= tensor(-2.5649, grad_fn=) , critic= tensor(1588.7549, grad_fn=) , return= 165854.0511753545\n", + "probs of actions: tensor([0.0184, 0.0251, 0.0180, 0.0212, 0.0318, 0.0210, 0.0152, 0.0242, 0.0151,\n", + " 0.0245, 0.0159, 0.0292, 0.0170, 0.0150, 0.0202, 0.0131, 0.0180, 0.0197,\n", + " 0.0171, 0.0152, 0.0298, 0.0264, 0.0246, 0.0264, 0.0237],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "116000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 7, 11, 45, 44, 42, 34, 15, 25, 17, 4, 43, 16, 1, 0, 39, 13, 16,\n", + " 33, 13, 44, 12, 12, 41, 17])\n", + "loss= tensor(149.2260, grad_fn=) , actor= tensor(-12.6860, grad_fn=) , critic= tensor(1619.1201, grad_fn=) , return= 164000.30123168306\n", + "probs of actions: tensor([0.0238, 0.0177, 0.0155, 0.0224, 0.0260, 0.0293, 0.0255, 0.0176, 0.0202,\n", + " 0.0183, 0.0128, 0.0315, 0.0187, 0.0112, 0.0123, 0.0235, 0.0192, 0.0190,\n", + " 0.0192, 0.0192, 0.0263, 0.0159, 0.0158, 0.0225, 0.0182],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "117000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 17, 38, 6, 32, 24, 38, 31, 8, 16, 45, 46, 37, 47, 25, 21, 10, 17,\n", + " 32, 20, 13, 35, 19, 48, 18])\n", + "loss= tensor(172.2215, grad_fn=) , actor= tensor(0.4329, grad_fn=) , critic= tensor(1717.8860, grad_fn=) , return= 168516.12238593923\n", + "probs of actions: tensor([0.0373, 0.0185, 0.0211, 0.0148, 0.0215, 0.0221, 0.0213, 0.0267, 0.0144,\n", + " 0.0191, 0.0227, 0.0365, 0.0326, 0.0221, 0.0203, 0.0148, 0.0162, 0.0180,\n", + " 0.0211, 0.0203, 0.0191, 0.0240, 0.0196, 0.0169, 0.0169],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "118000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 3, 37, 41, 39, 20, 26, 24, 40, 44, 37, 14, 24, 26, 1, 38, 28, 10, 39,\n", + " 4, 32, 1, 41, 22, 6, 22])\n", + "loss= tensor(165.2227, grad_fn=) , actor= tensor(-9.2318, grad_fn=) , critic= tensor(1744.5450, grad_fn=) , return= 166951.0330582357\n", + "probs of actions: tensor([0.0154, 0.0323, 0.0252, 0.0237, 0.0195, 0.0246, 0.0221, 0.0234, 0.0266,\n", + " 0.0327, 0.0159, 0.0219, 0.0248, 0.0110, 0.0210, 0.0205, 0.0161, 0.0233,\n", + " 0.0128, 0.0214, 0.0111, 0.0230, 0.0168, 0.0149, 0.0169],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "119000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 26, 9, 47, 46, 43, 31, 33, 42, 45, 34, 22, 42, 42, 48, 45, 28, 17,\n", + " 12, 37, 46, 13, 26, 19, 27])\n", + "loss= tensor(196.1899, grad_fn=) , actor= tensor(13.3001, grad_fn=) , critic= tensor(1828.8977, grad_fn=) , return= 172799.9986481786\n", + "probs of actions: tensor([0.0182, 0.0244, 0.0155, 0.0219, 0.0371, 0.0319, 0.0265, 0.0191, 0.0296,\n", + " 0.0228, 0.0266, 0.0163, 0.0295, 0.0291, 0.0169, 0.0228, 0.0202, 0.0179,\n", + " 0.0156, 0.0337, 0.0350, 0.0189, 0.0247, 0.0197, 0.0174],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "120000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 15, 20, 19, 34, 46, 48, 5, 19, 43, 26, 6, 7, 27, 11, 45, 20, 18,\n", + " 15, 2, 34, 46, 39, 16, 36])\n", + "loss= tensor(150.1913, grad_fn=) , actor= tensor(-11.3641, grad_fn=) , critic= tensor(1615.5544, grad_fn=) , return= 164542.9469923966\n", + "probs of actions: tensor([0.0184, 0.0176, 0.0193, 0.0187, 0.0264, 0.0373, 0.0171, 0.0153, 0.0185,\n", + " 0.0321, 0.0249, 0.0140, 0.0169, 0.0172, 0.0154, 0.0232, 0.0198, 0.0167,\n", + " 0.0180, 0.0140, 0.0274, 0.0349, 0.0233, 0.0187, 0.0185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "121000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 46, 9, 7, 32, 31, 23, 47, 41, 21, 39, 12, 22, 15, 40, 14, 5, 8,\n", + " 46, 3, 16, 32, 21, 24, 49])\n", + "loss= tensor(169.3102, grad_fn=) , actor= tensor(-13.9609, grad_fn=) , critic= tensor(1832.7117, grad_fn=) , return= 164219.23586345674\n", + "probs of actions: tensor([0.0175, 0.0371, 0.0153, 0.0170, 0.0219, 0.0268, 0.0206, 0.0224, 0.0247,\n", + " 0.0143, 0.0237, 0.0152, 0.0164, 0.0178, 0.0248, 0.0162, 0.0151, 0.0140,\n", + " 0.0355, 0.0141, 0.0190, 0.0215, 0.0149, 0.0221, 0.0169],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "122000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 29, 17, 49, 46, 39, 29, 5, 0, 42, 40, 23, 42, 24, 44, 39, 11, 32,\n", + " 2, 47, 17, 25, 3, 46, 14])\n", + "loss= tensor(172.6436, grad_fn=) , actor= tensor(-1.4970, grad_fn=) , critic= tensor(1741.4064, grad_fn=) , return= 168118.1142173214\n", + "probs of actions: tensor([0.0221, 0.0259, 0.0185, 0.0172, 0.0377, 0.0237, 0.0269, 0.0150, 0.0116,\n", + " 0.0298, 0.0242, 0.0206, 0.0293, 0.0224, 0.0270, 0.0235, 0.0151, 0.0219,\n", + " 0.0138, 0.0226, 0.0183, 0.0210, 0.0142, 0.0352, 0.0165],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "123000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 42, 7, 33, 23, 25, 0, 2, 22, 29, 38, 46, 35, 10, 17, 38, 49, 45,\n", + " 8, 36, 11, 38, 21, 12, 46])\n", + "loss= tensor(156.6644, grad_fn=) , actor= tensor(-8.2064, grad_fn=) , critic= tensor(1648.7078, grad_fn=) , return= 165433.9126606058\n", + "probs of actions: tensor([0.0221, 0.0298, 0.0167, 0.0189, 0.0206, 0.0201, 0.0112, 0.0135, 0.0162,\n", + " 0.0274, 0.0212, 0.0372, 0.0243, 0.0154, 0.0182, 0.0212, 0.0168, 0.0234,\n", + " 0.0136, 0.0186, 0.0152, 0.0214, 0.0145, 0.0149, 0.0353],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "124000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 25, 11, 46, 22, 36, 11, 14, 15, 20, 48, 32, 15, 9, 12, 13, 10, 36,\n", + " 25, 31, 42, 20, 33, 31, 43])\n", + "loss= tensor(153.9303, grad_fn=) , actor= tensor(-5.9910, grad_fn=) , critic= tensor(1599.2134, grad_fn=) , return= 164358.9308106642\n", + "probs of actions: tensor([0.0137, 0.0197, 0.0148, 0.0386, 0.0160, 0.0187, 0.0148, 0.0160, 0.0173,\n", + " 0.0193, 0.0167, 0.0225, 0.0174, 0.0145, 0.0145, 0.0184, 0.0154, 0.0186,\n", + " 0.0207, 0.0273, 0.0284, 0.0196, 0.0196, 0.0273, 0.0313],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "125000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 46, 41, 37, 35, 37, 35, 36, 11, 1, 15, 5, 34, 46, 10, 43, 42, 45,\n", + " 10, 29, 34, 43, 22, 40, 46])\n", + "loss= tensor(167.6550, grad_fn=) , actor= tensor(-0.0485, grad_fn=) , critic= tensor(1677.0348, grad_fn=) , return= 167173.01284487356\n", + "probs of actions: tensor([0.0137, 0.0386, 0.0270, 0.0339, 0.0242, 0.0340, 0.0243, 0.0186, 0.0148,\n", + " 0.0101, 0.0173, 0.0148, 0.0274, 0.0371, 0.0152, 0.0325, 0.0287, 0.0236,\n", + " 0.0153, 0.0278, 0.0274, 0.0314, 0.0169, 0.0255, 0.0355],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "126000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 45, 23, 22, 47, 46, 27, 20, 40, 39, 37, 14, 31, 22, 29, 43, 25, 44,\n", + " 34, 39, 18, 46, 48, 41, 29])\n", + "loss= tensor(187.9578, grad_fn=) , actor= tensor(15.4414, grad_fn=) , critic= tensor(1725.1638, grad_fn=) , return= 172735.06100862645\n", + "probs of actions: tensor([0.0180, 0.0233, 0.0205, 0.0163, 0.0228, 0.0385, 0.0177, 0.0192, 0.0240,\n", + " 0.0244, 0.0347, 0.0161, 0.0277, 0.0167, 0.0277, 0.0319, 0.0203, 0.0272,\n", + " 0.0275, 0.0241, 0.0165, 0.0362, 0.0168, 0.0245, 0.0282],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "127000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 22, 37, 34, 46, 46, 39, 40, 25, 45, 28, 43, 46, 22, 26, 2, 2, 10,\n", + " 33, 35, 2, 27, 6, 25, 23])\n", + "loss= tensor(186.4167, grad_fn=) , actor= tensor(-6.1414, grad_fn=) , critic= tensor(1925.5811, grad_fn=) , return= 169510.54078251845\n", + "probs of actions: tensor([0.0264, 0.0160, 0.0347, 0.0271, 0.0391, 0.0390, 0.0247, 0.0238, 0.0201,\n", + " 0.0238, 0.0206, 0.0332, 0.0379, 0.0166, 0.0260, 0.0131, 0.0132, 0.0152,\n", + " 0.0191, 0.0247, 0.0133, 0.0175, 0.0135, 0.0207, 0.0202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "128000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 33, 27, 43, 34, 16, 21, 3, 31, 25, 5, 34, 3, 44, 36, 48, 18, 49,\n", + " 49, 46, 38, 29, 20, 9, 43])\n", + "loss= tensor(159.4184, grad_fn=) , actor= tensor(1.3078, grad_fn=) , critic= tensor(1581.1060, grad_fn=) , return= 168374.9433966931\n", + "probs of actions: tensor([0.0162, 0.0185, 0.0179, 0.0346, 0.0274, 0.0188, 0.0133, 0.0139, 0.0277,\n", + " 0.0207, 0.0145, 0.0281, 0.0136, 0.0276, 0.0188, 0.0162, 0.0166, 0.0163,\n", + " 0.0163, 0.0373, 0.0218, 0.0281, 0.0197, 0.0138, 0.0318],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "129000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 38, 33, 42, 31, 28, 44, 30, 20, 25, 45, 24, 3, 35, 14, 27, 3, 18,\n", + " 40, 31, 23, 5, 37, 28, 32])\n", + "loss= tensor(178.7515, grad_fn=) , actor= tensor(-1.8295, grad_fn=) , critic= tensor(1805.8102, grad_fn=) , return= 168846.07051833\n", + "probs of actions: tensor([0.0353, 0.0213, 0.0185, 0.0306, 0.0279, 0.0210, 0.0276, 0.0196, 0.0193,\n", + " 0.0202, 0.0235, 0.0221, 0.0134, 0.0252, 0.0158, 0.0175, 0.0133, 0.0166,\n", + " 0.0248, 0.0284, 0.0206, 0.0145, 0.0351, 0.0204, 0.0225],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "130000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 8, 5, 20, 2, 25, 19, 49, 43, 10, 34, 49, 20, 36, 31, 3, 45, 33,\n", + " 4, 38, 47, 42, 36, 26, 15])\n", + "loss= tensor(149.3802, grad_fn=) , actor= tensor(2.0264, grad_fn=) , critic= tensor(1473.5378, grad_fn=) , return= 167326.74684623882\n", + "probs of actions: tensor([0.0403, 0.0130, 0.0142, 0.0193, 0.0127, 0.0201, 0.0182, 0.0162, 0.0331,\n", + " 0.0146, 0.0283, 0.0161, 0.0197, 0.0187, 0.0286, 0.0133, 0.0239, 0.0189,\n", + " 0.0110, 0.0216, 0.0220, 0.0299, 0.0188, 0.0266, 0.0171],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "131000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 15, 48, 39, 39, 18, 21, 32, 5, 40, 1, 3, 30, 12, 38, 26, 7, 32,\n", + " 3, 23, 39, 38, 41, 40, 5])\n", + "loss= tensor(148.0401, grad_fn=) , actor= tensor(-6.3673, grad_fn=) , critic= tensor(1544.0732, grad_fn=) , return= 166283.62052974632\n", + "probs of actions: tensor([0.0398, 0.0167, 0.0162, 0.0246, 0.0246, 0.0167, 0.0133, 0.0232, 0.0141,\n", + " 0.0235, 0.0098, 0.0134, 0.0193, 0.0135, 0.0215, 0.0266, 0.0158, 0.0230,\n", + " 0.0132, 0.0206, 0.0241, 0.0216, 0.0250, 0.0247, 0.0143],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "132000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 27, 13, 12, 34, 17, 42, 23, 30, 6, 4, 36, 43, 5, 23, 29, 29, 21,\n", + " 39, 42, 39, 1, 10, 44, 11])\n", + "loss= tensor(153.7693, grad_fn=) , actor= tensor(-5.7817, grad_fn=) , critic= tensor(1595.5100, grad_fn=) , return= 166657.67572387197\n", + "probs of actions: tensor([0.0284, 0.0178, 0.0179, 0.0136, 0.0278, 0.0179, 0.0321, 0.0208, 0.0196,\n", + " 0.0127, 0.0105, 0.0187, 0.0328, 0.0143, 0.0206, 0.0282, 0.0283, 0.0141,\n", + " 0.0241, 0.0308, 0.0241, 0.0100, 0.0147, 0.0276, 0.0148],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "133000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 38, 44, 20, 5, 39, 43, 3, 45, 15, 38, 29, 24, 34, 46, 19, 33, 38,\n", + " 6, 31, 21, 27, 28, 29, 42])\n", + "loss= tensor(177.1899, grad_fn=) , actor= tensor(0.4185, grad_fn=) , critic= tensor(1767.7139, grad_fn=) , return= 168746.4879405506\n", + "probs of actions: tensor([0.0392, 0.0213, 0.0268, 0.0192, 0.0142, 0.0245, 0.0337, 0.0135, 0.0238,\n", + " 0.0166, 0.0216, 0.0277, 0.0229, 0.0285, 0.0374, 0.0184, 0.0181, 0.0217,\n", + " 0.0130, 0.0287, 0.0144, 0.0175, 0.0203, 0.0287, 0.0306],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "134000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 4, 10, 43, 20, 8, 4, 2, 26, 29, 31, 41, 27, 0, 9, 17, 30, 35,\n", + " 25, 7, 27, 41, 42, 48, 16])\n", + "loss= tensor(133.7216, grad_fn=) , actor= tensor(-12.5985, grad_fn=) , critic= tensor(1463.2018, grad_fn=) , return= 163313.87970904517\n", + "probs of actions: tensor([0.0354, 0.0099, 0.0141, 0.0351, 0.0193, 0.0125, 0.0101, 0.0123, 0.0269,\n", + " 0.0275, 0.0285, 0.0268, 0.0173, 0.0100, 0.0138, 0.0179, 0.0192, 0.0255,\n", + " 0.0211, 0.0154, 0.0173, 0.0256, 0.0310, 0.0160, 0.0177],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "135000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 6, 49, 6, 45, 35, 43, 41, 36, 35, 39, 38, 22, 15, 30, 37, 3, 35,\n", + " 1, 42, 25, 29, 5, 44, 47])\n", + "loss= tensor(184.4749, grad_fn=) , actor= tensor(-6.7247, grad_fn=) , critic= tensor(1911.9955, grad_fn=) , return= 166933.74737790338\n", + "probs of actions: tensor([0.0370, 0.0125, 0.0169, 0.0124, 0.0233, 0.0255, 0.0348, 0.0272, 0.0186,\n", + " 0.0256, 0.0246, 0.0214, 0.0164, 0.0160, 0.0193, 0.0369, 0.0127, 0.0254,\n", + " 0.0095, 0.0321, 0.0213, 0.0282, 0.0143, 0.0279, 0.0225],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "136000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 2, 29, 25, 21, 46, 20, 14, 25, 25, 2, 41, 24, 33, 16, 8, 31, 37,\n", + " 37, 30, 13, 29, 18, 34, 36])\n", + "loss= tensor(161.7658, grad_fn=) , actor= tensor(-3.6113, grad_fn=) , critic= tensor(1653.7708, grad_fn=) , return= 166494.2550381319\n", + "probs of actions: tensor([0.0403, 0.0120, 0.0262, 0.0206, 0.0135, 0.0402, 0.0194, 0.0150, 0.0209,\n", + " 0.0209, 0.0121, 0.0268, 0.0240, 0.0181, 0.0180, 0.0122, 0.0290, 0.0370,\n", + " 0.0370, 0.0191, 0.0171, 0.0283, 0.0168, 0.0293, 0.0187],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "137000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 47, 34, 20, 41, 49, 43, 35, 49, 41, 37, 45, 29, 28, 13, 11, 6, 25,\n", + " 39, 41, 12, 29, 14, 4, 29])\n", + "loss= tensor(196.7570, grad_fn=) , actor= tensor(2.1995, grad_fn=) , critic= tensor(1945.5753, grad_fn=) , return= 171683.5268367168\n", + "probs of actions: tensor([0.0359, 0.0221, 0.0285, 0.0195, 0.0279, 0.0162, 0.0346, 0.0261, 0.0161,\n", + " 0.0269, 0.0376, 0.0242, 0.0279, 0.0203, 0.0170, 0.0143, 0.0123, 0.0213,\n", + " 0.0249, 0.0255, 0.0128, 0.0288, 0.0157, 0.0103, 0.0290],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "138000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 37, 13, 37, 42, 23, 2, 32, 36, 10, 24, 37, 47, 22, 34, 0, 31, 31,\n", + " 31, 43, 24, 40, 5, 16, 45])\n", + "loss= tensor(169.8274, grad_fn=) , actor= tensor(-4.8154, grad_fn=) , critic= tensor(1746.4282, grad_fn=) , return= 167707.9668063331\n", + "probs of actions: tensor([0.0273, 0.0376, 0.0172, 0.0377, 0.0328, 0.0204, 0.0115, 0.0245, 0.0185,\n", + " 0.0142, 0.0241, 0.0374, 0.0221, 0.0165, 0.0302, 0.0094, 0.0294, 0.0296,\n", + " 0.0296, 0.0325, 0.0243, 0.0252, 0.0136, 0.0179, 0.0240],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "139000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 32, 13, 18, 35, 37, 42, 7, 17, 27, 35, 2, 43, 4, 18, 15, 4, 26,\n", + " 47, 40, 26, 15, 13, 47, 31])\n", + "loss= tensor(148.1212, grad_fn=) , actor= tensor(-13.0168, grad_fn=) , critic= tensor(1611.3794, grad_fn=) , return= 164274.70542077557\n", + "probs of actions: tensor([0.0170, 0.0242, 0.0170, 0.0170, 0.0269, 0.0384, 0.0331, 0.0148, 0.0178,\n", + " 0.0174, 0.0271, 0.0115, 0.0341, 0.0098, 0.0171, 0.0159, 0.0100, 0.0281,\n", + " 0.0216, 0.0250, 0.0281, 0.0161, 0.0168, 0.0215, 0.0302],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "140000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 23, 28, 39, 26, 11, 33, 37, 35, 28, 29, 46, 27, 29, 13, 43, 45, 45,\n", + " 46, 9, 34, 6, 31, 26, 37])\n", + "loss= tensor(179.7397, grad_fn=) , actor= tensor(5.8541, grad_fn=) , critic= tensor(1738.8556, grad_fn=) , return= 169447.88640735732\n", + "probs of actions: tensor([0.0088, 0.0204, 0.0207, 0.0260, 0.0272, 0.0139, 0.0178, 0.0387, 0.0273,\n", + " 0.0207, 0.0281, 0.0390, 0.0177, 0.0284, 0.0168, 0.0337, 0.0243, 0.0243,\n", + " 0.0376, 0.0132, 0.0308, 0.0124, 0.0303, 0.0277, 0.0376],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "141000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 26, 5, 37, 48, 13, 22, 16, 33, 5, 37, 3, 22, 17, 49, 24, 38, 16,\n", + " 22, 43, 39, 28, 31, 5, 20])\n", + "loss= tensor(152.9943, grad_fn=) , actor= tensor(-0.8062, grad_fn=) , critic= tensor(1538.0048, grad_fn=) , return= 167745.39773118478\n", + "probs of actions: tensor([0.0209, 0.0267, 0.0133, 0.0390, 0.0158, 0.0171, 0.0162, 0.0182, 0.0178,\n", + " 0.0133, 0.0386, 0.0123, 0.0165, 0.0177, 0.0163, 0.0240, 0.0212, 0.0179,\n", + " 0.0167, 0.0324, 0.0253, 0.0206, 0.0301, 0.0136, 0.0208],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "142000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 46, 0, 8, 16, 12, 29, 44, 46, 31, 26, 26, 3, 26, 31, 34, 27, 41,\n", + " 49, 9, 6, 14, 25, 31, 14])\n", + "loss= tensor(153.7004, grad_fn=) , actor= tensor(-7.2913, grad_fn=) , critic= tensor(1609.9169, grad_fn=) , return= 166031.2439782173\n", + "probs of actions: tensor([0.0118, 0.0403, 0.0091, 0.0117, 0.0188, 0.0123, 0.0281, 0.0288, 0.0393,\n", + " 0.0303, 0.0268, 0.0269, 0.0123, 0.0269, 0.0305, 0.0316, 0.0176, 0.0266,\n", + " 0.0165, 0.0129, 0.0118, 0.0147, 0.0214, 0.0304, 0.0149],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "143000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 22, 3, 43, 28, 41, 42, 31, 20, 28, 42, 25, 40, 36, 38, 37, 11, 0,\n", + " 46, 44, 45, 31, 47, 29, 10])\n", + "loss= tensor(171.2654, grad_fn=) , actor= tensor(8.0435, grad_fn=) , critic= tensor(1632.2184, grad_fn=) , return= 171821.64604163828\n", + "probs of actions: tensor([0.0341, 0.0155, 0.0129, 0.0363, 0.0205, 0.0290, 0.0336, 0.0300, 0.0201,\n", + " 0.0207, 0.0335, 0.0208, 0.0246, 0.0191, 0.0210, 0.0393, 0.0139, 0.0091,\n", + " 0.0381, 0.0295, 0.0237, 0.0304, 0.0215, 0.0290, 0.0139],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "144000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 8, 29, 32, 15, 43, 46, 3, 15, 27, 41, 31, 33, 7, 23, 37, 5, 33,\n", + " 11, 40, 39, 37, 29, 29, 3])\n", + "loss= tensor(158.2000, grad_fn=) , actor= tensor(2.4426, grad_fn=) , critic= tensor(1557.5732, grad_fn=) , return= 168716.9284871648\n", + "probs of actions: tensor([0.0412, 0.0116, 0.0272, 0.0243, 0.0151, 0.0360, 0.0406, 0.0121, 0.0151,\n", + " 0.0173, 0.0285, 0.0303, 0.0179, 0.0143, 0.0199, 0.0395, 0.0134, 0.0180,\n", + " 0.0139, 0.0251, 0.0256, 0.0392, 0.0295, 0.0295, 0.0117],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "145000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 4, 46, 35, 25, 35, 34, 34, 38, 29, 45, 17, 48, 42, 21, 31, 36, 40,\n", + " 6, 43, 23, 49, 22, 39, 35])\n", + "loss= tensor(183.5701, grad_fn=) , actor= tensor(5.0299, grad_fn=) , critic= tensor(1785.4014, grad_fn=) , return= 171502.26415828618\n", + "probs of actions: tensor([0.0283, 0.0089, 0.0414, 0.0290, 0.0203, 0.0290, 0.0315, 0.0316, 0.0210,\n", + " 0.0280, 0.0241, 0.0180, 0.0148, 0.0332, 0.0133, 0.0302, 0.0190, 0.0251,\n", + " 0.0115, 0.0336, 0.0197, 0.0163, 0.0164, 0.0258, 0.0291],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "146000 adversary: AdversaryModes.myopic\n", + " actions: tensor([36, 31, 0, 14, 46, 12, 17, 7, 17, 32, 24, 45, 46, 27, 34, 35, 23, 37,\n", + " 37, 8, 47, 34, 42, 39, 44])\n", + "loss= tensor(161.3887, grad_fn=) , actor= tensor(0.7270, grad_fn=) , critic= tensor(1606.6173, grad_fn=) , return= 167156.6989969292\n", + "probs of actions: tensor([0.0192, 0.0294, 0.0086, 0.0133, 0.0420, 0.0120, 0.0179, 0.0140, 0.0178,\n", + " 0.0239, 0.0249, 0.0243, 0.0403, 0.0176, 0.0324, 0.0293, 0.0197, 0.0393,\n", + " 0.0393, 0.0113, 0.0219, 0.0323, 0.0326, 0.0256, 0.0295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "147000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 30, 29, 38, 24, 34, 10, 22, 6, 3, 18, 3, 14, 4, 46, 27, 37, 34,\n", + " 29, 14, 27, 23, 20, 36, 43])\n", + "loss= tensor(145.9570, grad_fn=) , actor= tensor(-14.0693, grad_fn=) , critic= tensor(1600.2628, grad_fn=) , return= 163834.75858928217\n", + "probs of actions: tensor([0.0177, 0.0200, 0.0268, 0.0211, 0.0253, 0.0318, 0.0134, 0.0159, 0.0107,\n", + " 0.0117, 0.0170, 0.0116, 0.0137, 0.0091, 0.0402, 0.0177, 0.0399, 0.0322,\n", + " 0.0289, 0.0140, 0.0176, 0.0196, 0.0208, 0.0192, 0.0328],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "148000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 16, 24, 39, 34, 37, 47, 38, 31, 43, 6, 41, 7, 31, 31, 22, 34, 34,\n", + " 29, 42, 22, 23, 45, 17, 31])\n", + "loss= tensor(183.2300, grad_fn=) , actor= tensor(7.5120, grad_fn=) , critic= tensor(1757.1793, grad_fn=) , return= 171618.05804481165\n", + "probs of actions: tensor([0.0165, 0.0181, 0.0249, 0.0263, 0.0317, 0.0403, 0.0221, 0.0211, 0.0301,\n", + " 0.0363, 0.0109, 0.0285, 0.0139, 0.0302, 0.0304, 0.0163, 0.0325, 0.0324,\n", + " 0.0291, 0.0325, 0.0164, 0.0195, 0.0249, 0.0180, 0.0303],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "149000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 10, 10, 13, 42, 3, 16, 30, 49, 24, 28, 40, 32, 15, 37, 42, 15, 32,\n", + " 40, 33, 38, 24, 29, 30, 22])\n", + "loss= tensor(161.8389, grad_fn=) , actor= tensor(5.2990, grad_fn=) , critic= tensor(1565.3983, grad_fn=) , return= 169522.6685312421\n", + "probs of actions: tensor([0.0304, 0.0128, 0.0129, 0.0165, 0.0348, 0.0117, 0.0183, 0.0198, 0.0159,\n", + " 0.0250, 0.0205, 0.0249, 0.0241, 0.0153, 0.0404, 0.0334, 0.0154, 0.0239,\n", + " 0.0256, 0.0183, 0.0214, 0.0245, 0.0290, 0.0192, 0.0166],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "150000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 20, 30, 20, 46, 6, 40, 5, 37, 3, 17, 33, 38, 9, 38, 42, 46, 37,\n", + " 41, 45, 24, 13, 0, 49, 10])\n", + "loss= tensor(148.9517, grad_fn=) , actor= tensor(-7.6314, grad_fn=) , critic= tensor(1565.8309, grad_fn=) , return= 167204.81101993096\n", + "probs of actions: tensor([0.0165, 0.0197, 0.0203, 0.0197, 0.0420, 0.0105, 0.0245, 0.0130, 0.0412,\n", + " 0.0114, 0.0179, 0.0177, 0.0217, 0.0122, 0.0218, 0.0334, 0.0394, 0.0408,\n", + " 0.0277, 0.0248, 0.0251, 0.0165, 0.0085, 0.0157, 0.0136],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "151000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 42, 37, 36, 11, 34, 17, 41, 30, 5, 23, 37, 37, 46, 43, 24, 16, 44,\n", + " 31, 23, 33, 35, 25, 44, 43])\n", + "loss= tensor(176.3898, grad_fn=) , actor= tensor(3.1738, grad_fn=) , critic= tensor(1732.1602, grad_fn=) , return= 169785.9708791693\n", + "probs of actions: tensor([0.0186, 0.0354, 0.0416, 0.0191, 0.0131, 0.0329, 0.0179, 0.0297, 0.0199,\n", + " 0.0128, 0.0195, 0.0413, 0.0413, 0.0397, 0.0356, 0.0251, 0.0180, 0.0309,\n", + " 0.0299, 0.0195, 0.0179, 0.0281, 0.0214, 0.0307, 0.0338],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "152000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 31, 16, 40, 4, 43, 18, 42, 18, 11, 34, 37, 31, 45, 19, 43, 9, 24,\n", + " 33, 13, 2, 38, 9, 0, 9])\n", + "loss= tensor(156.6243, grad_fn=) , actor= tensor(-16.0506, grad_fn=) , critic= tensor(1726.7491, grad_fn=) , return= 167386.4148504224\n", + "probs of actions: tensor([0.0158, 0.0289, 0.0182, 0.0241, 0.0081, 0.0389, 0.0164, 0.0359, 0.0164,\n", + " 0.0131, 0.0332, 0.0412, 0.0297, 0.0249, 0.0162, 0.0365, 0.0122, 0.0248,\n", + " 0.0178, 0.0164, 0.0102, 0.0222, 0.0122, 0.0083, 0.0122],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "153000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 9, 19, 42, 24, 2, 32, 12, 47, 5, 27, 46, 31, 33, 41, 37, 23, 43, 31,\n", + " 31, 7, 40, 37, 22, 1, 23])\n", + "loss= tensor(162.8978, grad_fn=) , actor= tensor(0.7076, grad_fn=) , critic= tensor(1621.9019, grad_fn=) , return= 168733.7741561521\n", + "probs of actions: tensor([0.0129, 0.0159, 0.0361, 0.0257, 0.0096, 0.0241, 0.0115, 0.0223, 0.0125,\n", + " 0.0174, 0.0406, 0.0299, 0.0173, 0.0290, 0.0413, 0.0200, 0.0359, 0.0300,\n", + " 0.0299, 0.0133, 0.0258, 0.0407, 0.0166, 0.0077, 0.0199],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "154000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 22, 7, 5, 46, 16, 47, 24, 46, 16, 34, 6, 39, 10, 34, 37, 7, 38,\n", + " 11, 27, 43, 47, 38, 24, 28])\n", + "loss= tensor(152.5648, grad_fn=) , actor= tensor(-2.3837, grad_fn=) , critic= tensor(1549.4846, grad_fn=) , return= 167254.51434747037\n", + "probs of actions: tensor([0.0391, 0.0156, 0.0132, 0.0121, 0.0415, 0.0180, 0.0221, 0.0256, 0.0407,\n", + " 0.0178, 0.0332, 0.0103, 0.0262, 0.0128, 0.0334, 0.0418, 0.0132, 0.0222,\n", + " 0.0132, 0.0176, 0.0347, 0.0220, 0.0222, 0.0249, 0.0197],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "155000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 13, 10, 42, 29, 22, 30, 5, 34, 23, 20, 47, 36, 19, 21, 47, 23, 48,\n", + " 47, 20, 24, 24, 17, 11, 46])\n", + "loss= tensor(170.7418, grad_fn=) , actor= tensor(-2.4301, grad_fn=) , critic= tensor(1731.7192, grad_fn=) , return= 168131.15815025172\n", + "probs of actions: tensor([0.0240, 0.0162, 0.0121, 0.0371, 0.0270, 0.0159, 0.0199, 0.0120, 0.0336,\n", + " 0.0202, 0.0209, 0.0222, 0.0198, 0.0161, 0.0127, 0.0221, 0.0201, 0.0149,\n", + " 0.0221, 0.0212, 0.0246, 0.0246, 0.0179, 0.0131, 0.0370],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "156000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 16, 45, 11, 6, 42, 42, 31, 13, 46, 38, 38, 24, 46, 34, 37, 16, 27,\n", + " 28, 28, 8, 39, 30, 33, 26])\n", + "loss= tensor(172.8705, grad_fn=) , actor= tensor(1.5910, grad_fn=) , critic= tensor(1712.7946, grad_fn=) , return= 170315.0665116964\n", + "probs of actions: tensor([0.0204, 0.0177, 0.0238, 0.0128, 0.0098, 0.0376, 0.0370, 0.0297, 0.0160,\n", + " 0.0401, 0.0223, 0.0224, 0.0248, 0.0392, 0.0340, 0.0418, 0.0172, 0.0177,\n", + " 0.0198, 0.0198, 0.0107, 0.0257, 0.0191, 0.0177, 0.0287],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "157000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 25, 19, 29, 28, 5, 43, 35, 46, 24, 36, 42, 27, 17, 37, 49, 36, 31,\n", + " 29, 14, 42, 31, 46, 31, 40])\n", + "loss= tensor(181.3515, grad_fn=) , actor= tensor(9.1464, grad_fn=) , critic= tensor(1722.0505, grad_fn=) , return= 171188.9414872887\n", + "probs of actions: tensor([0.0166, 0.0209, 0.0159, 0.0272, 0.0206, 0.0114, 0.0387, 0.0291, 0.0407,\n", + " 0.0253, 0.0200, 0.0366, 0.0175, 0.0178, 0.0420, 0.0148, 0.0201, 0.0303,\n", + " 0.0290, 0.0135, 0.0356, 0.0304, 0.0378, 0.0304, 0.0260],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "158000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 29, 43, 36, 43, 40, 34, 1, 33, 35, 23, 13, 48, 0, 2, 21, 39, 35,\n", + " 49, 41, 22, 4, 13, 15, 29])\n", + "loss= tensor(158.4941, grad_fn=) , actor= tensor(-10.7465, grad_fn=) , critic= tensor(1692.4060, grad_fn=) , return= 167265.5318516014\n", + "probs of actions: tensor([0.0157, 0.0274, 0.0391, 0.0200, 0.0387, 0.0241, 0.0340, 0.0069, 0.0166,\n", + " 0.0294, 0.0201, 0.0155, 0.0147, 0.0076, 0.0092, 0.0129, 0.0264, 0.0293,\n", + " 0.0145, 0.0296, 0.0166, 0.0080, 0.0157, 0.0158, 0.0300],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "159000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 15, 48, 43, 13, 42, 35, 38, 42, 22, 29, 45, 4, 35, 20, 17, 37, 5,\n", + " 31, 42, 44, 25, 42, 27, 6])\n", + "loss= tensor(168.9411, grad_fn=) , actor= tensor(2.2963, grad_fn=) , critic= tensor(1666.4485, grad_fn=) , return= 171372.80850459848\n", + "probs of actions: tensor([0.0414, 0.0153, 0.0151, 0.0387, 0.0155, 0.0373, 0.0289, 0.0222, 0.0367,\n", + " 0.0159, 0.0298, 0.0243, 0.0076, 0.0288, 0.0209, 0.0176, 0.0435, 0.0112,\n", + " 0.0301, 0.0353, 0.0318, 0.0219, 0.0352, 0.0179, 0.0100],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "160000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 13, 2, 9, 29, 12, 24, 42, 17, 36, 15, 11, 20, 31, 1, 49, 38, 35,\n", + " 43, 7, 25, 11, 16, 43, 29])\n", + "loss= tensor(144.1372, grad_fn=) , actor= tensor(-13.0317, grad_fn=) , critic= tensor(1571.6891, grad_fn=) , return= 163501.7686090762\n", + "probs of actions: tensor([0.0154, 0.0154, 0.0087, 0.0118, 0.0291, 0.0113, 0.0250, 0.0373, 0.0175,\n", + " 0.0197, 0.0153, 0.0124, 0.0212, 0.0299, 0.0069, 0.0142, 0.0224, 0.0290,\n", + " 0.0360, 0.0125, 0.0219, 0.0127, 0.0176, 0.0350, 0.0311],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "161000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 6, 11, 37, 15, 38, 20, 17, 27, 44, 47, 36, 46, 44, 10, 21, 43, 43, 16,\n", + " 45, 24, 35, 28, 26, 24, 43])\n", + "loss= tensor(177.9678, grad_fn=) , actor= tensor(7.4094, grad_fn=) , critic= tensor(1705.5844, grad_fn=) , return= 169354.8327124643\n", + "probs of actions: tensor([0.0091, 0.0123, 0.0458, 0.0149, 0.0221, 0.0203, 0.0172, 0.0181, 0.0322,\n", + " 0.0211, 0.0200, 0.0413, 0.0324, 0.0119, 0.0128, 0.0369, 0.0364, 0.0174,\n", + " 0.0238, 0.0252, 0.0290, 0.0202, 0.0288, 0.0249, 0.0352],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "162000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 23, 24, 29, 12, 11, 1, 10, 5, 23, 39, 16, 42, 39, 46, 12, 30, 29,\n", + " 39, 26, 18, 35, 45, 4, 23])\n", + "loss= tensor(139.6571, grad_fn=) , actor= tensor(-9.4431, grad_fn=) , critic= tensor(1491.0017, grad_fn=) , return= 166463.4013158164\n", + "probs of actions: tensor([0.0203, 0.0204, 0.0260, 0.0285, 0.0110, 0.0122, 0.0064, 0.0115, 0.0104,\n", + " 0.0202, 0.0268, 0.0173, 0.0380, 0.0266, 0.0413, 0.0111, 0.0200, 0.0304,\n", + " 0.0265, 0.0288, 0.0169, 0.0292, 0.0237, 0.0075, 0.0202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "163000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 8, 44, 31, 28, 44, 24, 32, 0, 16, 13, 34, 13, 6, 31, 27, 38, 19,\n", + " 33, 10, 35, 48, 3, 3, 49])\n", + "loss= tensor(154.1051, grad_fn=) , actor= tensor(-23.9131, grad_fn=) , critic= tensor(1780.1824, grad_fn=) , return= 164529.4793550289\n", + "probs of actions: tensor([0.0438, 0.0100, 0.0317, 0.0295, 0.0206, 0.0322, 0.0261, 0.0241, 0.0069,\n", + " 0.0175, 0.0150, 0.0349, 0.0150, 0.0089, 0.0301, 0.0180, 0.0221, 0.0149,\n", + " 0.0172, 0.0119, 0.0296, 0.0150, 0.0104, 0.0103, 0.0138],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "164000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 14, 45, 15, 46, 17, 32, 37, 22, 39, 49, 47, 23, 42, 44, 36, 23, 49,\n", + " 3, 30, 17, 33, 28, 18, 26])\n", + "loss= tensor(180.0185, grad_fn=) , actor= tensor(2.8938, grad_fn=) , critic= tensor(1771.2471, grad_fn=) , return= 171791.86226487876\n", + "probs of actions: tensor([0.0472, 0.0122, 0.0228, 0.0148, 0.0439, 0.0173, 0.0245, 0.0478, 0.0157,\n", + " 0.0271, 0.0137, 0.0216, 0.0201, 0.0382, 0.0325, 0.0207, 0.0201, 0.0138,\n", + " 0.0102, 0.0198, 0.0174, 0.0172, 0.0204, 0.0169, 0.0282],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "165000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 49, 40, 37, 15, 35, 23, 35, 36, 48, 32, 31, 6, 28, 5, 44, 16, 32,\n", + " 38, 7, 26, 34, 38, 44, 24])\n", + "loss= tensor(176.1493, grad_fn=) , actor= tensor(1.4827, grad_fn=) , critic= tensor(1746.6658, grad_fn=) , return= 170191.33195795456\n", + "probs of actions: tensor([0.0250, 0.0139, 0.0233, 0.0473, 0.0149, 0.0298, 0.0201, 0.0300, 0.0203,\n", + " 0.0148, 0.0248, 0.0301, 0.0087, 0.0208, 0.0100, 0.0328, 0.0167, 0.0246,\n", + " 0.0220, 0.0117, 0.0286, 0.0343, 0.0221, 0.0326, 0.0254],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "166000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 45, 15, 5, 47, 25, 33, 20, 17, 48, 42, 18, 36, 42, 21, 36, 37, 39,\n", + " 27, 42, 23, 6, 42, 29, 41])\n", + "loss= tensor(180.1258, grad_fn=) , actor= tensor(5.3207, grad_fn=) , critic= tensor(1748.0511, grad_fn=) , return= 169629.91091204734\n", + "probs of actions: tensor([0.0208, 0.0226, 0.0147, 0.0098, 0.0213, 0.0212, 0.0167, 0.0210, 0.0168,\n", + " 0.0147, 0.0393, 0.0163, 0.0201, 0.0391, 0.0125, 0.0202, 0.0472, 0.0276,\n", + " 0.0182, 0.0384, 0.0202, 0.0090, 0.0382, 0.0319, 0.0313],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "167000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 44, 46, 21, 46, 21, 39, 26, 44, 22, 37, 36, 31, 29, 31, 41, 48, 28,\n", + " 34, 26, 45, 20, 34, 28, 32])\n", + "loss= tensor(192.6754, grad_fn=) , actor= tensor(10.1870, grad_fn=) , critic= tensor(1824.8831, grad_fn=) , return= 174443.8514404321\n", + "probs of actions: tensor([0.0435, 0.0314, 0.0439, 0.0121, 0.0439, 0.0121, 0.0283, 0.0280, 0.0326,\n", + " 0.0158, 0.0485, 0.0199, 0.0305, 0.0316, 0.0305, 0.0325, 0.0148, 0.0202,\n", + " 0.0359, 0.0283, 0.0230, 0.0218, 0.0360, 0.0200, 0.0239],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "168000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 37, 24, 37, 2, 31, 12, 49, 37, 35, 38, 5, 13, 41, 10, 38, 37, 39,\n", + " 25, 45, 39, 46, 23, 39, 30])\n", + "loss= tensor(157.1108, grad_fn=) , actor= tensor(-0.5216, grad_fn=) , critic= tensor(1576.3247, grad_fn=) , return= 169936.64910369547\n", + "probs of actions: tensor([0.0292, 0.0486, 0.0271, 0.0488, 0.0074, 0.0292, 0.0097, 0.0133, 0.0488,\n", + " 0.0302, 0.0219, 0.0095, 0.0146, 0.0326, 0.0117, 0.0221, 0.0482, 0.0283,\n", + " 0.0223, 0.0229, 0.0282, 0.0394, 0.0200, 0.0281, 0.0197],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "169000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 43, 43, 43, 26, 18, 41, 19, 37, 32, 33, 24, 13, 47, 44, 19, 22, 33,\n", + " 28, 10, 24, 10, 39, 37, 30])\n", + "loss= tensor(182.3041, grad_fn=) , actor= tensor(-4.0238, grad_fn=) , critic= tensor(1863.2794, grad_fn=) , return= 170846.58154866938\n", + "probs of actions: tensor([0.0446, 0.0430, 0.0432, 0.0431, 0.0281, 0.0166, 0.0337, 0.0138, 0.0485,\n", + " 0.0248, 0.0172, 0.0264, 0.0146, 0.0217, 0.0329, 0.0140, 0.0164, 0.0174,\n", + " 0.0195, 0.0120, 0.0260, 0.0121, 0.0279, 0.0472, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "170000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 31, 34, 21, 0, 16, 21, 41, 43, 7, 49, 45, 49, 24, 14, 45, 49, 33,\n", + " 40, 45, 17, 14, 31, 17, 48])\n", + "loss= tensor(164.5307, grad_fn=) , actor= tensor(-5.8366, grad_fn=) , critic= tensor(1703.6732, grad_fn=) , return= 168518.29220492937\n", + "probs of actions: tensor([0.0277, 0.0298, 0.0363, 0.0119, 0.0061, 0.0174, 0.0117, 0.0336, 0.0431,\n", + " 0.0106, 0.0132, 0.0225, 0.0132, 0.0264, 0.0121, 0.0225, 0.0133, 0.0173,\n", + " 0.0254, 0.0225, 0.0164, 0.0124, 0.0304, 0.0164, 0.0147],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "171000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 7, 13, 41, 39, 4, 18, 36, 25, 38, 47, 20, 29, 32, 41, 40, 33, 1,\n", + " 24, 34, 31, 34, 27, 47, 45])\n", + "loss= tensor(172.5558, grad_fn=) , actor= tensor(-1.5348, grad_fn=) , critic= tensor(1740.9058, grad_fn=) , return= 167746.71918282693\n", + "probs of actions: tensor([0.0217, 0.0106, 0.0142, 0.0351, 0.0288, 0.0058, 0.0164, 0.0197, 0.0215,\n", + " 0.0224, 0.0218, 0.0217, 0.0313, 0.0249, 0.0330, 0.0252, 0.0166, 0.0058,\n", + " 0.0256, 0.0378, 0.0305, 0.0377, 0.0187, 0.0215, 0.0225],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "172000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 41, 25, 0, 8, 42, 42, 44, 9, 23, 29, 34, 8, 27, 15, 31, 36, 42,\n", + " 26, 37, 35, 43, 7, 18, 42])\n", + "loss= tensor(167.8437, grad_fn=) , actor= tensor(-0.3421, grad_fn=) , critic= tensor(1681.8577, grad_fn=) , return= 167893.4010535553\n", + "probs of actions: tensor([0.0217, 0.0361, 0.0211, 0.0060, 0.0087, 0.0406, 0.0401, 0.0340, 0.0105,\n", + " 0.0198, 0.0310, 0.0375, 0.0088, 0.0184, 0.0148, 0.0304, 0.0201, 0.0388,\n", + " 0.0282, 0.0486, 0.0308, 0.0399, 0.0107, 0.0166, 0.0381],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "173000 adversary: AdversaryModes.myopic\n", + " actions: tensor([15, 39, 47, 34, 41, 13, 13, 42, 39, 47, 14, 48, 37, 24, 27, 27, 6, 16,\n", + " 31, 25, 15, 22, 37, 31, 17])\n", + "loss= tensor(174.8607, grad_fn=) , actor= tensor(-0.6168, grad_fn=) , critic= tensor(1754.7747, grad_fn=) , return= 170218.8473160157\n", + "probs of actions: tensor([0.0144, 0.0296, 0.0218, 0.0367, 0.0357, 0.0140, 0.0139, 0.0401, 0.0294,\n", + " 0.0217, 0.0119, 0.0141, 0.0495, 0.0258, 0.0184, 0.0184, 0.0078, 0.0170,\n", + " 0.0308, 0.0226, 0.0151, 0.0163, 0.0483, 0.0308, 0.0165],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "174000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 24, 16, 45, 29, 7, 5, 46, 41, 42, 20, 24, 4, 2, 29, 40, 17, 20,\n", + " 47, 20, 11, 45, 24, 27, 33])\n", + "loss= tensor(142.8810, grad_fn=) , actor= tensor(-14.7751, grad_fn=) , critic= tensor(1576.5607, grad_fn=) , return= 164515.12730923443\n", + "probs of actions: tensor([0.0059, 0.0263, 0.0172, 0.0218, 0.0306, 0.0100, 0.0086, 0.0462, 0.0346,\n", + " 0.0394, 0.0214, 0.0261, 0.0057, 0.0068, 0.0324, 0.0259, 0.0161, 0.0219,\n", + " 0.0217, 0.0219, 0.0111, 0.0224, 0.0262, 0.0179, 0.0169],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "175000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 11, 42, 19, 35, 41, 19, 49, 26, 40, 24, 39, 37, 32, 22, 46, 46, 38,\n", + " 34, 9, 23, 7, 30, 5, 15])\n", + "loss= tensor(177.0563, grad_fn=) , actor= tensor(-3.4283, grad_fn=) , critic= tensor(1804.8457, grad_fn=) , return= 171984.12264133606\n", + "probs of actions: tensor([0.0208, 0.0105, 0.0405, 0.0135, 0.0302, 0.0357, 0.0133, 0.0127, 0.0286,\n", + " 0.0256, 0.0263, 0.0301, 0.0528, 0.0262, 0.0150, 0.0442, 0.0438, 0.0232,\n", + " 0.0380, 0.0099, 0.0191, 0.0103, 0.0196, 0.0088, 0.0145],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "176000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 46, 21, 27, 40, 19, 35, 36, 49, 16, 22, 14, 48, 35, 42, 21, 45, 33,\n", + " 28, 40, 32, 47, 31, 32, 32])\n", + "loss= tensor(178.1848, grad_fn=) , actor= tensor(11.2565, grad_fn=) , critic= tensor(1669.2828, grad_fn=) , return= 172492.74613842374\n", + "probs of actions: tensor([0.0206, 0.0472, 0.0114, 0.0179, 0.0258, 0.0131, 0.0304, 0.0193, 0.0128,\n", + " 0.0170, 0.0148, 0.0118, 0.0140, 0.0307, 0.0393, 0.0117, 0.0224, 0.0167,\n", + " 0.0187, 0.0274, 0.0262, 0.0217, 0.0311, 0.0261, 0.0261],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "177000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 38, 32, 9, 2, 27, 24, 16, 43, 39, 41, 31, 39, 42, 37, 35, 24, 41,\n", + " 43, 40, 41, 37, 41, 20, 43])\n", + "loss= tensor(175.0616, grad_fn=) , actor= tensor(11.4341, grad_fn=) , critic= tensor(1636.2749, grad_fn=) , return= 171280.98224559028\n", + "probs of actions: tensor([0.0176, 0.0232, 0.0264, 0.0099, 0.0063, 0.0179, 0.0262, 0.0171, 0.0438,\n", + " 0.0305, 0.0356, 0.0312, 0.0305, 0.0396, 0.0534, 0.0307, 0.0259, 0.0345,\n", + " 0.0408, 0.0271, 0.0340, 0.0526, 0.0338, 0.0212, 0.0399],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "178000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 43, 29, 38, 34, 27, 32, 13, 47, 40, 20, 36, 37, 26, 25, 39, 42, 9,\n", + " 39, 31, 44, 34, 37, 42, 34])\n", + "loss= tensor(185.7419, grad_fn=) , actor= tensor(10.0187, grad_fn=) , critic= tensor(1757.2313, grad_fn=) , return= 172883.60511346153\n", + "probs of actions: tensor([0.0384, 0.0449, 0.0315, 0.0237, 0.0384, 0.0183, 0.0260, 0.0134, 0.0219,\n", + " 0.0264, 0.0207, 0.0192, 0.0529, 0.0303, 0.0221, 0.0299, 0.0392, 0.0094,\n", + " 0.0298, 0.0310, 0.0338, 0.0389, 0.0518, 0.0384, 0.0389],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "179000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 11, 25, 43, 47, 33, 32, 44, 33, 40, 29, 37, 45, 34, 41, 37, 26, 14,\n", + " 49, 26, 12, 44, 32, 36, 31])\n", + "loss= tensor(189.5505, grad_fn=) , actor= tensor(6.2532, grad_fn=) , critic= tensor(1832.9723, grad_fn=) , return= 173352.4058806477\n", + "probs of actions: tensor([0.0240, 0.0101, 0.0212, 0.0453, 0.0221, 0.0163, 0.0264, 0.0335, 0.0164,\n", + " 0.0265, 0.0334, 0.0528, 0.0227, 0.0390, 0.0358, 0.0525, 0.0312, 0.0121,\n", + " 0.0128, 0.0312, 0.0084, 0.0334, 0.0258, 0.0194, 0.0312],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "180000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 39, 46, 6, 27, 34, 26, 13, 39, 41, 1, 31, 7, 30, 10, 30, 26, 42,\n", + " 30, 43, 43, 12, 10, 44, 1])\n", + "loss= tensor(146.7328, grad_fn=) , actor= tensor(-13.0647, grad_fn=) , critic= tensor(1597.9749, grad_fn=) , return= 168356.88721261907\n", + "probs of actions: tensor([0.0300, 0.0307, 0.0456, 0.0066, 0.0182, 0.0396, 0.0305, 0.0130, 0.0305,\n", + " 0.0368, 0.0051, 0.0306, 0.0093, 0.0204, 0.0108, 0.0203, 0.0309, 0.0394,\n", + " 0.0203, 0.0418, 0.0414, 0.0084, 0.0110, 0.0337, 0.0055],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "181000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 32, 15, 24, 24, 42, 0, 16, 48, 13, 32, 21, 26, 44, 20, 27, 19, 41,\n", + " 27, 39, 45, 32, 19, 38, 5])\n", + "loss= tensor(148.7295, grad_fn=) , actor= tensor(-5.3524, grad_fn=) , critic= tensor(1540.8190, grad_fn=) , return= 170105.83527341927\n", + "probs of actions: tensor([0.0532, 0.0269, 0.0135, 0.0257, 0.0258, 0.0412, 0.0051, 0.0172, 0.0140,\n", + " 0.0126, 0.0269, 0.0107, 0.0306, 0.0339, 0.0214, 0.0181, 0.0131, 0.0360,\n", + " 0.0182, 0.0303, 0.0231, 0.0263, 0.0134, 0.0253, 0.0081],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "182000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 9, 45, 29, 47, 3, 33, 41, 34, 30, 39, 38, 28, 32, 49, 28, 36, 40,\n", + " 16, 1, 49, 8, 31, 42, 25])\n", + "loss= tensor(174.5400, grad_fn=) , actor= tensor(-3.8577, grad_fn=) , critic= tensor(1783.9773, grad_fn=) , return= 170108.5115089777\n", + "probs of actions: tensor([0.0268, 0.0097, 0.0222, 0.0323, 0.0227, 0.0079, 0.0160, 0.0383, 0.0391,\n", + " 0.0208, 0.0308, 0.0248, 0.0193, 0.0266, 0.0127, 0.0191, 0.0193, 0.0264,\n", + " 0.0168, 0.0050, 0.0129, 0.0084, 0.0318, 0.0396, 0.0227],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "183000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 43, 30, 39, 17, 16, 39, 32, 24, 35, 30, 34, 23, 34, 6, 27, 36, 37,\n", + " 45, 27, 13, 44, 23, 18, 25])\n", + "loss= tensor(167.9819, grad_fn=) , actor= tensor(-3.6270, grad_fn=) , critic= tensor(1716.0896, grad_fn=) , return= 171653.13499200548\n", + "probs of actions: tensor([0.0266, 0.0477, 0.0215, 0.0320, 0.0149, 0.0169, 0.0319, 0.0268, 0.0268,\n", + " 0.0296, 0.0208, 0.0388, 0.0183, 0.0390, 0.0061, 0.0179, 0.0193, 0.0552,\n", + " 0.0229, 0.0180, 0.0122, 0.0326, 0.0185, 0.0148, 0.0226],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "184000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 35, 46, 3, 29, 35, 17, 46, 41, 17, 43, 34, 35, 41, 46, 35, 43, 32,\n", + " 42, 32, 46, 36, 31, 31, 21])\n", + "loss= tensor(175.2364, grad_fn=) , actor= tensor(8.7698, grad_fn=) , critic= tensor(1664.6663, grad_fn=) , return= 174617.73973931262\n", + "probs of actions: tensor([0.0324, 0.0290, 0.0464, 0.0078, 0.0320, 0.0293, 0.0149, 0.0455, 0.0374,\n", + " 0.0149, 0.0459, 0.0388, 0.0295, 0.0364, 0.0436, 0.0296, 0.0439, 0.0269,\n", + " 0.0420, 0.0268, 0.0422, 0.0193, 0.0317, 0.0317, 0.0114],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "185000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 31, 40, 43, 39, 43, 38, 17, 20, 42, 38, 18, 15, 39, 15, 34, 28, 40,\n", + " 16, 35, 25, 27, 17, 46, 44])\n", + "loss= tensor(183.0019, grad_fn=) , actor= tensor(-3.9900, grad_fn=) , critic= tensor(1869.9185, grad_fn=) , return= 170200.26760490437\n", + "probs of actions: tensor([0.0103, 0.0305, 0.0253, 0.0479, 0.0326, 0.0476, 0.0247, 0.0147, 0.0210,\n", + " 0.0447, 0.0248, 0.0144, 0.0131, 0.0323, 0.0132, 0.0393, 0.0193, 0.0269,\n", + " 0.0164, 0.0295, 0.0217, 0.0179, 0.0150, 0.0422, 0.0326],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "186000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 22, 41, 15, 11, 20, 7, 6, 46, 43, 37, 44, 43, 46, 41, 5, 26, 47,\n", + " 45, 37, 43, 43, 24, 26, 2])\n", + "loss= tensor(149.5301, grad_fn=) , actor= tensor(3.2030, grad_fn=) , critic= tensor(1463.2717, grad_fn=) , return= 170375.65698612484\n", + "probs of actions: tensor([0.0087, 0.0140, 0.0395, 0.0130, 0.0095, 0.0208, 0.0084, 0.0058, 0.0458,\n", + " 0.0458, 0.0566, 0.0327, 0.0453, 0.0446, 0.0369, 0.0073, 0.0312, 0.0221,\n", + " 0.0225, 0.0555, 0.0432, 0.0429, 0.0268, 0.0312, 0.0059],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "187000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 36, 42, 44, 13, 39, 17, 34, 17, 37, 20, 18, 15, 46, 41, 25, 38, 33,\n", + " 42, 42, 6, 16, 45, 42, 29])\n", + "loss= tensor(171.4867, grad_fn=) , actor= tensor(-1.7979, grad_fn=) , critic= tensor(1732.8461, grad_fn=) , return= 170572.29641299899\n", + "probs of actions: tensor([0.0243, 0.0184, 0.0452, 0.0318, 0.0120, 0.0337, 0.0145, 0.0396, 0.0145,\n", + " 0.0571, 0.0209, 0.0142, 0.0131, 0.0450, 0.0369, 0.0208, 0.0247, 0.0168,\n", + " 0.0437, 0.0434, 0.0061, 0.0165, 0.0226, 0.0426, 0.0356],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "188000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 41, 15, 31, 32, 44, 17, 9, 14, 42, 20, 18, 37, 20, 2, 41, 31, 40,\n", + " 27, 31, 43, 17, 43, 12, 45])\n", + "loss= tensor(158.2241, grad_fn=) , actor= tensor(-11.8690, grad_fn=) , critic= tensor(1700.9314, grad_fn=) , return= 167973.7337279152\n", + "probs of actions: tensor([0.0480, 0.0402, 0.0126, 0.0306, 0.0274, 0.0327, 0.0143, 0.0086, 0.0105,\n", + " 0.0455, 0.0210, 0.0141, 0.0587, 0.0212, 0.0053, 0.0372, 0.0315, 0.0261,\n", + " 0.0179, 0.0314, 0.0425, 0.0147, 0.0423, 0.0076, 0.0221],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "189000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 32, 34, 46, 29, 29, 10, 34, 24, 46, 34, 24, 7, 8, 43, 3, 11, 9,\n", + " 24, 33, 37, 44, 11, 35, 23])\n", + "loss= tensor(150.4502, grad_fn=) , actor= tensor(-17.2871, grad_fn=) , critic= tensor(1677.3729, grad_fn=) , return= 167663.20399300457\n", + "probs of actions: tensor([0.0203, 0.0275, 0.0402, 0.0471, 0.0348, 0.0352, 0.0100, 0.0412, 0.0268,\n", + " 0.0457, 0.0409, 0.0267, 0.0083, 0.0075, 0.0433, 0.0070, 0.0097, 0.0085,\n", + " 0.0262, 0.0171, 0.0580, 0.0333, 0.0099, 0.0291, 0.0178],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "190000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 6, 41, 46, 40, 35, 48, 40, 42, 27, 25, 44, 43, 44, 4, 35, 18, 21, 18,\n", + " 35, 41, 37, 35, 42, 43, 16])\n", + "loss= tensor(183.7878, grad_fn=) , actor= tensor(10.4855, grad_fn=) , critic= tensor(1733.0234, grad_fn=) , return= 172791.74670569657\n", + "probs of actions: tensor([0.0055, 0.0400, 0.0475, 0.0249, 0.0290, 0.0137, 0.0251, 0.0460, 0.0177,\n", + " 0.0204, 0.0341, 0.0444, 0.0341, 0.0044, 0.0292, 0.0144, 0.0103, 0.0145,\n", + " 0.0293, 0.0362, 0.0592, 0.0293, 0.0438, 0.0414, 0.0163],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "191000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 2, 33, 44, 39, 49, 40, 30, 33, 8, 19, 36, 37, 32, 38, 47, 31, 37, 5,\n", + " 29, 37, 18, 30, 35, 26, 46])\n", + "loss= tensor(190.2138, grad_fn=) , actor= tensor(6.8096, grad_fn=) , critic= tensor(1834.0414, grad_fn=) , return= 170090.89827955028\n", + "probs of actions: tensor([0.0050, 0.0167, 0.0331, 0.0327, 0.0124, 0.0250, 0.0208, 0.0167, 0.0076,\n", + " 0.0109, 0.0192, 0.0596, 0.0278, 0.0246, 0.0220, 0.0324, 0.0590, 0.0066,\n", + " 0.0364, 0.0583, 0.0146, 0.0202, 0.0293, 0.0319, 0.0426],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "192000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 32, 20, 31, 37, 47, 36, 33, 39, 48, 28, 44, 31, 49, 27, 28, 43, 16,\n", + " 15, 6, 44, 30, 39, 29, 30])\n", + "loss= tensor(188.9213, grad_fn=) , actor= tensor(2.9725, grad_fn=) , critic= tensor(1859.4882, grad_fn=) , return= 173056.49058452543\n", + "probs of actions: tensor([0.0473, 0.0278, 0.0191, 0.0323, 0.0606, 0.0223, 0.0194, 0.0170, 0.0327,\n", + " 0.0139, 0.0206, 0.0333, 0.0331, 0.0124, 0.0186, 0.0206, 0.0430, 0.0164,\n", + " 0.0125, 0.0056, 0.0330, 0.0204, 0.0319, 0.0373, 0.0204],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "193000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 49, 44, 46, 41, 46, 47, 46, 41, 14, 29, 44, 45, 43, 31, 14, 15, 36,\n", + " 32, 41, 30, 23, 32, 47, 40])\n", + "loss= tensor(193.5484, grad_fn=) , actor= tensor(0.2783, grad_fn=) , critic= tensor(1932.7013, grad_fn=) , return= 173374.46099056688\n", + "probs of actions: tensor([0.0210, 0.0124, 0.0321, 0.0485, 0.0404, 0.0481, 0.0221, 0.0476, 0.0395,\n", + " 0.0105, 0.0365, 0.0331, 0.0222, 0.0453, 0.0335, 0.0108, 0.0123, 0.0194,\n", + " 0.0280, 0.0371, 0.0204, 0.0176, 0.0279, 0.0218, 0.0266],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "194000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 43, 43, 20, 26, 43, 33, 30, 43, 20, 17, 39, 43, 35, 39, 36, 29, 8,\n", + " 31, 41, 2, 42, 44, 12, 46])\n", + "loss= tensor(180.3984, grad_fn=) , actor= tensor(-9.4811, grad_fn=) , critic= tensor(1898.7952, grad_fn=) , return= 170762.01436648218\n", + "probs of actions: tensor([0.0466, 0.0476, 0.0476, 0.0191, 0.0324, 0.0473, 0.0170, 0.0204, 0.0464,\n", + " 0.0197, 0.0131, 0.0326, 0.0449, 0.0290, 0.0324, 0.0194, 0.0383, 0.0074,\n", + " 0.0336, 0.0371, 0.0052, 0.0445, 0.0328, 0.0069, 0.0428],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "195000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 7, 20, 15, 46, 47, 20, 46, 41, 43, 15, 43, 42, 26, 44, 26, 5, 15,\n", + " 37, 43, 29, 35, 47, 30, 14])\n", + "loss= tensor(164.3884, grad_fn=) , actor= tensor(-0.9193, grad_fn=) , critic= tensor(1653.0768, grad_fn=) , return= 171365.55877032795\n", + "probs of actions: tensor([0.0492, 0.0078, 0.0191, 0.0117, 0.0489, 0.0217, 0.0191, 0.0482, 0.0407,\n", + " 0.0466, 0.0119, 0.0464, 0.0457, 0.0326, 0.0331, 0.0326, 0.0062, 0.0122,\n", + " 0.0579, 0.0434, 0.0369, 0.0289, 0.0214, 0.0200, 0.0110],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "196000 adversary: AdversaryModes.myopic\n", + " actions: tensor([11, 18, 23, 29, 16, 42, 41, 49, 36, 46, 41, 32, 18, 33, 33, 10, 29, 42,\n", + " 6, 46, 32, 16, 34, 21, 46])\n", + "loss= tensor(178.5513, grad_fn=) , actor= tensor(-3.8160, grad_fn=) , critic= tensor(1823.6729, grad_fn=) , return= 169416.70888874226\n", + "probs of actions: tensor([0.0093, 0.0132, 0.0176, 0.0349, 0.0158, 0.0468, 0.0417, 0.0120, 0.0190,\n", + " 0.0493, 0.0407, 0.0284, 0.0133, 0.0170, 0.0172, 0.0099, 0.0372, 0.0448,\n", + " 0.0054, 0.0465, 0.0279, 0.0157, 0.0419, 0.0105, 0.0451],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "197000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 2, 30, 49, 26, 8, 19, 24, 36, 45, 24, 35, 40, 23, 44, 30, 34, 26, 33,\n", + " 26, 35, 18, 42, 42, 39, 43])\n", + "loss= tensor(181.5442, grad_fn=) , actor= tensor(8.6280, grad_fn=) , critic= tensor(1729.1610, grad_fn=) , return= 169717.93829737522\n", + "probs of actions: tensor([0.0046, 0.0213, 0.0118, 0.0331, 0.0070, 0.0106, 0.0268, 0.0184, 0.0220,\n", + " 0.0270, 0.0302, 0.0249, 0.0174, 0.0339, 0.0205, 0.0425, 0.0338, 0.0173,\n", + " 0.0338, 0.0302, 0.0133, 0.0449, 0.0444, 0.0320, 0.0423],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "198000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 37, 47, 44, 47, 34, 32, 27, 46, 48, 32, 37, 22, 43, 49, 38, 12, 37,\n", + " 3, 41, 36, 46, 34, 37, 41])\n", + "loss= tensor(193.2819, grad_fn=) , actor= tensor(7.3999, grad_fn=) , critic= tensor(1858.8199, grad_fn=) , return= 172965.3701108363\n", + "probs of actions: tensor([0.0178, 0.0593, 0.0213, 0.0337, 0.0213, 0.0423, 0.0287, 0.0183, 0.0516,\n", + " 0.0130, 0.0288, 0.0589, 0.0131, 0.0459, 0.0117, 0.0249, 0.0063, 0.0578,\n", + " 0.0061, 0.0396, 0.0187, 0.0477, 0.0425, 0.0569, 0.0388],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "199000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 42, 44, 41, 39, 30, 44, 32, 44, 11, 37, 46, 29, 47, 24, 32, 24, 44,\n", + " 34, 34, 44, 24, 48, 28, 37])\n", + "loss= tensor(187.0922, grad_fn=) , actor= tensor(4.8490, grad_fn=) , critic= tensor(1822.4314, grad_fn=) , return= 174515.57261893307\n", + "probs of actions: tensor([0.0602, 0.0476, 0.0333, 0.0437, 0.0323, 0.0215, 0.0340, 0.0283, 0.0343,\n", + " 0.0092, 0.0602, 0.0512, 0.0379, 0.0210, 0.0265, 0.0282, 0.0263, 0.0343,\n", + " 0.0434, 0.0435, 0.0342, 0.0263, 0.0133, 0.0219, 0.0579],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "200000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 29, 21, 28, 34, 36, 26, 22, 37, 34, 45, 14, 36, 33, 42, 37, 22, 32,\n", + " 45, 39, 34, 43, 20, 24, 47])\n", + "loss= tensor(183.2238, grad_fn=) , actor= tensor(4.6768, grad_fn=) , critic= tensor(1785.4697, grad_fn=) , return= 172605.02280001357\n", + "probs of actions: tensor([0.0295, 0.0358, 0.0093, 0.0221, 0.0439, 0.0182, 0.0333, 0.0125, 0.0612,\n", + " 0.0443, 0.0220, 0.0100, 0.0183, 0.0168, 0.0472, 0.0602, 0.0130, 0.0287,\n", + " 0.0222, 0.0307, 0.0444, 0.0445, 0.0199, 0.0258, 0.0207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "201000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 25, 37, 26, 25, 23, 46, 39, 26, 48, 34, 34, 24, 40, 41, 5, 46, 22,\n", + " 23, 46, 27, 16, 35, 44, 29])\n", + "loss= tensor(175.0091, grad_fn=) , actor= tensor(-1.9302, grad_fn=) , critic= tensor(1769.3928, grad_fn=) , return= 171822.83506567535\n", + "probs of actions: tensor([0.0225, 0.0190, 0.0616, 0.0327, 0.0192, 0.0171, 0.0523, 0.0312, 0.0331,\n", + " 0.0128, 0.0443, 0.0445, 0.0259, 0.0253, 0.0415, 0.0054, 0.0494, 0.0132,\n", + " 0.0172, 0.0483, 0.0187, 0.0155, 0.0296, 0.0348, 0.0401],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "202000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 22, 46, 44, 32, 40, 29, 39, 41, 46, 35, 29, 37, 39, 14, 41, 30, 48,\n", + " 42, 29, 22, 9, 24, 37, 34])\n", + "loss= tensor(193.2345, grad_fn=) , actor= tensor(2.9476, grad_fn=) , critic= tensor(1902.8682, grad_fn=) , return= 173772.7682947857\n", + "probs of actions: tensor([0.0215, 0.0126, 0.0535, 0.0344, 0.0291, 0.0248, 0.0379, 0.0317, 0.0421,\n", + " 0.0516, 0.0300, 0.0388, 0.0606, 0.0315, 0.0103, 0.0405, 0.0206, 0.0129,\n", + " 0.0469, 0.0398, 0.0136, 0.0069, 0.0258, 0.0584, 0.0450],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "203000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 42, 38, 34, 37, 31, 35, 26, 45, 46, 41, 22, 45, 49, 34, 37, 32, 46,\n", + " 15, 30, 4, 44, 20, 36, 35])\n", + "loss= tensor(186.4067, grad_fn=) , actor= tensor(-6.5355, grad_fn=) , critic= tensor(1929.4222, grad_fn=) , return= 173696.63588876135\n", + "probs of actions: tensor([0.0523, 0.0492, 0.0258, 0.0454, 0.0611, 0.0354, 0.0295, 0.0336, 0.0221,\n", + " 0.0503, 0.0412, 0.0131, 0.0222, 0.0116, 0.0461, 0.0596, 0.0296, 0.0481,\n", + " 0.0115, 0.0204, 0.0040, 0.0349, 0.0196, 0.0189, 0.0296],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "204000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 26, 29, 16, 24, 39, 29, 28, 40, 3, 40, 41, 12, 37, 6, 47, 43, 19,\n", + " 49, 30, 43, 46, 35, 45, 32])\n", + "loss= tensor(153.7867, grad_fn=) , actor= tensor(-3.2234, grad_fn=) , critic= tensor(1570.1007, grad_fn=) , return= 170085.52943612626\n", + "probs of actions: tensor([0.0343, 0.0332, 0.0387, 0.0154, 0.0258, 0.0316, 0.0398, 0.0220, 0.0258,\n", + " 0.0055, 0.0260, 0.0404, 0.0058, 0.0592, 0.0047, 0.0206, 0.0443, 0.0104,\n", + " 0.0116, 0.0210, 0.0438, 0.0467, 0.0289, 0.0232, 0.0295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "205000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 37, 41, 13, 41, 44, 42, 22, 46, 41, 32, 33, 42, 29, 31, 31, 30, 46,\n", + " 35, 46, 45, 25, 42, 45, 46])\n", + "loss= tensor(188.9975, grad_fn=) , actor= tensor(5.9601, grad_fn=) , critic= tensor(1830.3740, grad_fn=) , return= 173674.33253358334\n", + "probs of actions: tensor([0.0168, 0.0592, 0.0422, 0.0103, 0.0418, 0.0340, 0.0481, 0.0128, 0.0513,\n", + " 0.0403, 0.0298, 0.0170, 0.0476, 0.0412, 0.0359, 0.0359, 0.0213, 0.0485,\n", + " 0.0293, 0.0481, 0.0232, 0.0202, 0.0459, 0.0233, 0.0467],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "206000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 16, 44, 41, 25, 38, 9, 43, 4, 34, 44, 29, 32, 26, 40, 29, 41, 38,\n", + " 42, 27, 37, 43, 45, 48, 29])\n", + "loss= tensor(166.7714, grad_fn=) , actor= tensor(6.8324, grad_fn=) , critic= tensor(1599.3901, grad_fn=) , return= 170992.57633399224\n", + "probs of actions: tensor([0.0064, 0.0158, 0.0328, 0.0431, 0.0198, 0.0263, 0.0070, 0.0468, 0.0035,\n", + " 0.0481, 0.0337, 0.0413, 0.0302, 0.0336, 0.0269, 0.0420, 0.0400, 0.0267,\n", + " 0.0454, 0.0188, 0.0546, 0.0426, 0.0232, 0.0136, 0.0425],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "207000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 49, 25, 39, 48, 33, 31, 35, 33, 29, 35, 44, 38, 42, 29, 39, 18,\n", + " 32, 46, 24, 10, 39, 43, 43])\n", + "loss= tensor(197.6444, grad_fn=) , actor= tensor(4.4168, grad_fn=) , critic= tensor(1932.2765, grad_fn=) , return= 173133.8207379853\n", + "probs of actions: tensor([0.0397, 0.0469, 0.0112, 0.0197, 0.0323, 0.0129, 0.0171, 0.0358, 0.0288,\n", + " 0.0171, 0.0423, 0.0288, 0.0339, 0.0272, 0.0465, 0.0429, 0.0318, 0.0131,\n", + " 0.0303, 0.0467, 0.0254, 0.0088, 0.0314, 0.0416, 0.0415],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "208000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 27, 26, 38, 37, 30, 28, 18, 28, 24, 41, 38, 42, 26, 34, 40, 18, 17,\n", + " 22, 31, 29, 40, 25, 48, 42])\n", + "loss= tensor(179.0977, grad_fn=) , actor= tensor(-5.2589, grad_fn=) , critic= tensor(1843.5656, grad_fn=) , return= 171314.2710194691\n", + "probs of actions: tensor([0.0271, 0.0187, 0.0316, 0.0271, 0.0569, 0.0222, 0.0227, 0.0125, 0.0227,\n", + " 0.0256, 0.0403, 0.0274, 0.0471, 0.0324, 0.0489, 0.0268, 0.0128, 0.0117,\n", + " 0.0139, 0.0370, 0.0440, 0.0273, 0.0218, 0.0129, 0.0449],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "209000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 38, 24, 26, 36, 47, 39, 44, 38, 31, 29, 18, 38, 42, 41, 43, 43, 21,\n", + " 13, 37, 37, 29, 43, 34, 42])\n", + "loss= tensor(196.6593, grad_fn=) , actor= tensor(11.1738, grad_fn=) , critic= tensor(1854.8550, grad_fn=) , return= 173589.67548152097\n", + "probs of actions: tensor([0.0270, 0.0269, 0.0261, 0.0324, 0.0183, 0.0205, 0.0329, 0.0336, 0.0272,\n", + " 0.0368, 0.0429, 0.0126, 0.0274, 0.0468, 0.0393, 0.0449, 0.0446, 0.0094,\n", + " 0.0102, 0.0546, 0.0544, 0.0441, 0.0433, 0.0492, 0.0451],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "210000 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 31, 37, 36, 34, 16, 42, 25, 38, 41, 29, 42, 23, 36, 44, 20, 35, 26,\n", + " 33, 41, 15, 33, 8, 31, 13])\n", + "loss= tensor(171.5246, grad_fn=) , actor= tensor(-7.3451, grad_fn=) , critic= tensor(1788.6965, grad_fn=) , return= 173527.29930634852\n", + "probs of actions: tensor([0.0088, 0.0353, 0.0555, 0.0184, 0.0505, 0.0148, 0.0474, 0.0207, 0.0274,\n", + " 0.0409, 0.0428, 0.0467, 0.0176, 0.0186, 0.0340, 0.0181, 0.0287, 0.0335,\n", + " 0.0173, 0.0387, 0.0114, 0.0174, 0.0061, 0.0362, 0.0105],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "211000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 23, 23, 41, 43, 42, 30, 27, 26, 7, 40, 38, 4, 40, 43, 34, 29, 22,\n", + " 46, 45, 20, 28, 29, 40, 16])\n", + "loss= tensor(166.3562, grad_fn=) , actor= tensor(-0.6311, grad_fn=) , critic= tensor(1669.8727, grad_fn=) , return= 172318.95775281772\n", + "probs of actions: tensor([0.0332, 0.0175, 0.0175, 0.0436, 0.0473, 0.0464, 0.0220, 0.0177, 0.0331,\n", + " 0.0062, 0.0267, 0.0276, 0.0035, 0.0270, 0.0443, 0.0520, 0.0441, 0.0142,\n", + " 0.0467, 0.0228, 0.0184, 0.0222, 0.0445, 0.0278, 0.0147],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "212000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 31, 34, 16, 26, 30, 26, 39, 41, 42, 45, 34, 41, 28, 17, 33, 25, 40,\n", + " 31, 26, 29, 36, 41, 23, 24])\n", + "loss= tensor(178.3607, grad_fn=) , actor= tensor(2.5544, grad_fn=) , critic= tensor(1758.0624, grad_fn=) , return= 174263.31697267538\n", + "probs of actions: tensor([0.0268, 0.0346, 0.0506, 0.0142, 0.0331, 0.0220, 0.0333, 0.0326, 0.0421,\n", + " 0.0466, 0.0222, 0.0517, 0.0412, 0.0223, 0.0113, 0.0174, 0.0212, 0.0274,\n", + " 0.0357, 0.0338, 0.0446, 0.0190, 0.0389, 0.0175, 0.0250],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "213000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 48, 45, 46, 39, 34, 47, 37, 28, 39, 30, 18, 33, 28, 33, 23, 26, 31,\n", + " 37, 24, 47, 42, 43, 35, 29])\n", + "loss= tensor(189.6743, grad_fn=) , actor= tensor(12.7010, grad_fn=) , critic= tensor(1769.7332, grad_fn=) , return= 173155.54474284835\n", + "probs of actions: tensor([0.0032, 0.0122, 0.0214, 0.0502, 0.0321, 0.0515, 0.0204, 0.0584, 0.0224,\n", + " 0.0319, 0.0217, 0.0127, 0.0172, 0.0224, 0.0174, 0.0172, 0.0338, 0.0370,\n", + " 0.0562, 0.0247, 0.0202, 0.0452, 0.0436, 0.0285, 0.0447],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "214000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 23, 30, 34, 34, 19, 33, 44, 14, 37, 36, 43, 45, 40, 34, 37, 21, 23,\n", + " 30, 46, 3, 14, 16, 32, 16])\n", + "loss= tensor(174.4698, grad_fn=) , actor= tensor(-8.8380, grad_fn=) , critic= tensor(1833.0779, grad_fn=) , return= 172449.8614714255\n", + "probs of actions: tensor([0.0332, 0.0175, 0.0223, 0.0513, 0.0516, 0.0097, 0.0169, 0.0356, 0.0096,\n", + " 0.0574, 0.0185, 0.0475, 0.0212, 0.0265, 0.0521, 0.0563, 0.0091, 0.0173,\n", + " 0.0214, 0.0469, 0.0053, 0.0103, 0.0141, 0.0316, 0.0141],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "215000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 13, 23, 39, 43, 37, 37, 37, 44, 29, 37, 39, 42, 9, 48, 39, 18, 47,\n", + " 26, 25, 39, 24, 30, 23, 43])\n", + "loss= tensor(180.3756, grad_fn=) , actor= tensor(-4.7227, grad_fn=) , critic= tensor(1850.9830, grad_fn=) , return= 172636.3696089242\n", + "probs of actions: tensor([0.0335, 0.0093, 0.0172, 0.0327, 0.0501, 0.0594, 0.0593, 0.0592, 0.0349,\n", + " 0.0425, 0.0587, 0.0323, 0.0494, 0.0064, 0.0117, 0.0321, 0.0127, 0.0198,\n", + " 0.0343, 0.0204, 0.0319, 0.0246, 0.0219, 0.0172, 0.0446],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "216000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 31, 44, 33, 13, 37, 43, 48, 37, 23, 26, 26, 37, 43, 42, 16, 8, 44,\n", + " 40, 42, 46, 45, 7, 31, 39])\n", + "loss= tensor(173.9905, grad_fn=) , actor= tensor(-3.1147, grad_fn=) , critic= tensor(1771.0529, grad_fn=) , return= 172090.28666568088\n", + "probs of actions: tensor([0.0404, 0.0365, 0.0341, 0.0166, 0.0089, 0.0607, 0.0500, 0.0115, 0.0602,\n", + " 0.0169, 0.0336, 0.0337, 0.0594, 0.0478, 0.0509, 0.0138, 0.0052, 0.0351,\n", + " 0.0264, 0.0498, 0.0473, 0.0212, 0.0059, 0.0376, 0.0319],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "217000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 47, 47, 17, 44, 25, 39, 34, 22, 25, 24, 32, 41, 49, 26, 37, 30, 18,\n", + " 23, 32, 47, 42, 36, 44, 31])\n", + "loss= tensor(180.4104, grad_fn=) , actor= tensor(7.3793, grad_fn=) , critic= tensor(1730.3107, grad_fn=) , return= 172344.3141878944\n", + "probs of actions: tensor([0.0089, 0.0193, 0.0193, 0.0107, 0.0349, 0.0189, 0.0326, 0.0544, 0.0134,\n", + " 0.0192, 0.0250, 0.0318, 0.0421, 0.0106, 0.0335, 0.0605, 0.0225, 0.0127,\n", + " 0.0169, 0.0315, 0.0190, 0.0492, 0.0188, 0.0352, 0.0387],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "218000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 42, 34, 19, 30, 46, 37, 33, 22, 36, 44, 42, 11, 9, 10, 28, 37, 25,\n", + " 45, 38, 46, 16, 37, 16, 34])\n", + "loss= tensor(174.2657, grad_fn=) , actor= tensor(-0.0022, grad_fn=) , critic= tensor(1742.6788, grad_fn=) , return= 171526.36606374744\n", + "probs of actions: tensor([0.0264, 0.0529, 0.0530, 0.0093, 0.0229, 0.0500, 0.0626, 0.0161, 0.0132,\n", + " 0.0183, 0.0360, 0.0523, 0.0077, 0.0060, 0.0073, 0.0222, 0.0604, 0.0197,\n", + " 0.0218, 0.0270, 0.0460, 0.0138, 0.0593, 0.0139, 0.0539],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "219000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 41, 39, 25, 44, 43, 43, 37, 42, 48, 34, 34, 46, 32, 7, 41, 33, 32,\n", + " 46, 42, 30, 47, 26, 29, 43])\n", + "loss= tensor(189.1049, grad_fn=) , actor= tensor(4.7530, grad_fn=) , critic= tensor(1843.5190, grad_fn=) , return= 174427.9595783325\n", + "probs of actions: tensor([0.0168, 0.0453, 0.0319, 0.0188, 0.0350, 0.0482, 0.0480, 0.0635, 0.0524,\n", + " 0.0116, 0.0546, 0.0548, 0.0483, 0.0314, 0.0053, 0.0417, 0.0164, 0.0312,\n", + " 0.0466, 0.0498, 0.0222, 0.0193, 0.0345, 0.0450, 0.0432],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "220000 adversary: AdversaryModes.myopic\n", + " actions: tensor([25, 34, 44, 33, 37, 31, 16, 26, 42, 42, 46, 26, 24, 29, 32, 28, 8, 24,\n", + " 22, 14, 35, 49, 38, 44, 29])\n", + "loss= tensor(169.9422, grad_fn=) , actor= tensor(-8.6054, grad_fn=) , critic= tensor(1785.4760, grad_fn=) , return= 171410.27023935108\n", + "probs of actions: tensor([0.0183, 0.0550, 0.0347, 0.0158, 0.0635, 0.0386, 0.0137, 0.0341, 0.0518,\n", + " 0.0514, 0.0493, 0.0345, 0.0258, 0.0457, 0.0307, 0.0215, 0.0050, 0.0255,\n", + " 0.0138, 0.0097, 0.0290, 0.0112, 0.0275, 0.0355, 0.0466],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "221000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 35, 25, 41, 44, 46, 26, 7, 30, 13, 43, 31, 42, 47, 45, 15, 34,\n", + " 39, 33, 37, 39, 48, 34, 28])\n", + "loss= tensor(167.1450, grad_fn=) , actor= tensor(2.4775, grad_fn=) , critic= tensor(1646.6748, grad_fn=) , return= 172963.88426456635\n", + "probs of actions: tensor([0.0333, 0.0336, 0.0284, 0.0184, 0.0445, 0.0344, 0.0500, 0.0343, 0.0050,\n", + " 0.0218, 0.0088, 0.0456, 0.0381, 0.0512, 0.0195, 0.0219, 0.0103, 0.0586,\n", + " 0.0317, 0.0164, 0.0614, 0.0315, 0.0120, 0.0578, 0.0210],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "222000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 25, 42, 46, 38, 33, 43, 45, 31, 33, 41, 32, 38, 42, 32, 46, 46, 28,\n", + " 42, 46, 47, 23, 44, 34, 29])\n", + "loss= tensor(192.3974, grad_fn=) , actor= tensor(14.3821, grad_fn=) , critic= tensor(1780.1534, grad_fn=) , return= 176409.82661986133\n", + "probs of actions: tensor([0.0276, 0.0182, 0.0523, 0.0507, 0.0262, 0.0159, 0.0480, 0.0215, 0.0377,\n", + " 0.0159, 0.0425, 0.0299, 0.0265, 0.0509, 0.0298, 0.0476, 0.0472, 0.0211,\n", + " 0.0500, 0.0465, 0.0197, 0.0156, 0.0348, 0.0595, 0.0469],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "223000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 42, 43, 10, 14, 31, 39, 34, 37, 43, 14, 42, 44, 41, 32, 13, 41, 13,\n", + " 24, 37, 37, 40, 30, 25, 46])\n", + "loss= tensor(177.1917, grad_fn=) , actor= tensor(-2.4954, grad_fn=) , critic= tensor(1796.8710, grad_fn=) , return= 171096.53211821304\n", + "probs of actions: tensor([0.0324, 0.0520, 0.0484, 0.0069, 0.0084, 0.0382, 0.0320, 0.0618, 0.0645,\n", + " 0.0465, 0.0087, 0.0518, 0.0350, 0.0414, 0.0300, 0.0089, 0.0409, 0.0090,\n", + " 0.0264, 0.0618, 0.0615, 0.0269, 0.0218, 0.0200, 0.0453],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "224000 adversary: AdversaryModes.myopic\n", + " actions: tensor([48, 34, 43, 6, 32, 32, 38, 34, 46, 25, 17, 29, 43, 26, 34, 17, 32, 4,\n", + " 32, 46, 43, 44, 32, 35, 29])\n", + "loss= tensor(172.2711, grad_fn=) , actor= tensor(2.2955, grad_fn=) , critic= tensor(1699.7554, grad_fn=) , return= 171695.24750193456\n", + "probs of actions: tensor([0.0121, 0.0609, 0.0490, 0.0032, 0.0299, 0.0300, 0.0258, 0.0630, 0.0501,\n", + " 0.0185, 0.0096, 0.0465, 0.0460, 0.0340, 0.0631, 0.0097, 0.0299, 0.0030,\n", + " 0.0299, 0.0467, 0.0435, 0.0354, 0.0298, 0.0291, 0.0476],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "225000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 36, 32, 35, 6, 46, 39, 26, 41, 28, 35, 31, 25, 42, 34, 44, 40,\n", + " 34, 5, 45, 11, 37, 46, 28])\n", + "loss= tensor(175.9993, grad_fn=) , actor= tensor(-3.7991, grad_fn=) , critic= tensor(1797.9832, grad_fn=) , return= 172190.78246483422\n", + "probs of actions: tensor([0.0635, 0.0600, 0.0178, 0.0305, 0.0285, 0.0032, 0.0507, 0.0326, 0.0337,\n", + " 0.0422, 0.0213, 0.0289, 0.0382, 0.0189, 0.0510, 0.0616, 0.0354, 0.0273,\n", + " 0.0615, 0.0039, 0.0213, 0.0076, 0.0601, 0.0456, 0.0211],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "226000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 48, 19, 37, 40, 5, 19, 35, 12, 44, 39, 49, 42, 37, 25, 39, 37, 37,\n", + " 43, 42, 42, 42, 26, 26, 32])\n", + "loss= tensor(185.0960, grad_fn=) , actor= tensor(18.8149, grad_fn=) , critic= tensor(1662.8114, grad_fn=) , return= 173661.7542827918\n", + "probs of actions: tensor([0.0450, 0.0121, 0.0089, 0.0653, 0.0254, 0.0035, 0.0086, 0.0284, 0.0046,\n", + " 0.0348, 0.0335, 0.0101, 0.0522, 0.0637, 0.0187, 0.0334, 0.0629, 0.0627,\n", + " 0.0450, 0.0507, 0.0506, 0.0504, 0.0342, 0.0342, 0.0304],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "227000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 40, 38, 10, 36, 5, 28, 39, 16, 34, 22, 35, 18, 3, 34, 31, 13, 46,\n", + " 34, 15, 32, 43, 6, 42, 31])\n", + "loss= tensor(160.2292, grad_fn=) , actor= tensor(-8.3159, grad_fn=) , critic= tensor(1685.4502, grad_fn=) , return= 167643.06311090838\n", + "probs of actions: tensor([0.0615, 0.0249, 0.0256, 0.0065, 0.0174, 0.0034, 0.0210, 0.0341, 0.0140,\n", + " 0.0643, 0.0135, 0.0295, 0.0119, 0.0044, 0.0643, 0.0391, 0.0081, 0.0493,\n", + " 0.0634, 0.0098, 0.0310, 0.0446, 0.0035, 0.0503, 0.0391],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "228000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 40, 34, 40, 15, 13, 46, 6, 44, 20, 43, 32, 35, 45, 39, 38, 14, 35,\n", + " 37, 44, 34, 42, 42, 42, 42])\n", + "loss= tensor(179.9173, grad_fn=) , actor= tensor(12.9467, grad_fn=) , critic= tensor(1669.7063, grad_fn=) , return= 171205.22398003156\n", + "probs of actions: tensor([0.0131, 0.0249, 0.0628, 0.0250, 0.0089, 0.0077, 0.0531, 0.0030, 0.0362,\n", + " 0.0163, 0.0486, 0.0309, 0.0296, 0.0214, 0.0344, 0.0263, 0.0084, 0.0295,\n", + " 0.0602, 0.0362, 0.0638, 0.0510, 0.0506, 0.0505, 0.0503],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "229000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 49, 34, 35, 37, 6, 34, 9, 37, 43, 44, 5, 27, 37, 43, 16,\n", + " 29, 29, 32, 37, 25, 34, 29])\n", + "loss= tensor(171.9165, grad_fn=) , actor= tensor(1.6041, grad_fn=) , critic= tensor(1703.1238, grad_fn=) , return= 171339.88365079858\n", + "probs of actions: tensor([0.0623, 0.0628, 0.0452, 0.0097, 0.0640, 0.0297, 0.0631, 0.0030, 0.0652,\n", + " 0.0049, 0.0623, 0.0484, 0.0368, 0.0033, 0.0185, 0.0612, 0.0468, 0.0140,\n", + " 0.0491, 0.0492, 0.0313, 0.0599, 0.0191, 0.0643, 0.0495],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "230000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 39, 42, 39, 40, 25, 24, 46, 42, 18, 41, 48, 40, 30, 27, 22, 41, 30,\n", + " 22, 26, 34, 11, 26, 31, 28])\n", + "loss= tensor(188.4186, grad_fn=) , actor= tensor(0.8227, grad_fn=) , critic= tensor(1875.9587, grad_fn=) , return= 173704.46317349668\n", + "probs of actions: tensor([0.0453, 0.0344, 0.0548, 0.0343, 0.0242, 0.0177, 0.0272, 0.0513, 0.0544,\n", + " 0.0109, 0.0414, 0.0114, 0.0248, 0.0213, 0.0188, 0.0135, 0.0398, 0.0213,\n", + " 0.0137, 0.0354, 0.0645, 0.0069, 0.0354, 0.0414, 0.0214],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "231000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 27, 46, 42, 48, 26, 32, 44, 34, 37, 40, 43, 25, 43, 18, 34, 45,\n", + " 42, 27, 34, 46, 37, 29, 31])\n", + "loss= tensor(192.1230, grad_fn=) , actor= tensor(11.4813, grad_fn=) , critic= tensor(1806.4165, grad_fn=) , return= 175797.27134740225\n", + "probs of actions: tensor([0.0623, 0.0548, 0.0184, 0.0537, 0.0548, 0.0111, 0.0340, 0.0328, 0.0374,\n", + " 0.0647, 0.0636, 0.0250, 0.0461, 0.0177, 0.0457, 0.0109, 0.0650, 0.0224,\n", + " 0.0523, 0.0188, 0.0645, 0.0481, 0.0608, 0.0509, 0.0425],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "232000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 30, 25, 46, 34, 35, 38, 25, 34, 37, 42, 46, 42, 37, 42, 39, 26, 31,\n", + " 45, 30, 21, 39, 26, 44, 43])\n", + "loss= tensor(190.9790, grad_fn=) , actor= tensor(0.2000, grad_fn=) , critic= tensor(1907.7902, grad_fn=) , return= 174438.56528422018\n", + "probs of actions: tensor([0.0542, 0.0226, 0.0168, 0.0536, 0.0649, 0.0299, 0.0254, 0.0170, 0.0659,\n", + " 0.0652, 0.0540, 0.0510, 0.0536, 0.0644, 0.0533, 0.0347, 0.0352, 0.0417,\n", + " 0.0220, 0.0213, 0.0081, 0.0344, 0.0352, 0.0382, 0.0432],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "233000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 34, 36, 25, 36, 36, 10, 26, 24, 43, 38, 41, 26, 21, 40, 32, 26, 26,\n", + " 30, 46, 30, 26, 41, 44, 26])\n", + "loss= tensor(182.9955, grad_fn=) , actor= tensor(9.3200, grad_fn=) , critic= tensor(1736.7552, grad_fn=) , return= 173051.05063321942\n", + "probs of actions: tensor([0.0205, 0.0624, 0.0169, 0.0164, 0.0169, 0.0169, 0.0058, 0.0344, 0.0263,\n", + " 0.0477, 0.0254, 0.0440, 0.0349, 0.0075, 0.0247, 0.0324, 0.0350, 0.0350,\n", + " 0.0213, 0.0481, 0.0214, 0.0351, 0.0416, 0.0384, 0.0351],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "234000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 37, 18, 40, 42, 37, 23, 29, 19, 26, 29, 44, 42, 41, 28, 27, 31, 34,\n", + " 45, 29, 30, 19, 23, 26, 12])\n", + "loss= tensor(169.6209, grad_fn=) , actor= tensor(-7.2976, grad_fn=) , critic= tensor(1769.1846, grad_fn=) , return= 174581.6304875332\n", + "probs of actions: tensor([0.0362, 0.0655, 0.0101, 0.0237, 0.0552, 0.0657, 0.0131, 0.0495, 0.0081,\n", + " 0.0351, 0.0504, 0.0381, 0.0540, 0.0450, 0.0224, 0.0195, 0.0431, 0.0649,\n", + " 0.0211, 0.0516, 0.0217, 0.0086, 0.0133, 0.0355, 0.0047],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "235000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 32, 42, 21, 24, 37, 39, 46, 37, 34, 46, 26, 26, 39, 26, 42, 37, 11,\n", + " 26, 26, 36, 40, 38, 29, 35])\n", + "loss= tensor(181.6141, grad_fn=) , actor= tensor(-1.3032, grad_fn=) , critic= tensor(1829.1727, grad_fn=) , return= 173752.16246146546\n", + "probs of actions: tensor([0.0363, 0.0311, 0.0567, 0.0073, 0.0259, 0.0664, 0.0342, 0.0508, 0.0659,\n", + " 0.0673, 0.0500, 0.0356, 0.0356, 0.0339, 0.0357, 0.0550, 0.0641, 0.0062,\n", + " 0.0357, 0.0358, 0.0172, 0.0244, 0.0268, 0.0526, 0.0296],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "236000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 31, 27, 38, 28, 10, 30, 6, 35, 37, 26, 34, 7, 24, 43, 39, 35, 34,\n", + " 40, 34, 35, 34, 37, 18, 41])\n", + "loss= tensor(169.8328, grad_fn=) , actor= tensor(3.7035, grad_fn=) , critic= tensor(1661.2927, grad_fn=) , return= 171014.75073899308\n", + "probs of actions: tensor([0.0651, 0.0425, 0.0195, 0.0261, 0.0223, 0.0057, 0.0218, 0.0025, 0.0287,\n", + " 0.0647, 0.0359, 0.0685, 0.0042, 0.0254, 0.0437, 0.0335, 0.0290, 0.0681,\n", + " 0.0244, 0.0678, 0.0290, 0.0677, 0.0620, 0.0105, 0.0438],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "237000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 37, 42, 35, 42, 22, 34, 47, 41, 40, 33, 20, 35, 10, 46, 46, 22, 34,\n", + " 42, 46, 38, 39, 19, 46, 43])\n", + "loss= tensor(182.3569, grad_fn=) , actor= tensor(0.5921, grad_fn=) , critic= tensor(1817.6478, grad_fn=) , return= 173214.226783918\n", + "probs of actions: tensor([0.0417, 0.0665, 0.0572, 0.0286, 0.0574, 0.0119, 0.0685, 0.0195, 0.0483,\n", + " 0.0233, 0.0153, 0.0155, 0.0290, 0.0059, 0.0501, 0.0496, 0.0126, 0.0686,\n", + " 0.0548, 0.0486, 0.0267, 0.0344, 0.0090, 0.0477, 0.0420],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "238000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 38, 28, 19, 34, 42, 19, 46, 40, 37, 36, 44, 48, 24, 15, 32, 42, 34,\n", + " 37, 28, 26, 34, 30, 34, 16])\n", + "loss= tensor(187.2125, grad_fn=) , actor= tensor(10.7772, grad_fn=) , critic= tensor(1764.3530, grad_fn=) , return= 174912.51662512706\n", + "probs of actions: tensor([0.0379, 0.0257, 0.0223, 0.0085, 0.0678, 0.0563, 0.0085, 0.0534, 0.0233,\n", + " 0.0681, 0.0165, 0.0400, 0.0106, 0.0250, 0.0078, 0.0293, 0.0543, 0.0680,\n", + " 0.0659, 0.0224, 0.0355, 0.0678, 0.0216, 0.0675, 0.0137],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "239000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 46, 44, 43, 22, 42, 43, 46, 34, 38, 30, 2, 46, 32, 38, 36, 21, 19,\n", + " 15, 41, 23, 46, 33, 35, 25])\n", + "loss= tensor(168.7080, grad_fn=) , actor= tensor(-8.3500, grad_fn=) , critic= tensor(1770.5792, grad_fn=) , return= 172349.19265800618\n", + "probs of actions: tensor([0.0065, 0.0539, 0.0378, 0.0484, 0.0117, 0.0555, 0.0475, 0.0522, 0.0708,\n", + " 0.0254, 0.0215, 0.0022, 0.0506, 0.0296, 0.0256, 0.0163, 0.0071, 0.0086,\n", + " 0.0079, 0.0453, 0.0125, 0.0480, 0.0158, 0.0301, 0.0176],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "240000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 46, 43, 37, 31, 42, 47, 41, 30, 30, 28, 13, 42, 39, 31, 29, 43,\n", + " 35, 46, 37, 33, 35, 10, 21])\n", + "loss= tensor(171.6793, grad_fn=) , actor= tensor(-7.3395, grad_fn=) , critic= tensor(1790.1874, grad_fn=) , return= 176162.4846305892\n", + "probs of actions: tensor([0.0723, 0.0691, 0.0533, 0.0485, 0.0728, 0.0437, 0.0544, 0.0183, 0.0486,\n", + " 0.0215, 0.0214, 0.0230, 0.0061, 0.0535, 0.0364, 0.0448, 0.0527, 0.0445,\n", + " 0.0306, 0.0483, 0.0694, 0.0158, 0.0306, 0.0059, 0.0074],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "241000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 10, 41, 9, 31, 38, 20, 42, 42, 8, 43, 20, 46, 26, 35, 37, 30, 2,\n", + " 35, 6, 28, 40, 27, 23, 30])\n", + "loss= tensor(153.6180, grad_fn=) , actor= tensor(-18.0295, grad_fn=) , critic= tensor(1716.4756, grad_fn=) , return= 168897.6297662069\n", + "probs of actions: tensor([0.0298, 0.0053, 0.0507, 0.0044, 0.0429, 0.0247, 0.0142, 0.0545, 0.0539,\n", + " 0.0035, 0.0465, 0.0146, 0.0494, 0.0339, 0.0307, 0.0706, 0.0219, 0.0022,\n", + " 0.0306, 0.0027, 0.0227, 0.0248, 0.0198, 0.0126, 0.0219],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "242000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 45, 20, 37, 37, 34, 32, 34, 29, 29, 29, 26, 26, 36, 36, 33, 31, 48,\n", + " 32, 44, 42, 42, 34, 29, 36])\n", + "loss= tensor(176.8444, grad_fn=) , actor= tensor(3.3228, grad_fn=) , critic= tensor(1735.2158, grad_fn=) , return= 174634.5249150165\n", + "probs of actions: tensor([0.0225, 0.0193, 0.0138, 0.0720, 0.0719, 0.0723, 0.0299, 0.0728, 0.0515,\n", + " 0.0518, 0.0520, 0.0342, 0.0342, 0.0167, 0.0168, 0.0155, 0.0436, 0.0105,\n", + " 0.0299, 0.0402, 0.0506, 0.0505, 0.0717, 0.0535, 0.0171],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "243000 adversary: AdversaryModes.myopic\n", + " actions: tensor([49, 38, 46, 32, 32, 44, 37, 28, 32, 34, 30, 38, 24, 16, 45, 40, 11, 37,\n", + " 30, 23, 11, 15, 40, 34, 49])\n", + "loss= tensor(180.9940, grad_fn=) , actor= tensor(-19.4718, grad_fn=) , critic= tensor(2004.6584, grad_fn=) , return= 170918.5540581879\n", + "probs of actions: tensor([0.0089, 0.0247, 0.0517, 0.0294, 0.0294, 0.0391, 0.0742, 0.0220, 0.0295,\n", + " 0.0749, 0.0222, 0.0249, 0.0248, 0.0135, 0.0197, 0.0247, 0.0055, 0.0715,\n", + " 0.0221, 0.0122, 0.0057, 0.0078, 0.0253, 0.0732, 0.0093],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "244000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 37, 34, 22, 29, 35, 33, 43, 34, 21, 43, 34, 28, 17, 39, 28, 26, 34,\n", + " 40, 14, 40, 41, 3, 12, 31])\n", + "loss= tensor(170.5337, grad_fn=) , actor= tensor(-15.2296, grad_fn=) , critic= tensor(1857.6328, grad_fn=) , return= 172676.50921498646\n", + "probs of actions: tensor([0.0194, 0.0740, 0.0737, 0.0112, 0.0518, 0.0306, 0.0148, 0.0455, 0.0754,\n", + " 0.0071, 0.0447, 0.0753, 0.0217, 0.0076, 0.0363, 0.0216, 0.0339, 0.0751,\n", + " 0.0250, 0.0076, 0.0251, 0.0466, 0.0034, 0.0044, 0.0418],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "245000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 15, 46, 12, 22, 46, 34, 40, 41, 18, 1, 43, 39, 41, 24, 30, 24, 29,\n", + " 36, 31, 45, 44, 38, 4, 46])\n", + "loss= tensor(162.9260, grad_fn=) , actor= tensor(-9.3577, grad_fn=) , critic= tensor(1722.8378, grad_fn=) , return= 169986.90817668434\n", + "probs of actions: tensor([0.0505, 0.0068, 0.0517, 0.0041, 0.0113, 0.0508, 0.0736, 0.0241, 0.0504,\n", + " 0.0097, 0.0015, 0.0443, 0.0368, 0.0486, 0.0247, 0.0223, 0.0246, 0.0557,\n", + " 0.0171, 0.0422, 0.0205, 0.0387, 0.0258, 0.0024, 0.0456],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "246000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 31, 26, 26, 30, 29, 42, 7, 11, 46, 14, 44, 37, 44, 27, 32, 31, 43,\n", + " 26, 45, 23, 41, 31, 10, 46])\n", + "loss= tensor(165.9326, grad_fn=) , actor= tensor(-7.5335, grad_fn=) , critic= tensor(1734.6614, grad_fn=) , return= 170818.67019317116\n", + "probs of actions: tensor([0.0259, 0.0412, 0.0332, 0.0332, 0.0228, 0.0541, 0.0519, 0.0037, 0.0051,\n", + " 0.0495, 0.0071, 0.0386, 0.0725, 0.0386, 0.0197, 0.0287, 0.0429, 0.0416,\n", + " 0.0343, 0.0198, 0.0122, 0.0470, 0.0430, 0.0059, 0.0455],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "247000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 24, 45, 40, 11, 42, 44, 30, 47, 43, 29, 34, 43, 34, 43, 41, 42,\n", + " 34, 6, 36, 29, 47, 44, 22])\n", + "loss= tensor(176.0892, grad_fn=) , actor= tensor(-1.1045, grad_fn=) , critic= tensor(1771.9362, grad_fn=) , return= 174164.61188243752\n", + "probs of actions: tensor([0.0402, 0.0407, 0.0261, 0.0191, 0.0242, 0.0049, 0.0537, 0.0382, 0.0226,\n", + " 0.0200, 0.0436, 0.0572, 0.0769, 0.0429, 0.0764, 0.0424, 0.0482, 0.0513,\n", + " 0.0760, 0.0023, 0.0169, 0.0585, 0.0200, 0.0382, 0.0125],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "248000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 41, 47, 47, 39, 22, 25, 44, 11, 41, 44, 33, 28, 34, 41, 24, 39, 41,\n", + " 46, 38, 42, 31, 37, 46, 25])\n", + "loss= tensor(186.4092, grad_fn=) , actor= tensor(13.5372, grad_fn=) , critic= tensor(1728.7198, grad_fn=) , return= 174985.18039877154\n", + "probs of actions: tensor([0.0410, 0.0544, 0.0205, 0.0205, 0.0365, 0.0109, 0.0156, 0.0382, 0.0048,\n", + " 0.0521, 0.0385, 0.0149, 0.0220, 0.0778, 0.0502, 0.0256, 0.0359, 0.0493,\n", + " 0.0457, 0.0269, 0.0505, 0.0433, 0.0714, 0.0445, 0.0168],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "249000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 33, 46, 22, 45, 34, 30, 31, 38, 40, 29, 32, 40, 41, 42, 41, 42, 49,\n", + " 39, 46, 27, 43, 35, 34, 34])\n", + "loss= tensor(191.7284, grad_fn=) , actor= tensor(14.8135, grad_fn=) , critic= tensor(1769.1492, grad_fn=) , return= 176251.6120158717\n", + "probs of actions: tensor([0.0745, 0.0149, 0.0508, 0.0109, 0.0197, 0.0768, 0.0229, 0.0416, 0.0264,\n", + " 0.0237, 0.0600, 0.0292, 0.0239, 0.0514, 0.0503, 0.0509, 0.0500, 0.0083,\n", + " 0.0360, 0.0459, 0.0196, 0.0399, 0.0313, 0.0757, 0.0756],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "250000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 41, 27, 10, 42, 41, 18, 44, 42, 26, 42, 46, 37, 41, 28, 24, 34, 22,\n", + " 24, 34, 29, 13, 39, 41, 45])\n", + "loss= tensor(181.8197, grad_fn=) , actor= tensor(-5.2558, grad_fn=) , critic= tensor(1870.7551, grad_fn=) , return= 170797.84355103193\n", + "probs of actions: tensor([0.0059, 0.0544, 0.0188, 0.0050, 0.0534, 0.0530, 0.0088, 0.0387, 0.0524,\n", + " 0.0341, 0.0525, 0.0493, 0.0741, 0.0505, 0.0224, 0.0254, 0.0763, 0.0117,\n", + " 0.0254, 0.0757, 0.0594, 0.0062, 0.0362, 0.0476, 0.0210],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "251000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 14, 38, 41, 34, 34, 44, 6, 25, 31, 46, 41, 34, 34, 32, 30, 37, 32,\n", + " 43, 24, 34, 39, 28, 22, 39])\n", + "loss= tensor(178.7449, grad_fn=) , actor= tensor(0.2555, grad_fn=) , critic= tensor(1784.8934, grad_fn=) , return= 173269.671073155\n", + "probs of actions: tensor([0.0192, 0.0067, 0.0277, 0.0544, 0.0756, 0.0760, 0.0391, 0.0019, 0.0158,\n", + " 0.0407, 0.0479, 0.0514, 0.0761, 0.0761, 0.0302, 0.0225, 0.0770, 0.0301,\n", + " 0.0378, 0.0256, 0.0753, 0.0365, 0.0222, 0.0119, 0.0364],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "252000 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 28, 30, 37, 5, 26, 42, 46, 38, 17, 42, 28, 27, 41, 29, 42, 16, 37,\n", + " 31, 46, 43, 34, 24, 25, 28])\n", + "loss= tensor(171.6949, grad_fn=) , actor= tensor(5.3926, grad_fn=) , critic= tensor(1663.0228, grad_fn=) , return= 172703.77128248438\n", + "probs of actions: tensor([0.0085, 0.0229, 0.0231, 0.0793, 0.0022, 0.0338, 0.0537, 0.0476, 0.0275,\n", + " 0.0072, 0.0534, 0.0230, 0.0187, 0.0512, 0.0604, 0.0522, 0.0119, 0.0759,\n", + " 0.0412, 0.0444, 0.0373, 0.0750, 0.0251, 0.0171, 0.0228],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "253000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 25, 46, 42, 42, 31, 44, 44, 41, 37, 42, 44, 29, 26, 37, 0, 24, 29,\n", + " 32, 37, 34, 37, 14, 29, 34])\n", + "loss= tensor(192.2556, grad_fn=) , actor= tensor(1.9816, grad_fn=) , critic= tensor(1902.7396, grad_fn=) , return= 173744.0151889776\n", + "probs of actions: tensor([0.0196, 0.0158, 0.0474, 0.0557, 0.0558, 0.0400, 0.0408, 0.0410, 0.0531,\n", + " 0.0791, 0.0552, 0.0413, 0.0597, 0.0339, 0.0775, 0.0017, 0.0247, 0.0608,\n", + " 0.0309, 0.0756, 0.0737, 0.0751, 0.0077, 0.0609, 0.0731],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "254000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 39, 46, 41, 29, 32, 24, 45, 47, 42, 35, 37, 34, 37, 44, 3, 46, 42,\n", + " 18, 40, 28, 16, 34, 37, 18])\n", + "loss= tensor(178.1891, grad_fn=) , actor= tensor(-5.1103, grad_fn=) , critic= tensor(1832.9943, grad_fn=) , return= 174564.27192864567\n", + "probs of actions: tensor([0.0394, 0.0393, 0.0477, 0.0561, 0.0552, 0.0315, 0.0253, 0.0196, 0.0189,\n", + " 0.0557, 0.0321, 0.0796, 0.0767, 0.0788, 0.0415, 0.0028, 0.0439, 0.0538,\n", + " 0.0089, 0.0244, 0.0219, 0.0119, 0.0755, 0.0751, 0.0092],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "255000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 42, 18, 47, 38, 39, 46, 34, 29, 32, 42, 28, 39, 37, 34, 37, 42, 39,\n", + " 31, 35, 34, 40, 37, 23, 17])\n", + "loss= tensor(178.7177, grad_fn=) , actor= tensor(0.8291, grad_fn=) , critic= tensor(1778.8860, grad_fn=) , return= 176922.91300951893\n", + "probs of actions: tensor([0.0822, 0.0555, 0.0084, 0.0190, 0.0257, 0.0400, 0.0475, 0.0777, 0.0584,\n", + " 0.0318, 0.0551, 0.0223, 0.0397, 0.0808, 0.0775, 0.0801, 0.0537, 0.0394,\n", + " 0.0402, 0.0329, 0.0767, 0.0241, 0.0775, 0.0114, 0.0075],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "256000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 47, 16, 6, 46, 23, 35, 44, 46, 34, 39, 31, 46, 36, 30, 46, 37,\n", + " 34, 45, 20, 42, 1, 49, 42])\n", + "loss= tensor(174.3519, grad_fn=) , actor= tensor(-11.7669, grad_fn=) , critic= tensor(1861.1875, grad_fn=) , return= 171751.7960602622\n", + "probs of actions: tensor([0.0820, 0.0823, 0.0188, 0.0117, 0.0017, 0.0482, 0.0108, 0.0327, 0.0409,\n", + " 0.0468, 0.0813, 0.0403, 0.0399, 0.0458, 0.0152, 0.0219, 0.0450, 0.0791,\n", + " 0.0806, 0.0207, 0.0135, 0.0528, 0.0014, 0.0076, 0.0516],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "257000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 38, 31, 24, 8, 29, 43, 41, 46, 34, 35, 47, 24, 44, 40, 45, 34,\n", + " 41, 11, 27, 37, 47, 25, 34])\n", + "loss= tensor(174.2233, grad_fn=) , actor= tensor(-1.6907, grad_fn=) , critic= tensor(1759.1396, grad_fn=) , return= 173559.946156863\n", + "probs of actions: tensor([0.0550, 0.0824, 0.0257, 0.0387, 0.0247, 0.0027, 0.0582, 0.0423, 0.0523,\n", + " 0.0472, 0.0847, 0.0323, 0.0183, 0.0245, 0.0421, 0.0223, 0.0205, 0.0839,\n", + " 0.0496, 0.0049, 0.0193, 0.0764, 0.0185, 0.0154, 0.0828],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "258000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 28, 31, 43, 49, 40, 34, 27, 38, 35, 29, 46, 22, 24, 16, 30, 29, 40,\n", + " 19, 43, 46, 38, 41, 35, 42])\n", + "loss= tensor(180.9682, grad_fn=) , actor= tensor(0.0995, grad_fn=) , critic= tensor(1808.6879, grad_fn=) , return= 173211.307409631\n", + "probs of actions: tensor([0.0827, 0.0224, 0.0394, 0.0431, 0.0071, 0.0216, 0.0858, 0.0184, 0.0260,\n", + " 0.0319, 0.0600, 0.0463, 0.0105, 0.0239, 0.0112, 0.0211, 0.0614, 0.0226,\n", + " 0.0069, 0.0387, 0.0439, 0.0267, 0.0488, 0.0320, 0.0519],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "259000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 49, 37, 37, 46, 29, 23, 42, 44, 22, 30, 39, 39, 42, 48, 32, 45, 26,\n", + " 32, 29, 49, 0, 34, 42, 26])\n", + "loss= tensor(182.9697, grad_fn=) , actor= tensor(-3.2731, grad_fn=) , critic= tensor(1862.4279, grad_fn=) , return= 174219.38377051914\n", + "probs of actions: tensor([0.0306, 0.0072, 0.0825, 0.0828, 0.0487, 0.0579, 0.0103, 0.0544, 0.0424,\n", + " 0.0106, 0.0210, 0.0423, 0.0422, 0.0531, 0.0091, 0.0307, 0.0218, 0.0364,\n", + " 0.0306, 0.0615, 0.0075, 0.0016, 0.0850, 0.0508, 0.0366],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "260000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 43, 2, 46, 32, 37, 26, 47, 41, 44, 34, 35, 29, 39, 35, 13, 38, 16,\n", + " 34, 37, 38, 34, 39, 37, 28])\n", + "loss= tensor(182.2796, grad_fn=) , actor= tensor(7.1220, grad_fn=) , critic= tensor(1751.5757, grad_fn=) , return= 173229.17178388764\n", + "probs of actions: tensor([0.0218, 0.0433, 0.0015, 0.0506, 0.0304, 0.0858, 0.0344, 0.0180, 0.0542,\n", + " 0.0418, 0.0859, 0.0324, 0.0625, 0.0418, 0.0326, 0.0049, 0.0261, 0.0111,\n", + " 0.0854, 0.0811, 0.0263, 0.0845, 0.0412, 0.0799, 0.0219],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "261000 adversary: AdversaryModes.myopic\n", + " actions: tensor([36, 40, 43, 29, 37, 29, 26, 37, 30, 31, 32, 29, 37, 29, 29, 42, 10, 43,\n", + " 41, 43, 41, 45, 26, 26, 44])\n", + "loss= tensor(175.8185, grad_fn=) , actor= tensor(-4.0210, grad_fn=) , critic= tensor(1798.3949, grad_fn=) , return= 173717.66932334457\n", + "probs of actions: tensor([0.0142, 0.0214, 0.0437, 0.0588, 0.0830, 0.0600, 0.0339, 0.0827, 0.0207,\n", + " 0.0395, 0.0301, 0.0624, 0.0812, 0.0627, 0.0630, 0.0535, 0.0049, 0.0396,\n", + " 0.0527, 0.0389, 0.0524, 0.0211, 0.0350, 0.0350, 0.0408],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "262000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 46, 27, 31, 37, 42, 34, 46, 38, 32, 16, 34, 47, 26, 15, 41, 34, 9,\n", + " 34, 29, 28, 34, 34, 29, 36])\n", + "loss= tensor(182.2045, grad_fn=) , actor= tensor(-0.8956, grad_fn=) , critic= tensor(1831.0009, grad_fn=) , return= 172815.51923345044\n", + "probs of actions: tensor([0.0225, 0.0508, 0.0190, 0.0383, 0.0841, 0.0553, 0.0845, 0.0490, 0.0256,\n", + " 0.0306, 0.0111, 0.0853, 0.0175, 0.0352, 0.0056, 0.0525, 0.0840, 0.0033,\n", + " 0.0843, 0.0627, 0.0221, 0.0833, 0.0830, 0.0629, 0.0148],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "263000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 37, 31, 25, 45, 39, 24, 46, 22, 46, 33, 37, 49, 35, 44, 37, 44, 42,\n", + " 37, 47, 35, 29, 41, 46, 25])\n", + "loss= tensor(182.8527, grad_fn=) , actor= tensor(10.6482, grad_fn=) , critic= tensor(1722.0444, grad_fn=) , return= 175720.43093415626\n", + "probs of actions: tensor([0.0119, 0.0855, 0.0382, 0.0128, 0.0209, 0.0443, 0.0255, 0.0500, 0.0106,\n", + " 0.0494, 0.0133, 0.0844, 0.0069, 0.0327, 0.0393, 0.0829, 0.0393, 0.0554,\n", + " 0.0819, 0.0174, 0.0327, 0.0644, 0.0495, 0.0455, 0.0140],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "264000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 45, 32, 40, 32, 27, 38, 29, 18, 41, 11, 36, 39, 48, 46, 42, 38, 8,\n", + " 35, 29, 41, 46, 29, 20, 25])\n", + "loss= tensor(174.6527, grad_fn=) , actor= tensor(3.3465, grad_fn=) , critic= tensor(1713.0613, grad_fn=) , return= 173963.53397452907\n", + "probs of actions: tensor([0.0575, 0.0204, 0.0300, 0.0208, 0.0301, 0.0182, 0.0248, 0.0610, 0.0081,\n", + " 0.0537, 0.0042, 0.0145, 0.0449, 0.0092, 0.0481, 0.0559, 0.0252, 0.0025,\n", + " 0.0325, 0.0638, 0.0503, 0.0463, 0.0639, 0.0129, 0.0139],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "265000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 37, 20, 34, 34, 46, 29, 44, 41, 34, 29, 42, 43, 23, 46, 37, 35,\n", + " 43, 31, 44, 34, 26, 37, 34])\n", + "loss= tensor(186.8197, grad_fn=) , actor= tensor(6.6091, grad_fn=) , critic= tensor(1802.1067, grad_fn=) , return= 175636.71765098264\n", + "probs of actions: tensor([0.0837, 0.0586, 0.0896, 0.0115, 0.0867, 0.0870, 0.0503, 0.0637, 0.0392,\n", + " 0.0560, 0.0875, 0.0652, 0.0557, 0.0414, 0.0097, 0.0475, 0.0864, 0.0325,\n", + " 0.0403, 0.0390, 0.0394, 0.0859, 0.0342, 0.0837, 0.0854],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "266000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 42, 41, 23, 41, 16, 31, 40, 42, 26, 36, 30, 30, 24, 29, 47, 27, 30,\n", + " 43, 43, 34, 26, 29, 42, 25])\n", + "loss= tensor(181.6086, grad_fn=) , actor= tensor(5.6120, grad_fn=) , critic= tensor(1759.9658, grad_fn=) , return= 174449.98106394132\n", + "probs of actions: tensor([0.0438, 0.0565, 0.0572, 0.0097, 0.0567, 0.0109, 0.0384, 0.0212, 0.0562,\n", + " 0.0338, 0.0144, 0.0197, 0.0196, 0.0242, 0.0666, 0.0178, 0.0189, 0.0197,\n", + " 0.0405, 0.0402, 0.0886, 0.0345, 0.0675, 0.0532, 0.0138],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "267000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 41, 43, 34, 14, 31, 16, 30, 40, 34, 41, 37, 34, 10, 44, 37, 26, 33,\n", + " 26, 27, 42, 42, 31, 32, 29])\n", + "loss= tensor(173.4982, grad_fn=) , actor= tensor(1.7672, grad_fn=) , critic= tensor(1717.3099, grad_fn=) , return= 173239.07108175286\n", + "probs of actions: tensor([0.0608, 0.0570, 0.0448, 0.0909, 0.0056, 0.0390, 0.0108, 0.0200, 0.0209,\n", + " 0.0925, 0.0541, 0.0879, 0.0926, 0.0045, 0.0398, 0.0861, 0.0344, 0.0130,\n", + " 0.0345, 0.0186, 0.0538, 0.0534, 0.0406, 0.0293, 0.0679],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "268000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 30, 31, 38, 43, 43, 21, 25, 37, 1, 32, 23, 7, 46, 35, 34, 46, 34,\n", + " 44, 28, 34, 24, 42, 14, 32])\n", + "loss= tensor(168.4262, grad_fn=) , actor= tensor(-0.3883, grad_fn=) , critic= tensor(1688.1449, grad_fn=) , return= 172004.78333292052\n", + "probs of actions: tensor([0.0568, 0.0214, 0.0378, 0.0241, 0.0446, 0.0442, 0.0053, 0.0121, 0.0907,\n", + " 0.0009, 0.0298, 0.0091, 0.0027, 0.0471, 0.0323, 0.0960, 0.0463, 0.0954,\n", + " 0.0389, 0.0216, 0.0952, 0.0240, 0.0522, 0.0065, 0.0296],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "269000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 40, 46, 41, 35, 39, 38, 44, 32, 34, 41, 35, 43, 14, 37, 26, 17, 40,\n", + " 28, 37, 39, 24, 43, 44, 31])\n", + "loss= tensor(188.3151, grad_fn=) , actor= tensor(0.7924, grad_fn=) , critic= tensor(1875.2272, grad_fn=) , return= 174703.82822241378\n", + "probs of actions: tensor([0.0516, 0.0201, 0.0510, 0.0578, 0.0321, 0.0443, 0.0242, 0.0393, 0.0292,\n", + " 0.1003, 0.0554, 0.0327, 0.0421, 0.0058, 0.0863, 0.0348, 0.0061, 0.0211,\n", + " 0.0211, 0.0842, 0.0434, 0.0238, 0.0398, 0.0395, 0.0403],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "270000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 31, 37, 39, 30, 39, 30, 17, 39, 34, 39, 37, 37, 38, 34, 34, 30, 34,\n", + " 49, 44, 34, 37, 41, 27, 49])\n", + "loss= tensor(177.1586, grad_fn=) , actor= tensor(-5.2380, grad_fn=) , critic= tensor(1823.9652, grad_fn=) , return= 174368.9510574987\n", + "probs of actions: tensor([0.0290, 0.0377, 0.0886, 0.0447, 0.0206, 0.0446, 0.0204, 0.0059, 0.0445,\n", + " 0.1012, 0.0443, 0.0873, 0.0869, 0.0248, 0.1009, 0.1008, 0.0201, 0.1005,\n", + " 0.0067, 0.0392, 0.0995, 0.0835, 0.0528, 0.0186, 0.0069],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "271000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 26, 38, 22, 42, 43, 28, 45, 29, 33, 34, 29, 15, 43, 37, 23, 26, 41,\n", + " 34, 34, 37, 37, 15, 40, 34])\n", + "loss= tensor(186.3294, grad_fn=) , actor= tensor(5.1132, grad_fn=) , critic= tensor(1812.1621, grad_fn=) , return= 173595.07817583714\n", + "probs of actions: tensor([0.0592, 0.0327, 0.0246, 0.0093, 0.0553, 0.0451, 0.0204, 0.0189, 0.0661,\n", + " 0.0129, 0.1029, 0.0673, 0.0050, 0.0428, 0.0869, 0.0090, 0.0337, 0.0539,\n", + " 0.1014, 0.1014, 0.0847, 0.0843, 0.0055, 0.0208, 0.0998],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "272000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 13, 42, 29, 37, 34, 17, 34, 29, 46, 32, 41, 46, 14, 42, 43,\n", + " 32, 44, 3, 24, 34, 3, 47])\n", + "loss= tensor(158.3581, grad_fn=) , actor= tensor(-30.4633, grad_fn=) , critic= tensor(1888.2140, grad_fn=) , return= 170970.1040480919\n", + "probs of actions: tensor([0.0988, 0.0999, 0.1012, 0.0038, 0.0547, 0.0639, 0.0918, 0.1042, 0.0056,\n", + " 0.1051, 0.0663, 0.0486, 0.0285, 0.0550, 0.0477, 0.0056, 0.0528, 0.0417,\n", + " 0.0284, 0.0378, 0.0019, 0.0234, 0.1023, 0.0020, 0.0188],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "273000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 42, 34, 33, 33, 32, 24, 29, 18, 39, 41, 37, 47, 42, 25, 46, 45, 39,\n", + " 43, 34, 21, 31, 34, 24, 34])\n", + "loss= tensor(189.6227, grad_fn=) , actor= tensor(9.7924, grad_fn=) , critic= tensor(1798.3026, grad_fn=) , return= 175250.16964839972\n", + "probs of actions: tensor([0.0361, 0.0546, 0.1001, 0.0128, 0.0127, 0.0287, 0.0231, 0.0671, 0.0068,\n", + " 0.0463, 0.0574, 0.0936, 0.0181, 0.0534, 0.0115, 0.0474, 0.0191, 0.0457,\n", + " 0.0420, 0.1020, 0.0053, 0.0389, 0.1012, 0.0231, 0.1009],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "274000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 3, 37, 46, 42, 41, 40, 42, 34, 37, 37, 18, 14, 42, 43, 42, 40, 22,\n", + " 17, 29, 41, 31, 39, 29, 20])\n", + "loss= tensor(176.0951, grad_fn=) , actor= tensor(-0.0010, grad_fn=) , critic= tensor(1760.9609, grad_fn=) , return= 173812.9556516586\n", + "probs of actions: tensor([0.0555, 0.0018, 0.0944, 0.0512, 0.0545, 0.0594, 0.0195, 0.0544, 0.1029,\n", + " 0.0938, 0.0935, 0.0071, 0.0051, 0.0537, 0.0433, 0.0529, 0.0203, 0.0099,\n", + " 0.0057, 0.0713, 0.0543, 0.0386, 0.0444, 0.0714, 0.0110],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "275000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 39, 34, 37, 29, 23, 35, 37, 48, 26, 45, 39, 42, 37, 43, 48, 34, 46,\n", + " 26, 31, 47, 34, 34, 44, 41])\n", + "loss= tensor(189.7341, grad_fn=) , actor= tensor(6.9881, grad_fn=) , critic= tensor(1827.4595, grad_fn=) , return= 175247.3854415657\n", + "probs of actions: tensor([0.0463, 0.0463, 0.1059, 0.0947, 0.0666, 0.0082, 0.0309, 0.0944, 0.0090,\n", + " 0.0338, 0.0190, 0.0456, 0.0555, 0.0926, 0.0433, 0.0091, 0.1085, 0.0458,\n", + " 0.0345, 0.0378, 0.0182, 0.1071, 0.1073, 0.0369, 0.0519],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "276000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 37, 31, 30, 34, 41, 34, 42, 34, 45, 8, 39, 41, 37, 42, 39, 37, 48,\n", + " 44, 41, 37, 31, 39, 43, 34])\n", + "loss= tensor(182.3263, grad_fn=) , actor= tensor(6.6659, grad_fn=) , critic= tensor(1756.6047, grad_fn=) , return= 175517.60687121097\n", + "probs of actions: tensor([0.0348, 0.0931, 0.0352, 0.0196, 0.1091, 0.0580, 0.1098, 0.0582, 0.1103,\n", + " 0.0190, 0.0018, 0.0459, 0.0553, 0.0917, 0.0568, 0.0455, 0.0906, 0.0091,\n", + " 0.0364, 0.0535, 0.0890, 0.0369, 0.0452, 0.0408, 0.1073],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "277000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 34, 32, 44, 47, 34, 49, 37, 29, 13, 37, 39, 26, 14, 34, 35, 42, 37,\n", + " 26, 29, 32, 34, 27, 43, 39])\n", + "loss= tensor(186.6344, grad_fn=) , actor= tensor(0.3075, grad_fn=) , critic= tensor(1863.2683, grad_fn=) , return= 173395.2932428352\n", + "probs of actions: tensor([0.0512, 0.1064, 0.0287, 0.0367, 0.0185, 0.1100, 0.0058, 0.0913, 0.0662,\n", + " 0.0038, 0.0906, 0.0462, 0.0341, 0.0052, 0.1115, 0.0315, 0.0548, 0.0880,\n", + " 0.0345, 0.0692, 0.0287, 0.1091, 0.0176, 0.0397, 0.0454],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "278000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 29, 38, 41, 25, 28, 42, 37, 37, 39, 42, 21, 14, 46, 43, 41, 42, 32,\n", + " 40, 27, 48, 34, 43, 31, 43])\n", + "loss= tensor(178.7505, grad_fn=) , actor= tensor(0.3257, grad_fn=) , critic= tensor(1784.2474, grad_fn=) , return= 174278.320514798\n", + "probs of actions: tensor([0.0310, 0.0622, 0.0245, 0.0578, 0.0108, 0.0215, 0.0546, 0.0917, 0.0915,\n", + " 0.0470, 0.0538, 0.0049, 0.0051, 0.0461, 0.0424, 0.0535, 0.0527, 0.0294,\n", + " 0.0196, 0.0173, 0.0094, 0.1105, 0.0408, 0.0383, 0.0405],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "279000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 29, 37, 37, 37, 37, 30, 37, 34, 29, 25, 22, 34, 47, 43, 34, 43, 34,\n", + " 28, 43, 34, 43, 38, 37, 31])\n", + "loss= tensor(175.6331, grad_fn=) , actor= tensor(-0.4611, grad_fn=) , critic= tensor(1760.9426, grad_fn=) , return= 175559.0951746271\n", + "probs of actions: tensor([0.0601, 0.0615, 0.0924, 0.0924, 0.0925, 0.0925, 0.0178, 0.0923, 0.1111,\n", + " 0.0664, 0.0110, 0.0092, 0.1115, 0.0180, 0.0429, 0.1104, 0.0426, 0.1099,\n", + " 0.0222, 0.0418, 0.1090, 0.0414, 0.0249, 0.0865, 0.0373],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "280000 adversary: AdversaryModes.myopic\n", + " actions: tensor([13, 35, 26, 42, 47, 45, 46, 43, 32, 37, 30, 27, 35, 39, 38, 22, 29, 34,\n", + " 34, 34, 46, 36, 38, 3, 41])\n", + "loss= tensor(184.6038, grad_fn=) , actor= tensor(-2.2895, grad_fn=) , critic= tensor(1868.9333, grad_fn=) , return= 174169.36475200235\n", + "probs of actions: tensor([0.0039, 0.0309, 0.0333, 0.0557, 0.0178, 0.0193, 0.0500, 0.0453, 0.0292,\n", + " 0.0956, 0.0175, 0.0173, 0.0318, 0.0475, 0.0245, 0.0094, 0.0688, 0.1082,\n", + " 0.1078, 0.1075, 0.0459, 0.0140, 0.0251, 0.0017, 0.0542],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "281000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 33, 27, 34, 16, 42, 28, 31, 33, 39, 46, 46, 30, 45, 35, 16, 26, 49,\n", + " 28, 31, 29, 34, 37, 7, 45])\n", + "loss= tensor(178.0053, grad_fn=) , actor= tensor(-5.8080, grad_fn=) , critic= tensor(1838.1333, grad_fn=) , return= 172639.22372589476\n", + "probs of actions: tensor([0.0090, 0.0128, 0.0176, 0.1064, 0.0095, 0.0568, 0.0212, 0.0362, 0.0127,\n", + " 0.0496, 0.0489, 0.0486, 0.0178, 0.0196, 0.0326, 0.0095, 0.0340, 0.0061,\n", + " 0.0212, 0.0372, 0.0709, 0.1066, 0.0909, 0.0022, 0.0202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "282000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 34, 46, 31, 43, 34, 16, 40, 29, 31, 27, 34, 45, 34, 46, 22, 16, 29,\n", + " 34, 12, 34, 33, 44, 34, 24])\n", + "loss= tensor(172.4665, grad_fn=) , actor= tensor(-4.8758, grad_fn=) , critic= tensor(1773.4229, grad_fn=) , return= 173036.9924256345\n", + "probs of actions: tensor([0.0090, 0.1040, 0.0524, 0.0357, 0.0455, 0.1067, 0.0096, 0.0185, 0.0684,\n", + " 0.0363, 0.0178, 0.1082, 0.0198, 0.1073, 0.0482, 0.0092, 0.0097, 0.0712,\n", + " 0.1066, 0.0025, 0.1064, 0.0137, 0.0375, 0.1049, 0.0211],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "283000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 37, 29, 35, 29, 38, 30, 43, 24, 39, 42, 39, 34, 37, 46, 42, 44, 38,\n", + " 34, 34, 39, 39, 37, 42, 37])\n", + "loss= tensor(191.7418, grad_fn=) , actor= tensor(11.3567, grad_fn=) , critic= tensor(1803.8512, grad_fn=) , return= 175966.78298216237\n", + "probs of actions: tensor([0.0463, 0.1008, 0.0647, 0.0318, 0.0662, 0.0242, 0.0170, 0.0434, 0.0211,\n", + " 0.0493, 0.0535, 0.0491, 0.1071, 0.0998, 0.0501, 0.0526, 0.0381, 0.0248,\n", + " 0.1061, 0.1059, 0.0485, 0.0484, 0.0956, 0.0513, 0.0947],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "284000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 36, 34, 24, 18, 37, 42, 22, 26, 36, 45, 36, 31, 32, 38, 28, 26, 45,\n", + " 29, 20, 41, 41, 32, 32, 26])\n", + "loss= tensor(177.5660, grad_fn=) , actor= tensor(4.5549, grad_fn=) , critic= tensor(1730.1106, grad_fn=) , return= 174156.55298637992\n", + "probs of actions: tensor([0.0636, 0.0139, 0.1022, 0.0217, 0.0060, 0.1024, 0.0528, 0.0087, 0.0335,\n", + " 0.0137, 0.0200, 0.0138, 0.0358, 0.0281, 0.0246, 0.0208, 0.0342, 0.0203,\n", + " 0.0718, 0.0095, 0.0551, 0.0546, 0.0281, 0.0281, 0.0346],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "285000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 29, 34, 37, 45, 26, 47, 40, 29, 15, 44, 41, 28, 39, 42, 39, 40, 34,\n", + " 45, 37, 34, 0, 42, 45, 38])\n", + "loss= tensor(175.0687, grad_fn=) , actor= tensor(-11.7985, grad_fn=) , critic= tensor(1868.6722, grad_fn=) , return= 173423.1580585767\n", + "probs of actions: tensor([0.0976, 0.0633, 0.1041, 0.0988, 0.0194, 0.0330, 0.0176, 0.0196, 0.0680,\n", + " 0.0042, 0.0392, 0.0593, 0.0209, 0.0493, 0.0517, 0.0491, 0.0203, 0.1063,\n", + " 0.0200, 0.0942, 0.1057, 0.0009, 0.0508, 0.0203, 0.0256],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "286000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 39, 41, 28, 34, 46, 34, 41, 44, 11, 37, 39, 37, 42, 43, 34, 43, 46,\n", + " 37, 37, 29, 34, 29, 2, 40])\n", + "loss= tensor(177.5589, grad_fn=) , actor= tensor(-8.8055, grad_fn=) , critic= tensor(1863.6436, grad_fn=) , return= 175214.44936241204\n", + "probs of actions: tensor([0.0319, 0.0512, 0.0604, 0.0211, 0.1038, 0.0570, 0.1043, 0.0587, 0.0387,\n", + " 0.0032, 0.1005, 0.0505, 0.0997, 0.0502, 0.0416, 0.1047, 0.0412, 0.0526,\n", + " 0.0971, 0.0967, 0.0725, 0.1037, 0.0727, 0.0011, 0.0208],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "287000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 46, 41, 23, 28, 32, 43, 30, 37, 34, 34, 41, 31, 47, 31, 43, 34, 42,\n", + " 44, 36, 23, 39, 39, 47, 37])\n", + "loss= tensor(183.2621, grad_fn=) , actor= tensor(0.5752, grad_fn=) , critic= tensor(1826.8688, grad_fn=) , return= 175139.36743073625\n", + "probs of actions: tensor([0.0600, 0.0589, 0.0594, 0.0087, 0.0212, 0.0273, 0.0448, 0.0173, 0.1010,\n", + " 0.1061, 0.1062, 0.0563, 0.0349, 0.0172, 0.0351, 0.0420, 0.1053, 0.0503,\n", + " 0.0398, 0.0143, 0.0088, 0.0510, 0.0509, 0.0175, 0.0942],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "288000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 37, 43, 39, 18, 15, 40, 43, 41, 44, 23, 42, 46, 34, 29, 35, 18, 30,\n", + " 37, 5, 37, 37, 26, 35, 38])\n", + "loss= tensor(182.3901, grad_fn=) , actor= tensor(-4.6085, grad_fn=) , critic= tensor(1869.9858, grad_fn=) , return= 172638.7551954219\n", + "probs of actions: tensor([0.0531, 0.0998, 0.0475, 0.0548, 0.0060, 0.0040, 0.0187, 0.0454, 0.0596,\n", + " 0.0402, 0.0087, 0.0520, 0.0543, 0.1018, 0.0701, 0.0326, 0.0063, 0.0174,\n", + " 0.0961, 0.0016, 0.0952, 0.0945, 0.0331, 0.0327, 0.0257],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "289000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 41, 34, 37, 48, 41, 47, 44, 38, 41, 37, 29, 32, 34, 31, 29, 39, 26,\n", + " 31, 47, 30, 46, 44, 36, 45])\n", + "loss= tensor(183.3759, grad_fn=) , actor= tensor(-7.6318, grad_fn=) , critic= tensor(1910.0762, grad_fn=) , return= 175252.16238702287\n", + "probs of actions: tensor([0.0244, 0.0652, 0.0969, 0.1029, 0.0084, 0.0639, 0.0166, 0.0403, 0.0243,\n", + " 0.0625, 0.1021, 0.0702, 0.0272, 0.1003, 0.0351, 0.0714, 0.0537, 0.0328,\n", + " 0.0354, 0.0167, 0.0177, 0.0510, 0.0408, 0.0140, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "290000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 24, 17, 28, 30, 39, 29, 44, 26, 49, 44, 37, 34, 32, 29, 39, 25, 14,\n", + " 25, 41, 29, 22, 26, 5, 34])\n", + "loss= tensor(171.8862, grad_fn=) , actor= tensor(-14.0443, grad_fn=) , critic= tensor(1859.3046, grad_fn=) , return= 172790.43621614782\n", + "probs of actions: tensor([0.0945, 0.0222, 0.0047, 0.0221, 0.0174, 0.0553, 0.0682, 0.0411, 0.0317,\n", + " 0.0057, 0.0414, 0.1028, 0.0997, 0.0266, 0.0716, 0.0544, 0.0094, 0.0046,\n", + " 0.0095, 0.0604, 0.0727, 0.0091, 0.0327, 0.0015, 0.0978],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "291000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 35, 42, 37, 15, 41, 46, 38, 43, 31, 46, 41, 46, 37, 26, 29, 30, 42,\n", + " 26, 21, 35, 49, 37, 34, 40])\n", + "loss= tensor(182.2189, grad_fn=) , actor= tensor(-4.6542, grad_fn=) , critic= tensor(1868.7312, grad_fn=) , return= 174651.15108710376\n", + "probs of actions: tensor([0.0470, 0.0326, 0.0555, 0.1021, 0.0040, 0.0694, 0.0564, 0.0242, 0.0438,\n", + " 0.0334, 0.0549, 0.0666, 0.0542, 0.1004, 0.0317, 0.0693, 0.0171, 0.0539,\n", + " 0.0321, 0.0054, 0.0335, 0.0062, 0.0960, 0.0947, 0.0201],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "292000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 46, 34, 37, 34, 12, 27, 16, 41, 42, 42, 29, 29, 42, 45, 31, 37, 29,\n", + " 45, 29, 29, 13, 29, 29, 35])\n", + "loss= tensor(177.9176, grad_fn=) , actor= tensor(-4.9460, grad_fn=) , critic= tensor(1828.6361, grad_fn=) , return= 173543.16849059632\n", + "probs of actions: tensor([0.0710, 0.0587, 0.0922, 0.1013, 0.0939, 0.0021, 0.0164, 0.0091, 0.0683,\n", + " 0.0548, 0.0547, 0.0671, 0.0676, 0.0545, 0.0191, 0.0343, 0.0984, 0.0688,\n", + " 0.0192, 0.0691, 0.0694, 0.0037, 0.0697, 0.0697, 0.0327],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "293000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 46, 16, 18, 40, 34, 29, 48, 46, 32, 31, 17, 26, 48, 27, 43, 41, 34,\n", + " 32, 28, 44, 10, 24, 34, 18])\n", + "loss= tensor(170.6294, grad_fn=) , actor= tensor(-5.6515, grad_fn=) , critic= tensor(1762.8088, grad_fn=) , return= 173709.97226993396\n", + "probs of actions: tensor([0.0905, 0.0564, 0.0095, 0.0058, 0.0184, 0.0942, 0.0644, 0.0079, 0.0536,\n", + " 0.0286, 0.0348, 0.0049, 0.0306, 0.0080, 0.0178, 0.0428, 0.0650, 0.0947,\n", + " 0.0286, 0.0215, 0.0431, 0.0043, 0.0226, 0.0936, 0.0066],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "294000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 39, 8, 29, 46, 36, 23, 46, 34, 35, 32, 34, 34, 36, 44, 31, 29, 30,\n", + " 41, 39, 31, 37, 30, 32, 35])\n", + "loss= tensor(184.4204, grad_fn=) , actor= tensor(5.3230, grad_fn=) , critic= tensor(1790.9744, grad_fn=) , return= 174415.02312349086\n", + "probs of actions: tensor([0.0552, 0.0575, 0.0016, 0.0619, 0.0537, 0.0129, 0.0086, 0.0525, 0.0930,\n", + " 0.0320, 0.0301, 0.0936, 0.0935, 0.0130, 0.0425, 0.0359, 0.0673, 0.0176,\n", + " 0.0633, 0.0560, 0.0362, 0.0952, 0.0178, 0.0301, 0.0324],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "295000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 44, 41, 34, 38, 28, 27, 31, 35, 13, 40, 42, 34, 41, 37, 44, 39, 39,\n", + " 26, 12, 34, 33, 29, 45, 31])\n", + "loss= tensor(179.2253, grad_fn=) , actor= tensor(-3.5729, grad_fn=) , critic= tensor(1827.9824, grad_fn=) , return= 174057.02801140226\n", + "probs of actions: tensor([0.0303, 0.0403, 0.0691, 0.0911, 0.0236, 0.0214, 0.0183, 0.0355, 0.0315,\n", + " 0.0033, 0.0192, 0.0564, 0.0932, 0.0648, 0.1008, 0.0421, 0.0558, 0.0558,\n", + " 0.0312, 0.0023, 0.0927, 0.0143, 0.0682, 0.0192, 0.0371],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "296000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 46, 35, 37, 41, 37, 44, 26, 34, 44, 38, 16, 32, 49, 43, 27, 26, 27,\n", + " 39, 38, 48, 37, 38, 42, 32])\n", + "loss= tensor(175.3902, grad_fn=) , actor= tensor(-3.4502, grad_fn=) , critic= tensor(1788.4037, grad_fn=) , return= 175223.0308146661\n", + "probs of actions: tensor([0.0915, 0.0539, 0.0307, 0.1068, 0.0694, 0.1070, 0.0407, 0.0300, 0.0963,\n", + " 0.0412, 0.0243, 0.0088, 0.0293, 0.0053, 0.0414, 0.0185, 0.0307, 0.0186,\n", + " 0.0564, 0.0250, 0.0087, 0.1007, 0.0252, 0.0532, 0.0295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "297000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 29, 42, 32, 48, 31, 43, 26, 34, 29, 37, 4, 43, 42, 33, 46, 29,\n", + " 46, 47, 19, 39, 34, 31, 24])\n", + "loss= tensor(168.8078, grad_fn=) , actor= tensor(-2.0194, grad_fn=) , critic= tensor(1708.2715, grad_fn=) , return= 174535.00681927562\n", + "probs of actions: tensor([0.0938, 0.0596, 0.0604, 0.0574, 0.0282, 0.0080, 0.0367, 0.0441, 0.0304,\n", + " 0.0990, 0.0651, 0.1060, 0.0010, 0.0422, 0.0557, 0.0140, 0.0467, 0.0670,\n", + " 0.0462, 0.0162, 0.0058, 0.0573, 0.0971, 0.0382, 0.0231],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "298000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 34, 47, 31, 44, 34, 28, 42, 29, 29, 16, 32, 37, 29, 47, 37, 41, 32,\n", + " 24, 29, 47, 27, 45, 46, 31])\n", + "loss= tensor(174.6505, grad_fn=) , actor= tensor(-5.4911, grad_fn=) , critic= tensor(1801.4164, grad_fn=) , return= 174294.10468013244\n", + "probs of actions: tensor([0.0172, 0.0946, 0.0160, 0.0358, 0.0400, 0.0978, 0.0209, 0.0579, 0.0651,\n", + " 0.0657, 0.0090, 0.0295, 0.1014, 0.0672, 0.0158, 0.1000, 0.0624, 0.0297,\n", + " 0.0229, 0.0685, 0.0160, 0.0180, 0.0182, 0.0452, 0.0377],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "299000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 35, 23, 39, 25, 31, 26, 2, 34, 45, 29, 43, 40, 38, 30, 43, 34, 44,\n", + " 42, 44, 31, 37, 29, 23, 37])\n", + "loss= tensor(183.5506, grad_fn=) , actor= tensor(13.6959, grad_fn=) , critic= tensor(1698.5461, grad_fn=) , return= 173850.49142399232\n", + "probs of actions: tensor([0.0240, 0.0296, 0.0084, 0.0639, 0.0090, 0.0363, 0.0306, 0.0008, 0.0973,\n", + " 0.0170, 0.0659, 0.0438, 0.0195, 0.0242, 0.0175, 0.0426, 0.0963, 0.0414,\n", + " 0.0564, 0.0414, 0.0379, 0.0972, 0.0687, 0.0087, 0.0956],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "300000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 42, 37, 34, 31, 28, 34, 44, 37, 39, 26, 44, 48, 35, 34, 46, 35, 46,\n", + " 39, 43, 43, 30, 43, 46, 25])\n", + "loss= tensor(170.0327, grad_fn=) , actor= tensor(-5.5465, grad_fn=) , critic= tensor(1755.7917, grad_fn=) , return= 176733.01566393135\n", + "probs of actions: tensor([0.1053, 0.0570, 0.1063, 0.0932, 0.0368, 0.0212, 0.0950, 0.0399, 0.1063,\n", + " 0.0644, 0.0316, 0.0403, 0.0084, 0.0304, 0.0956, 0.0465, 0.0305, 0.0460,\n", + " 0.0631, 0.0428, 0.0425, 0.0174, 0.0422, 0.0446, 0.0096],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "301000 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 31, 34, 42, 0, 37, 39, 26, 26, 44, 42, 21, 45, 49, 43, 39, 48, 36,\n", + " 15, 43, 42, 37, 38, 43, 41])\n", + "loss= tensor(174.2155, grad_fn=) , actor= tensor(4.1690, grad_fn=) , critic= tensor(1700.4648, grad_fn=) , return= 172261.14243147348\n", + "probs of actions: tensor([0.0056, 0.0379, 0.0929, 0.0576, 0.0006, 0.1056, 0.0651, 0.0314, 0.0315,\n", + " 0.0415, 0.0569, 0.0051, 0.0171, 0.0050, 0.0430, 0.0640, 0.0084, 0.0132,\n", + " 0.0041, 0.0420, 0.0551, 0.0994, 0.0243, 0.0409, 0.0606],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "302000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 46, 29, 35, 44, 44, 37, 18, 32, 34, 46, 33, 32, 29, 41, 32, 11, 11,\n", + " 49, 46, 43, 20, 3, 28, 27])\n", + "loss= tensor(156.8992, grad_fn=) , actor= tensor(-27.2709, grad_fn=) , critic= tensor(1841.7010, grad_fn=) , return= 172762.3646017755\n", + "probs of actions: tensor([0.0294, 0.0518, 0.0569, 0.0305, 0.0401, 0.0403, 0.1052, 0.0053, 0.0324,\n", + " 0.0966, 0.0484, 0.0140, 0.0326, 0.0624, 0.0634, 0.0326, 0.0030, 0.0030,\n", + " 0.0053, 0.0457, 0.0417, 0.0090, 0.0013, 0.0212, 0.0178],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "303000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 18, 46, 44, 43, 25, 31, 29, 42, 18, 33, 23, 28, 37, 46, 42, 27, 42,\n", + " 24, 39, 30, 34, 47, 35, 39])\n", + "loss= tensor(180.4427, grad_fn=) , actor= tensor(3.4692, grad_fn=) , critic= tensor(1769.7357, grad_fn=) , return= 173189.62997026855\n", + "probs of actions: tensor([0.0288, 0.0053, 0.0521, 0.0397, 0.0462, 0.0082, 0.0405, 0.0617, 0.0578,\n", + " 0.0053, 0.0139, 0.0079, 0.0210, 0.1035, 0.0476, 0.0564, 0.0172, 0.0564,\n", + " 0.0220, 0.0636, 0.0173, 0.0943, 0.0157, 0.0327, 0.0628],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "304000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 33, 35, 46, 14, 43, 38, 34, 38, 22, 37, 29, 39, 44, 41, 41, 34, 29,\n", + " 40, 26, 39, 44, 29, 41, 31])\n", + "loss= tensor(188.6701, grad_fn=) , actor= tensor(11.0674, grad_fn=) , critic= tensor(1776.0271, grad_fn=) , return= 175101.94158648106\n", + "probs of actions: tensor([0.0311, 0.0140, 0.0316, 0.0527, 0.0034, 0.0442, 0.0239, 0.0970, 0.0239,\n", + " 0.0077, 0.1062, 0.0651, 0.0637, 0.0414, 0.0645, 0.0642, 0.0970, 0.0667,\n", + " 0.0195, 0.0307, 0.0625, 0.0414, 0.0674, 0.0616, 0.0416],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "305000 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 39, 33, 39, 37, 46, 35, 42, 46, 37, 32, 23, 31, 29, 37, 47, 44, 44,\n", + " 40, 41, 34, 38, 38, 20, 23])\n", + "loss= tensor(169.2382, grad_fn=) , actor= tensor(-5.5755, grad_fn=) , critic= tensor(1748.1373, grad_fn=) , return= 176743.0046785527\n", + "probs of actions: tensor([0.0086, 0.0636, 0.0140, 0.0636, 0.1094, 0.0515, 0.0312, 0.0567, 0.0502,\n", + " 0.1085, 0.0315, 0.0076, 0.0402, 0.0670, 0.1063, 0.0152, 0.0422, 0.0421,\n", + " 0.0198, 0.0632, 0.0979, 0.0252, 0.0253, 0.0090, 0.0081],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "306000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 43, 46, 46, 44, 42, 23, 41, 44, 42, 30, 37, 24, 32, 35, 28, 40,\n", + " 48, 41, 10, 39, 35, 34, 37])\n", + "loss= tensor(189.6647, grad_fn=) , actor= tensor(0.2504, grad_fn=) , critic= tensor(1894.1426, grad_fn=) , return= 175148.8513401012\n", + "probs of actions: tensor([0.0932, 0.1123, 0.0444, 0.0509, 0.0505, 0.0419, 0.0591, 0.0072, 0.0671,\n", + " 0.0426, 0.0587, 0.0162, 0.1114, 0.0215, 0.0313, 0.0308, 0.0206, 0.0190,\n", + " 0.0081, 0.0625, 0.0034, 0.0618, 0.0311, 0.0965, 0.1048],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "307000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 37, 38, 30, 28, 24, 39, 37, 34, 41, 49, 34, 37, 42, 21, 39, 47, 35,\n", + " 29, 30, 42, 33, 33, 24, 41])\n", + "loss= tensor(177.3228, grad_fn=) , actor= tensor(-5.7426, grad_fn=) , critic= tensor(1830.6539, grad_fn=) , return= 175046.8296868437\n", + "probs of actions: tensor([0.0376, 0.1137, 0.0231, 0.0168, 0.0210, 0.0214, 0.0632, 0.1142, 0.1005,\n", + " 0.0648, 0.0046, 0.1005, 0.1125, 0.0579, 0.0045, 0.0620, 0.0150, 0.0306,\n", + " 0.0724, 0.0165, 0.0567, 0.0153, 0.0153, 0.0217, 0.0596],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "308000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 29, 27, 44, 44, 39, 33, 29, 37, 34, 43, 39, 39, 34, 26, 37, 37, 39,\n", + " 23, 42, 27, 24, 29, 49, 34])\n", + "loss= tensor(184.0863, grad_fn=) , actor= tensor(-5.6423, grad_fn=) , critic= tensor(1897.2855, grad_fn=) , return= 174828.3986879239\n", + "probs of actions: tensor([0.0162, 0.0626, 0.0153, 0.0407, 0.0409, 0.0636, 0.0145, 0.0671, 0.1157,\n", + " 0.1013, 0.0431, 0.0629, 0.0628, 0.1013, 0.0290, 0.1122, 0.1114, 0.0620,\n", + " 0.0073, 0.0571, 0.0162, 0.0218, 0.0719, 0.0052, 0.0989],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "309000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 28, 37, 26, 30, 27, 47, 24, 28, 37, 41, 31, 46, 46, 17, 37, 42, 41,\n", + " 29, 43, 34, 44, 34, 26, 39])\n", + "loss= tensor(184.9028, grad_fn=) , actor= tensor(10.1845, grad_fn=) , critic= tensor(1747.1825, grad_fn=) , return= 174458.39872350078\n", + "probs of actions: tensor([0.0314, 0.0211, 0.1173, 0.0280, 0.0161, 0.0151, 0.0149, 0.0223, 0.0211,\n", + " 0.1166, 0.0625, 0.0404, 0.0476, 0.0472, 0.0041, 0.1135, 0.0583, 0.0599,\n", + " 0.0704, 0.0412, 0.0988, 0.0418, 0.0984, 0.0296, 0.0617],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "310000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 32, 35, 44, 37, 19, 44, 31, 37, 34, 17, 30, 34, 42, 10, 47, 46, 33,\n", + " 21, 35, 42, 46, 38, 31, 37])\n", + "loss= tensor(174.3051, grad_fn=) , actor= tensor(0.0576, grad_fn=) , critic= tensor(1742.4747, grad_fn=) , return= 173506.20214090287\n", + "probs of actions: tensor([0.0234, 0.0314, 0.0289, 0.0391, 0.1192, 0.0051, 0.0397, 0.0393, 0.1187,\n", + " 0.1016, 0.0041, 0.0157, 0.1018, 0.0574, 0.0032, 0.0144, 0.0466, 0.0154,\n", + " 0.0048, 0.0299, 0.0562, 0.0456, 0.0244, 0.0408, 0.1096],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "311000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 43, 38, 31, 30, 37, 29, 42, 27, 41, 9, 30, 37, 29, 37, 37, 7, 37,\n", + " 34, 34, 43, 34, 46, 37, 32])\n", + "loss= tensor(181.5929, grad_fn=) , actor= tensor(6.2803, grad_fn=) , critic= tensor(1753.1263, grad_fn=) , return= 173284.87324346925\n", + "probs of actions: tensor([0.0528, 0.0464, 0.0232, 0.0367, 0.0163, 0.1216, 0.0625, 0.0584, 0.0148,\n", + " 0.0622, 0.0016, 0.0158, 0.1187, 0.0656, 0.1176, 0.1169, 0.0013, 0.1156,\n", + " 0.1046, 0.1046, 0.0408, 0.1039, 0.0460, 0.1120, 0.0312],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "312000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 46, 27, 35, 34, 46, 26, 6, 30, 46, 37, 46, 39, 34, 34, 34, 37, 26,\n", + " 46, 43, 24, 37, 45, 44, 39])\n", + "loss= tensor(178.6835, grad_fn=) , actor= tensor(2.0930, grad_fn=) , critic= tensor(1765.9044, grad_fn=) , return= 173451.207325012\n", + "probs of actions: tensor([0.0582, 0.0525, 0.0149, 0.0301, 0.1055, 0.0510, 0.0287, 0.0006, 0.0161,\n", + " 0.0492, 0.1171, 0.0487, 0.0628, 0.1072, 0.1073, 0.1071, 0.1139, 0.0298,\n", + " 0.0468, 0.0413, 0.0218, 0.1110, 0.0171, 0.0400, 0.0612],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "313000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 40, 31, 42, 23, 46, 34, 27, 48, 24, 29, 42, 39, 39, 26, 37, 44, 28,\n", + " 43, 17, 12, 39, 42, 47, 33])\n", + "loss= tensor(170.1289, grad_fn=) , actor= tensor(-14.8440, grad_fn=) , critic= tensor(1849.7296, grad_fn=) , return= 173446.41091863665\n", + "probs of actions: tensor([0.1046, 0.0175, 0.0362, 0.0622, 0.0073, 0.0510, 0.1092, 0.0144, 0.0075,\n", + " 0.0209, 0.0619, 0.0616, 0.0617, 0.0616, 0.0295, 0.1117, 0.0411, 0.0209,\n", + " 0.0426, 0.0042, 0.0020, 0.0605, 0.0592, 0.0152, 0.0147],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "314000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 44, 31, 46, 34, 46, 20, 32, 37, 18, 46, 48, 37, 28, 34, 46, 43, 39,\n", + " 29, 34, 36, 31, 48, 46, 41])\n", + "loss= tensor(179.1306, grad_fn=) , actor= tensor(-2.0486, grad_fn=) , critic= tensor(1811.7922, grad_fn=) , return= 174067.60969513346\n", + "probs of actions: tensor([0.0276, 0.0394, 0.0369, 0.0516, 0.1091, 0.0508, 0.0071, 0.0327, 0.1111,\n", + " 0.0046, 0.0488, 0.0078, 0.1093, 0.0219, 0.1112, 0.0472, 0.0430, 0.0594,\n", + " 0.0638, 0.1101, 0.0118, 0.0390, 0.0083, 0.0453, 0.0605],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "315000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 27, 44, 30, 29, 37, 24, 34, 35, 43, 42, 42, 28, 46, 36, 41, 34, 34,\n", + " 32, 35, 31, 40, 37, 29, 41])\n", + "loss= tensor(186.8811, grad_fn=) , actor= tensor(5.0590, grad_fn=) , critic= tensor(1818.2212, grad_fn=) , return= 175032.98173357302\n", + "probs of actions: tensor([0.0274, 0.0145, 0.0405, 0.0168, 0.0581, 0.1099, 0.0202, 0.1106, 0.0301,\n", + " 0.0442, 0.0636, 0.0635, 0.0221, 0.0485, 0.0117, 0.0632, 0.1100, 0.1100,\n", + " 0.0327, 0.0306, 0.0399, 0.0189, 0.1020, 0.0642, 0.0603],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "316000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 15, 43, 37, 27, 45, 34, 46, 34, 39, 43, 26, 41, 34, 31, 26, 34, 41,\n", + " 47, 30, 34, 29, 31, 38, 44])\n", + "loss= tensor(186.7377, grad_fn=) , actor= tensor(-0.7082, grad_fn=) , critic= tensor(1874.4592, grad_fn=) , return= 174286.61877335198\n", + "probs of actions: tensor([0.0482, 0.0027, 0.0473, 0.1108, 0.0147, 0.0157, 0.1091, 0.0512, 0.1097,\n", + " 0.0614, 0.0440, 0.0277, 0.0668, 0.1098, 0.0401, 0.0281, 0.1097, 0.0645,\n", + " 0.0150, 0.0167, 0.1087, 0.0637, 0.0408, 0.0250, 0.0415],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "317000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 42, 32, 39, 41, 42, 41, 39, 29, 33, 26, 35, 37, 26, 37, 39, 20, 37,\n", + " 42, 48, 41, 42, 40, 41, 16])\n", + "loss= tensor(169.3947, grad_fn=) , actor= tensor(-4.8490, grad_fn=) , critic= tensor(1742.4376, grad_fn=) , return= 176621.35328043238\n", + "probs of actions: tensor([0.0176, 0.0646, 0.0310, 0.0624, 0.0696, 0.0651, 0.0687, 0.0620, 0.0606,\n", + " 0.0129, 0.0273, 0.0302, 0.1073, 0.0276, 0.1063, 0.0609, 0.0075, 0.1047,\n", + " 0.0629, 0.0075, 0.0630, 0.0624, 0.0188, 0.0623, 0.0084],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "318000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 46, 41, 38, 34, 42, 31, 34, 34, 24, 0, 42, 42, 39, 34, 24, 35, 35,\n", + " 37, 42, 46, 34, 42, 43, 34])\n", + "loss= tensor(176.3717, grad_fn=) , actor= tensor(3.9603, grad_fn=) , critic= tensor(1724.1145, grad_fn=) , return= 173785.882459081\n", + "probs of actions: tensor([0.0544, 0.0517, 0.0724, 0.0225, 0.1181, 0.0669, 0.0395, 0.1199, 0.1201,\n", + " 0.0191, 0.0004, 0.0667, 0.0657, 0.0602, 0.1198, 0.0193, 0.0299, 0.0300,\n", + " 0.1079, 0.0644, 0.0455, 0.1178, 0.0640, 0.0421, 0.1170],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "319000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 44, 39, 41, 37, 14, 37, 41, 42, 31, 43, 34, 30, 26, 44, 34, 37, 42,\n", + " 41, 4, 39, 31, 41, 46, 42])\n", + "loss= tensor(183.7242, grad_fn=) , actor= tensor(-4.7144, grad_fn=) , critic= tensor(1884.3862, grad_fn=) , return= 173259.76583270723\n", + "probs of actions: tensor([0.0217, 0.0385, 0.0619, 0.0711, 0.1173, 0.0026, 0.1172, 0.0691, 0.0673,\n", + " 0.0417, 0.0451, 0.1219, 0.0162, 0.0280, 0.0403, 0.1212, 0.1126, 0.0656,\n", + " 0.0647, 0.0007, 0.0598, 0.0431, 0.0633, 0.0446, 0.0640],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "320000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 29, 29, 43, 31, 44, 46, 42, 46, 39, 34, 49, 29, 38, 43, 45, 39, 27,\n", + " 39, 34, 35, 26, 36, 29, 28])\n", + "loss= tensor(182.8194, grad_fn=) , actor= tensor(0.2414, grad_fn=) , critic= tensor(1825.7791, grad_fn=) , return= 176635.4882748931\n", + "probs of actions: tensor([0.0072, 0.0562, 0.0569, 0.0471, 0.0400, 0.0391, 0.0461, 0.0728, 0.0454,\n", + " 0.0588, 0.1192, 0.0043, 0.0619, 0.0222, 0.0432, 0.0166, 0.0579, 0.0138,\n", + " 0.0578, 0.1174, 0.0302, 0.0273, 0.0119, 0.0646, 0.0204],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "321000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 43, 42, 33, 27, 46, 37, 26, 37, 38, 46, 31, 20, 29, 24, 43, 31, 28,\n", + " 31, 39, 34, 30, 29, 43, 24])\n", + "loss= tensor(185.1709, grad_fn=) , actor= tensor(2.3794, grad_fn=) , critic= tensor(1827.9148, grad_fn=) , return= 175096.31306775895\n", + "probs of actions: tensor([0.0491, 0.0485, 0.0706, 0.0116, 0.0129, 0.0473, 0.1209, 0.0256, 0.1206,\n", + " 0.0227, 0.0454, 0.0405, 0.0070, 0.0631, 0.0187, 0.0438, 0.0412, 0.0206,\n", + " 0.0412, 0.0558, 0.1173, 0.0179, 0.0652, 0.0420, 0.0193],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "322000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 45, 34, 41, 43, 34, 37, 37, 34, 29, 34, 47, 41, 37, 44, 10, 38,\n", + " 37, 42, 31, 35, 34, 37, 32])\n", + "loss= tensor(182.0333, grad_fn=) , actor= tensor(-1.9551, grad_fn=) , critic= tensor(1839.8839, grad_fn=) , return= 175842.39188866934\n", + "probs of actions: tensor([0.1150, 0.0724, 0.0168, 0.1180, 0.0713, 0.0468, 0.1201, 0.1233, 0.1229,\n", + " 0.1211, 0.0589, 0.1214, 0.0134, 0.0669, 0.1198, 0.0400, 0.0026, 0.0235,\n", + " 0.1167, 0.0686, 0.0408, 0.0308, 0.1184, 0.1140, 0.0321],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "323000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 30, 42, 26, 37, 20, 40, 34, 37, 42, 41, 29, 37, 42, 32, 27, 34, 42,\n", + " 17, 43, 41, 34, 28, 31, 42])\n", + "loss= tensor(182.3763, grad_fn=) , actor= tensor(-0.9259, grad_fn=) , critic= tensor(1833.0220, grad_fn=) , return= 174259.62428253455\n", + "probs of actions: tensor([0.0390, 0.0177, 0.0715, 0.0255, 0.1244, 0.0064, 0.0164, 0.1220, 0.1235,\n", + " 0.0712, 0.0686, 0.0599, 0.1217, 0.0704, 0.0302, 0.0129, 0.1220, 0.0694,\n", + " 0.0037, 0.0424, 0.0645, 0.1200, 0.0215, 0.0422, 0.0678],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "324000 adversary: AdversaryModes.myopic\n", + " actions: tensor([36, 28, 44, 41, 43, 34, 26, 34, 37, 39, 37, 31, 26, 31, 29, 34, 5, 34,\n", + " 15, 40, 22, 26, 37, 28, 25])\n", + "loss= tensor(163.1185, grad_fn=) , actor= tensor(-22.1745, grad_fn=) , critic= tensor(1852.9299, grad_fn=) , return= 173434.83757903703\n", + "probs of actions: tensor([0.0111, 0.0208, 0.0375, 0.0707, 0.0460, 0.1220, 0.0248, 0.1234, 0.1269,\n", + " 0.0523, 0.1259, 0.0400, 0.0254, 0.0402, 0.0607, 0.1234, 0.0009, 0.1233,\n", + " 0.0026, 0.0173, 0.0079, 0.0263, 0.1180, 0.0213, 0.0081],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "325000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 30, 37, 19, 37, 43, 24, 46, 32, 34, 22, 31, 40, 34, 31, 30, 38, 43,\n", + " 42, 48, 32, 18, 38, 19, 37])\n", + "loss= tensor(169.9713, grad_fn=) , actor= tensor(-9.3624, grad_fn=) , critic= tensor(1793.3376, grad_fn=) , return= 174434.46207508887\n", + "probs of actions: tensor([0.0517, 0.0174, 0.1282, 0.0043, 0.1287, 0.0461, 0.0197, 0.0470, 0.0303,\n", + " 0.1241, 0.0071, 0.0409, 0.0167, 0.1236, 0.0414, 0.0166, 0.0221, 0.0423,\n", + " 0.0740, 0.0073, 0.0307, 0.0051, 0.0226, 0.0049, 0.1176],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "326000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 43, 35, 39, 34, 35, 43, 46, 39, 38, 46, 35, 42, 44, 34, 35, 34, 46,\n", + " 29, 42, 39, 39, 44, 39, 31])\n", + "loss= tensor(189.3838, grad_fn=) , actor= tensor(7.2675, grad_fn=) , critic= tensor(1821.1628, grad_fn=) , return= 177187.50573526273\n", + "probs of actions: tensor([0.0125, 0.0501, 0.0316, 0.0522, 0.1216, 0.0317, 0.0482, 0.0485, 0.0516,\n", + " 0.0225, 0.0474, 0.0324, 0.0724, 0.0401, 0.1234, 0.0325, 0.1233, 0.0455,\n", + " 0.0601, 0.0708, 0.0507, 0.0506, 0.0403, 0.0505, 0.0415],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "327000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 42, 34, 47, 34, 29, 29, 45, 41, 42, 34, 19, 34, 33, 36, 37, 37, 43,\n", + " 46, 28, 46, 42, 41, 37, 42])\n", + "loss= tensor(186.7900, grad_fn=) , actor= tensor(5.2615, grad_fn=) , critic= tensor(1815.2847, grad_fn=) , return= 175304.38789506123\n", + "probs of actions: tensor([0.0670, 0.0724, 0.1199, 0.0134, 0.1217, 0.0535, 0.0541, 0.0160, 0.0636,\n", + " 0.0727, 0.1242, 0.0045, 0.1249, 0.0126, 0.0107, 0.1262, 0.1255, 0.0439,\n", + " 0.0446, 0.0216, 0.0443, 0.0697, 0.0589, 0.1210, 0.0693],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "328000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 41, 35, 44, 35, 34, 34, 46, 37, 39, 42, 34, 27, 40, 37, 44, 45, 45,\n", + " 37, 29, 40, 32, 35, 30, 34])\n", + "loss= tensor(184.3558, grad_fn=) , actor= tensor(-0.9963, grad_fn=) , critic= tensor(1853.5208, grad_fn=) , return= 177033.56844346342\n", + "probs of actions: tensor([0.0485, 0.0648, 0.0315, 0.0394, 0.0317, 0.1299, 0.1305, 0.0458, 0.1316,\n", + " 0.0515, 0.0727, 0.1314, 0.0120, 0.0166, 0.1283, 0.0409, 0.0163, 0.0163,\n", + " 0.1257, 0.0594, 0.0173, 0.0295, 0.0328, 0.0164, 0.1279],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "329000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 14, 41, 37, 42, 38, 40, 18, 32, 43, 41, 29, 38, 39, 44, 37, 37, 37,\n", + " 31, 39, 41, 43, 43, 34, 41])\n", + "loss= tensor(192.0567, grad_fn=) , actor= tensor(14.9450, grad_fn=) , critic= tensor(1771.1163, grad_fn=) , return= 174787.6981174543\n", + "probs of actions: tensor([0.0117, 0.0023, 0.0661, 0.1293, 0.0729, 0.0247, 0.0162, 0.0043, 0.0286,\n", + " 0.0462, 0.0625, 0.0584, 0.0251, 0.0503, 0.0416, 0.1248, 0.1243, 0.1235,\n", + " 0.0409, 0.0499, 0.0592, 0.0429, 0.0427, 0.1296, 0.0584],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "330000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 35, 34, 41, 38, 34, 37, 46, 33, 41, 42, 29, 34, 37, 34, 47, 37,\n", + " 47, 42, 42, 34, 30, 36, 37])\n", + "loss= tensor(177.4620, grad_fn=) , actor= tensor(-4.2961, grad_fn=) , critic= tensor(1817.5803, grad_fn=) , return= 176683.66034370058\n", + "probs of actions: tensor([0.1333, 0.1312, 0.0297, 0.1376, 0.0624, 0.0244, 0.1400, 0.1320, 0.0437,\n", + " 0.0113, 0.0600, 0.0714, 0.0595, 0.1414, 0.1281, 0.1405, 0.0130, 0.1259,\n", + " 0.0131, 0.0694, 0.0693, 0.1382, 0.0154, 0.0108, 0.1213],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "331000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 44, 47, 43, 41, 34, 37, 40, 37, 34, 41, 37, 36, 24, 34, 35, 44, 42,\n", + " 37, 34, 46, 34, 37, 32, 37])\n", + "loss= tensor(199.1499, grad_fn=) , actor= tensor(11.8263, grad_fn=) , critic= tensor(1873.2355, grad_fn=) , return= 176772.3646879259\n", + "probs of actions: tensor([0.0463, 0.0407, 0.0128, 0.0463, 0.0606, 0.1368, 0.1352, 0.0167, 0.1344,\n", + " 0.1387, 0.0581, 0.1328, 0.0100, 0.0198, 0.1388, 0.0316, 0.0428, 0.0700,\n", + " 0.1280, 0.1367, 0.0405, 0.1355, 0.1254, 0.0304, 0.1239],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "332000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 34, 42, 20, 31, 37, 35, 34, 39, 26, 37, 12, 43, 5, 34, 34, 44,\n", + " 39, 34, 46, 46, 44, 31, 18])\n", + "loss= tensor(152.2685, grad_fn=) , actor= tensor(-10.6990, grad_fn=) , critic= tensor(1629.6753, grad_fn=) , return= 174042.32054962657\n", + "probs of actions: tensor([0.0554, 0.1317, 0.1363, 0.0727, 0.0056, 0.0399, 0.1324, 0.0303, 0.1408,\n", + " 0.0460, 0.0227, 0.1302, 0.0017, 0.0427, 0.0009, 0.1410, 0.1394, 0.0452,\n", + " 0.0455, 0.1385, 0.0393, 0.0391, 0.0452, 0.0424, 0.0049],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "333000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 41, 7, 42, 26, 37, 37, 31, 43, 43, 42, 34, 43, 24, 46, 37, 34, 47,\n", + " 48, 39, 44, 40, 21, 37, 37])\n", + "loss= tensor(175.9594, grad_fn=) , actor= tensor(1.0105, grad_fn=) , critic= tensor(1749.4896, grad_fn=) , return= 174932.9813783826\n", + "probs of actions: tensor([0.0298, 0.0635, 0.0010, 0.0700, 0.0227, 0.1367, 0.1363, 0.0410, 0.0432,\n", + " 0.0426, 0.0686, 0.1393, 0.0419, 0.0195, 0.0402, 0.1311, 0.1384, 0.0129,\n", + " 0.0070, 0.0457, 0.0443, 0.0184, 0.0042, 0.1257, 0.1246],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "334000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 35, 31, 44, 39, 42, 16, 42, 41, 34, 33, 27, 33, 37, 29, 29, 41, 39,\n", + " 39, 14, 42, 22, 40, 49, 26])\n", + "loss= tensor(163.4059, grad_fn=) , actor= tensor(-17.8836, grad_fn=) , critic= tensor(1812.8948, grad_fn=) , return= 174146.31236640207\n", + "probs of actions: tensor([0.0560, 0.0299, 0.0411, 0.0416, 0.0475, 0.0717, 0.0066, 0.0720, 0.0634,\n", + " 0.1397, 0.0119, 0.0123, 0.0120, 0.1279, 0.0627, 0.0630, 0.0604, 0.0464,\n", + " 0.0464, 0.0024, 0.0691, 0.0078, 0.0189, 0.0047, 0.0245],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "335000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 43, 39, 34, 39, 42, 29, 22, 40, 46, 37, 43, 42, 45, 49, 20, 39, 42,\n", + " 37, 43, 31, 41, 24, 44, 37])\n", + "loss= tensor(188.4029, grad_fn=) , actor= tensor(4.4173, grad_fn=) , critic= tensor(1839.8561, grad_fn=) , return= 175798.06302744363\n", + "probs of actions: tensor([0.1266, 0.0451, 0.0470, 0.1417, 0.0467, 0.0723, 0.0579, 0.0068, 0.0166,\n", + " 0.0405, 0.1257, 0.0414, 0.0711, 0.0152, 0.0043, 0.0064, 0.0458, 0.0699,\n", + " 0.1207, 0.0395, 0.0441, 0.0600, 0.0198, 0.0439, 0.1167],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "336000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 43, 29, 41, 28, 37, 34, 37, 37, 24, 39, 45, 30, 46, 46, 39, 44,\n", + " 32, 39, 25, 44, 33, 34, 41])\n", + "loss= tensor(175.7502, grad_fn=) , actor= tensor(-6.0004, grad_fn=) , critic= tensor(1817.5057, grad_fn=) , return= 175371.27895422748\n", + "probs of actions: tensor([0.1317, 0.0535, 0.0460, 0.0547, 0.0645, 0.0205, 0.1308, 0.1384, 0.1299,\n", + " 0.1294, 0.0195, 0.0468, 0.0152, 0.0148, 0.0395, 0.0393, 0.0465, 0.0446,\n", + " 0.0315, 0.0463, 0.0080, 0.0446, 0.0130, 0.1350, 0.0574],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "337000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 47, 46, 46, 44, 46, 28, 38, 31, 34, 46, 30, 41, 34, 47, 35, 29, 46,\n", + " 20, 39, 41, 35, 41, 37, 41])\n", + "loss= tensor(197.9831, grad_fn=) , actor= tensor(11.4661, grad_fn=) , critic= tensor(1865.1702, grad_fn=) , return= 175084.81537527387\n", + "probs of actions: tensor([0.0029, 0.0127, 0.0441, 0.0437, 0.0432, 0.0430, 0.0211, 0.0259, 0.0430,\n", + " 0.1398, 0.0413, 0.0147, 0.0598, 0.1390, 0.0126, 0.0318, 0.0605, 0.0398,\n", + " 0.0065, 0.0467, 0.0571, 0.0320, 0.0567, 0.1195, 0.0562],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "338000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 34, 24, 37, 34, 38, 42, 41, 42, 40, 36, 13, 37, 46, 29, 37, 38, 34,\n", + " 29, 32, 37, 34, 45, 43, 21])\n", + "loss= tensor(170.6880, grad_fn=) , actor= tensor(-5.9187, grad_fn=) , critic= tensor(1766.0665, grad_fn=) , return= 175620.19240865967\n", + "probs of actions: tensor([0.0298, 0.1349, 0.0188, 0.1301, 0.1387, 0.0249, 0.0746, 0.0633, 0.0743,\n", + " 0.0162, 0.0095, 0.0020, 0.1270, 0.0401, 0.0603, 0.1251, 0.0257, 0.1392,\n", + " 0.0614, 0.0326, 0.1214, 0.1374, 0.0148, 0.0399, 0.0041],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "339000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 31, 34, 42, 37, 31, 24, 44, 10, 37, 46, 19, 33, 47, 39, 34, 46,\n", + " 37, 37, 40, 31, 28, 37, 46])\n", + "loss= tensor(176.2517, grad_fn=) , actor= tensor(-3.1681, grad_fn=) , critic= tensor(1794.1984, grad_fn=) , return= 173576.6811729186\n", + "probs of actions: tensor([0.1328, 0.1400, 0.0415, 0.1432, 0.0737, 0.1342, 0.0423, 0.0182, 0.0412,\n", + " 0.0020, 0.1324, 0.0398, 0.0047, 0.0123, 0.0118, 0.0461, 0.1448, 0.0387,\n", + " 0.1266, 0.1262, 0.0178, 0.0443, 0.0210, 0.1232, 0.0377],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "340000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 24, 30, 39, 41, 32, 46, 37, 32, 37, 24, 46, 37, 8, 43, 37, 33,\n", + " 44, 32, 26, 34, 36, 30, 42])\n", + "loss= tensor(174.9451, grad_fn=) , actor= tensor(-6.6945, grad_fn=) , critic= tensor(1816.3958, grad_fn=) , return= 173693.07070506702\n", + "probs of actions: tensor([0.0397, 0.0401, 0.0184, 0.0153, 0.0472, 0.0614, 0.0337, 0.0419, 0.1322,\n", + " 0.0338, 0.1315, 0.0179, 0.0405, 0.1292, 0.0011, 0.0409, 0.1268, 0.0125,\n", + " 0.0416, 0.0342, 0.0226, 0.1449, 0.0106, 0.0154, 0.0705],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "341000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 39, 34, 28, 42, 42, 28, 37, 37, 41, 37, 34, 29, 39, 37, 29, 41, 41,\n", + " 44, 34, 27, 42, 22, 41, 42])\n", + "loss= tensor(177.3820, grad_fn=) , actor= tensor(-10.0825, grad_fn=) , critic= tensor(1874.6456, grad_fn=) , return= 175176.52747521186\n", + "probs of actions: tensor([0.1413, 0.0472, 0.1442, 0.0203, 0.0759, 0.0755, 0.0203, 0.1315, 0.1309,\n", + " 0.0605, 0.1298, 0.1490, 0.0590, 0.0460, 0.1273, 0.0599, 0.0581, 0.0577,\n", + " 0.0412, 0.1460, 0.0124, 0.0723, 0.0079, 0.0562, 0.0712],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "342000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 18, 31, 34, 44, 29, 41, 41, 33, 37, 45, 16, 37, 32, 43, 27, 30, 34,\n", + " 42, 41, 35, 35, 41, 29, 32])\n", + "loss= tensor(180.9940, grad_fn=) , actor= tensor(7.0394, grad_fn=) , critic= tensor(1739.5460, grad_fn=) , return= 174747.32170229996\n", + "probs of actions: tensor([0.0060, 0.0037, 0.0404, 0.1506, 0.0386, 0.0577, 0.0607, 0.0602, 0.0116,\n", + " 0.1267, 0.0142, 0.0063, 0.1250, 0.0344, 0.0418, 0.0120, 0.0145, 0.1520,\n", + " 0.0710, 0.0561, 0.0322, 0.0322, 0.0555, 0.0635, 0.0346],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "343000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 32, 36, 46, 34, 32, 29, 29, 33, 29, 41, 48, 37, 46, 41, 35, 31,\n", + " 26, 37, 35, 38, 30, 40, 30])\n", + "loss= tensor(172.1673, grad_fn=) , actor= tensor(-9.1899, grad_fn=) , critic= tensor(1813.5724, grad_fn=) , return= 175983.68042369033\n", + "probs of actions: tensor([0.1427, 0.0631, 0.0335, 0.0097, 0.0435, 0.1487, 0.0336, 0.0625, 0.0631,\n", + " 0.0117, 0.0640, 0.0589, 0.0061, 0.1259, 0.0404, 0.0575, 0.0325, 0.0436,\n", + " 0.0216, 0.1217, 0.0328, 0.0276, 0.0145, 0.0172, 0.0146],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "344000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 37, 35, 34, 41, 37, 39, 23, 29, 37, 34, 34, 37, 40, 39, 41, 37, 37,\n", + " 10, 37, 46, 46, 31, 42, 34])\n", + "loss= tensor(179.8869, grad_fn=) , actor= tensor(-1.7622, grad_fn=) , critic= tensor(1816.4913, grad_fn=) , return= 175054.9723043699\n", + "probs of actions: tensor([0.0374, 0.1342, 0.0298, 0.1469, 0.0604, 0.1353, 0.0446, 0.0057, 0.0638,\n", + " 0.1338, 0.1502, 0.1502, 0.1319, 0.0162, 0.0440, 0.0562, 0.1291, 0.1284,\n", + " 0.0022, 0.1267, 0.0397, 0.0396, 0.0434, 0.0701, 0.1446],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "345000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 34, 37, 44, 38, 31, 26, 28, 37, 44, 37, 35, 39, 37, 37, 25, 32,\n", + " 39, 42, 42, 37, 31, 22, 37])\n", + "loss= tensor(178.6588, grad_fn=) , actor= tensor(-3.8196, grad_fn=) , critic= tensor(1824.7837, grad_fn=) , return= 176012.97804212294\n", + "probs of actions: tensor([0.1344, 0.1348, 0.1460, 0.1356, 0.0385, 0.0269, 0.0410, 0.0208, 0.0193,\n", + " 0.1339, 0.0396, 0.1324, 0.0298, 0.0442, 0.1305, 0.1298, 0.0074, 0.0339,\n", + " 0.0440, 0.0714, 0.0711, 0.1253, 0.0430, 0.0083, 0.1231],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "346000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 42, 32, 42, 24, 32, 30, 37, 41, 41, 36, 24, 29, 37, 8, 29, 31, 29,\n", + " 34, 34, 33, 39, 37, 39, 34])\n", + "loss= tensor(186.2122, grad_fn=) , actor= tensor(7.1464, grad_fn=) , critic= tensor(1790.6580, grad_fn=) , return= 173513.167705001\n", + "probs of actions: tensor([0.0202, 0.0761, 0.0336, 0.0762, 0.0182, 0.0337, 0.0137, 0.1298, 0.0561,\n", + " 0.0557, 0.0098, 0.0179, 0.0669, 0.1263, 0.0011, 0.0680, 0.0427, 0.0684,\n", + " 0.1510, 0.1503, 0.0129, 0.0453, 0.1200, 0.0452, 0.1478],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "347000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 37, 39, 44, 24, 39, 29, 37, 44, 39, 40, 43, 26, 29, 41, 37, 35, 22,\n", + " 41, 43, 20, 32, 42, 42, 41])\n", + "loss= tensor(184.8360, grad_fn=) , actor= tensor(-2.6872, grad_fn=) , critic= tensor(1875.2318, grad_fn=) , return= 174461.0718578875\n", + "probs of actions: tensor([0.0411, 0.1268, 0.0501, 0.0385, 0.0170, 0.0498, 0.0598, 0.1266, 0.0395,\n", + " 0.0493, 0.0169, 0.0427, 0.0217, 0.0628, 0.0542, 0.1216, 0.0299, 0.0078,\n", + " 0.0532, 0.0407, 0.0066, 0.0361, 0.0732, 0.0728, 0.0518],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "348000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 31, 29, 39, 46, 34, 37, 37, 37, 34, 42, 37, 42, 42, 39, 34, 35, 42,\n", + " 42, 37, 31, 42, 43, 27, 29])\n", + "loss= tensor(174.6302, grad_fn=) , actor= tensor(-4.0242, grad_fn=) , critic= tensor(1786.5441, grad_fn=) , return= 177074.67925665132\n", + "probs of actions: tensor([0.0200, 0.0417, 0.0577, 0.0504, 0.0422, 0.1570, 0.1252, 0.1248, 0.1243,\n", + " 0.1588, 0.0756, 0.1226, 0.0750, 0.0746, 0.0494, 0.1571, 0.0293, 0.0736,\n", + " 0.0732, 0.1174, 0.0443, 0.0726, 0.0393, 0.0127, 0.0654],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "349000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 39, 42, 39, 26, 42, 34, 30, 43, 29, 43, 37, 31, 17, 43, 43, 35, 45,\n", + " 37, 26, 34, 37, 46, 39, 36])\n", + "loss= tensor(176.8535, grad_fn=) , actor= tensor(-4.3225, grad_fn=) , critic= tensor(1811.7600, grad_fn=) , return= 175183.97325705554\n", + "probs of actions: tensor([0.1285, 0.0496, 0.0800, 0.0494, 0.0211, 0.0804, 0.1626, 0.0127, 0.0426,\n", + " 0.0602, 0.0420, 0.1264, 0.0427, 0.0025, 0.0409, 0.0404, 0.0279, 0.0140,\n", + " 0.1217, 0.0225, 0.1595, 0.1196, 0.0380, 0.0481, 0.0107],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "350000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 16, 39, 32, 34, 38, 29, 34, 34, 46, 46, 28, 45, 44, 39, 34, 37, 31,\n", + " 42, 40, 34, 38, 45, 39, 31])\n", + "loss= tensor(173.6835, grad_fn=) , actor= tensor(-1.1262, grad_fn=) , critic= tensor(1748.0966, grad_fn=) , return= 175680.63255269374\n", + "probs of actions: tensor([0.0547, 0.0064, 0.0488, 0.0341, 0.1643, 0.0274, 0.0579, 0.1663, 0.1665,\n", + " 0.0391, 0.0389, 0.0199, 0.0133, 0.0373, 0.0477, 0.1650, 0.1280, 0.0434,\n", + " 0.0780, 0.0172, 0.1619, 0.0286, 0.0141, 0.0473, 0.0440],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "351000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 44, 34, 35, 11, 34, 37, 42, 43, 34, 42, 27, 34, 34, 31, 26, 37,\n", + " 28, 34, 26, 40, 37, 37, 37])\n", + "loss= tensor(186.9379, grad_fn=) , actor= tensor(3.1649, grad_fn=) , critic= tensor(1837.7303, grad_fn=) , return= 174309.8273147738\n", + "probs of actions: tensor([0.1568, 0.0794, 0.0347, 0.1613, 0.0263, 0.0016, 0.1650, 0.1379, 0.0790,\n", + " 0.0399, 0.1651, 0.0785, 0.0117, 0.1651, 0.1643, 0.0450, 0.0211, 0.1312,\n", + " 0.0210, 0.1617, 0.0216, 0.0177, 0.1273, 0.1268, 0.1262],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "352000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 28, 34, 35, 22, 37, 37, 41, 35, 34, 41, 39, 28, 34, 34, 42, 42, 37,\n", + " 37, 30, 34, 34, 37, 40, 34])\n", + "loss= tensor(188.1091, grad_fn=) , actor= tensor(7.4279, grad_fn=) , critic= tensor(1806.8124, grad_fn=) , return= 175644.3165188418\n", + "probs of actions: tensor([0.1419, 0.0206, 0.1585, 0.0254, 0.0072, 0.1432, 0.1427, 0.0558, 0.0258,\n", + " 0.1631, 0.0548, 0.0495, 0.0207, 0.1626, 0.1619, 0.0762, 0.0757, 0.1352,\n", + " 0.1344, 0.0134, 0.1588, 0.1579, 0.1311, 0.0179, 0.1561],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "353000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 34, 27, 42, 27, 29, 29, 34, 34, 16, 35, 37, 42, 34, 46, 34, 42, 24,\n", + " 45, 29, 37, 29, 34, 34, 37])\n", + "loss= tensor(191.3896, grad_fn=) , actor= tensor(12.4127, grad_fn=) , critic= tensor(1789.7692, grad_fn=) , return= 174418.18195391816\n", + "probs of actions: tensor([0.0125, 0.1653, 0.0117, 0.0770, 0.0117, 0.0591, 0.0596, 0.1728, 0.1730,\n", + " 0.0058, 0.0253, 0.1366, 0.0752, 0.1716, 0.0383, 0.1706, 0.0743, 0.0152,\n", + " 0.0132, 0.0641, 0.1300, 0.0645, 0.1669, 0.1659, 0.1270],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "354000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 48, 46, 45, 41, 37, 42, 37, 41, 37, 37, 34, 37, 39, 29, 16, 37, 36,\n", + " 34, 39, 32, 44, 46, 29, 43])\n", + "loss= tensor(187.0092, grad_fn=) , actor= tensor(-4.3888, grad_fn=) , critic= tensor(1913.9799, grad_fn=) , return= 175598.75697703636\n", + "probs of actions: tensor([0.1428, 0.0055, 0.0416, 0.0127, 0.0520, 0.1439, 0.0760, 0.1431, 0.0504,\n", + " 0.1420, 0.1414, 0.1717, 0.1399, 0.0457, 0.0618, 0.0059, 0.1365, 0.0092,\n", + " 0.1682, 0.0456, 0.0335, 0.0349, 0.0368, 0.0637, 0.0384],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "355000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 43, 31, 37, 35, 34, 24, 31, 34, 42, 37, 37, 39, 46, 44, 38, 47,\n", + " 40, 34, 27, 34, 26, 15, 42])\n", + "loss= tensor(168.6577, grad_fn=) , actor= tensor(-18.3641, grad_fn=) , critic= tensor(1870.2186, grad_fn=) , return= 175820.93165641508\n", + "probs of actions: tensor([0.1453, 0.1456, 0.0453, 0.0446, 0.1465, 0.0259, 0.1723, 0.0142, 0.0453,\n", + " 0.1734, 0.0746, 0.1428, 0.1422, 0.0459, 0.0387, 0.0340, 0.0278, 0.0100,\n", + " 0.0170, 0.1690, 0.0120, 0.1679, 0.0213, 0.0022, 0.0714],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "356000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 28, 44, 37, 22, 44, 46, 34, 29, 39, 39, 31, 34, 34, 44, 34, 34, 39,\n", + " 25, 46, 38, 31, 30, 41, 37])\n", + "loss= tensor(181.0652, grad_fn=) , actor= tensor(-2.7086, grad_fn=) , critic= tensor(1837.7380, grad_fn=) , return= 175293.01351714623\n", + "probs of actions: tensor([0.1418, 0.0228, 0.0317, 0.1427, 0.0073, 0.0321, 0.0406, 0.1751, 0.0587,\n", + " 0.0459, 0.0459, 0.0470, 0.1758, 0.1752, 0.0332, 0.1737, 0.1738, 0.0457,\n", + " 0.0078, 0.0377, 0.0273, 0.0482, 0.0135, 0.0457, 0.1291],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "357000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 28, 37, 42, 38, 37, 34, 40, 34, 37, 37, 37, 34, 36, 44, 44, 34, 36,\n", + " 34, 44, 37, 46, 41, 37, 34])\n", + "loss= tensor(185.5877, grad_fn=) , actor= tensor(5.2064, grad_fn=) , critic= tensor(1803.8130, grad_fn=) , return= 176768.06821034002\n", + "probs of actions: tensor([0.0757, 0.0242, 0.1463, 0.0749, 0.0263, 0.1462, 0.1737, 0.0151, 0.1744,\n", + " 0.1442, 0.1434, 0.1427, 0.1742, 0.0090, 0.0332, 0.0333, 0.1721, 0.0092,\n", + " 0.1711, 0.0336, 0.1350, 0.0353, 0.0456, 0.1330, 0.1673],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "358000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 29, 37, 34, 34, 41, 41, 28, 42, 22, 42, 25, 46, 44, 34, 19, 34,\n", + " 37, 30, 34, 26, 40, 37, 28])\n", + "loss= tensor(172.6791, grad_fn=) , actor= tensor(-8.4282, grad_fn=) , critic= tensor(1811.0726, grad_fn=) , return= 175154.04046814982\n", + "probs of actions: tensor([0.1704, 0.0719, 0.0532, 0.1475, 0.1771, 0.1782, 0.0498, 0.0494, 0.0230,\n", + " 0.0714, 0.0076, 0.0711, 0.0076, 0.0355, 0.0334, 0.1776, 0.0040, 0.1775,\n", + " 0.1374, 0.0141, 0.1748, 0.0200, 0.0170, 0.1334, 0.0236],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "359000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 34, 34, 31, 32, 41, 37, 29, 37, 34, 34, 37, 28, 43, 32, 34, 37,\n", + " 26, 43, 28, 19, 28, 26, 34])\n", + "loss= tensor(169.2421, grad_fn=) , actor= tensor(-17.8035, grad_fn=) , critic= tensor(1870.4552, grad_fn=) , return= 175201.9555792558\n", + "probs of actions: tensor([0.0259, 0.1646, 0.1668, 0.1683, 0.0472, 0.0367, 0.0502, 0.1460, 0.0580,\n", + " 0.1450, 0.1718, 0.1718, 0.1425, 0.0233, 0.0438, 0.0373, 0.1699, 0.1382,\n", + " 0.0197, 0.0426, 0.0235, 0.0043, 0.0237, 0.0203, 0.1644],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "360000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 22, 43, 32, 33, 42, 34, 34, 35, 42, 37, 35, 42, 41, 34, 34, 49, 42,\n", + " 31, 37, 32, 36, 32, 37, 35])\n", + "loss= tensor(182.9876, grad_fn=) , actor= tensor(0.0292, grad_fn=) , critic= tensor(1829.5837, grad_fn=) , return= 176194.5446401812\n", + "probs of actions: tensor([0.0748, 0.0078, 0.0491, 0.0384, 0.0118, 0.0740, 0.1604, 0.1612, 0.0251,\n", + " 0.0734, 0.1388, 0.0254, 0.0727, 0.0514, 0.1602, 0.1602, 0.0036, 0.0711,\n", + " 0.0496, 0.1318, 0.0392, 0.0095, 0.0392, 0.1284, 0.0262],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "361000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 41, 34, 39, 38, 33, 37, 37, 39, 16, 32, 29, 34, 37, 47, 43, 37, 35,\n", + " 37, 41, 34, 34, 44, 17, 45])\n", + "loss= tensor(173.1694, grad_fn=) , actor= tensor(-9.3199, grad_fn=) , critic= tensor(1824.8927, grad_fn=) , return= 174726.4247567068\n", + "probs of actions: tensor([0.0055, 0.0564, 0.1567, 0.0458, 0.0269, 0.0115, 0.1413, 0.1408, 0.0453,\n", + " 0.0056, 0.0383, 0.0607, 0.1614, 0.1364, 0.0098, 0.0445, 0.1342, 0.0261,\n", + " 0.1326, 0.0503, 0.1570, 0.1568, 0.0338, 0.0026, 0.0151],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "362000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 37, 38, 34, 31, 35, 37, 37, 34, 37, 29, 16, 37, 32, 45, 28, 37, 32,\n", + " 38, 42, 41, 42, 37, 34, 48])\n", + "loss= tensor(175.0807, grad_fn=) , actor= tensor(-8.8108, grad_fn=) , critic= tensor(1838.9152, grad_fn=) , return= 174356.45492271104\n", + "probs of actions: tensor([0.0140, 0.1459, 0.0268, 0.1567, 0.0472, 0.0249, 0.1465, 0.1460, 0.1598,\n", + " 0.1448, 0.0587, 0.0059, 0.1424, 0.0392, 0.0144, 0.0224, 0.1391, 0.0393,\n", + " 0.0279, 0.0702, 0.0511, 0.0697, 0.1340, 0.1541, 0.0059],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "363000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 43, 44, 48, 12, 43, 37, 31, 37, 44, 34, 29, 29, 34, 41, 38, 49, 30,\n", + " 34, 43, 37, 37, 34, 35, 24])\n", + "loss= tensor(186.7073, grad_fn=) , actor= tensor(11.2712, grad_fn=) , critic= tensor(1754.3613, grad_fn=) , return= 176080.15061314614\n", + "probs of actions: tensor([0.0152, 0.0515, 0.0311, 0.0050, 0.0017, 0.0501, 0.1461, 0.0488, 0.1453,\n", + " 0.0321, 0.1544, 0.0585, 0.0589, 0.1542, 0.0510, 0.0282, 0.0037, 0.0146,\n", + " 0.1521, 0.0451, 0.1353, 0.1347, 0.1494, 0.0272, 0.0155],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "364000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 41, 34, 37, 42, 31, 27, 29, 42, 31, 24, 41, 29, 31, 21, 31, 43, 34,\n", + " 42, 39, 34, 34, 11, 34, 37])\n", + "loss= tensor(184.9020, grad_fn=) , actor= tensor(-0.3112, grad_fn=) , critic= tensor(1852.1318, grad_fn=) , return= 174345.02956388358\n", + "probs of actions: tensor([0.0779, 0.0541, 0.1619, 0.1438, 0.0771, 0.0505, 0.0113, 0.0588, 0.0767,\n", + " 0.0513, 0.0143, 0.0503, 0.0609, 0.0517, 0.0029, 0.0519, 0.0451, 0.1631,\n", + " 0.0742, 0.0433, 0.1618, 0.1614, 0.0018, 0.1606, 0.1289],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "365000 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 39, 46, 18, 34, 34, 35, 37, 32, 40, 22, 30, 46, 43, 28, 42, 38, 16,\n", + " 34, 38, 20, 26, 42, 35, 45])\n", + "loss= tensor(176.5681, grad_fn=) , actor= tensor(-11.1352, grad_fn=) , critic= tensor(1877.0331, grad_fn=) , return= 172882.7654178057\n", + "probs of actions: tensor([0.0114, 0.0445, 0.0385, 0.0031, 0.1601, 0.1605, 0.0268, 0.1432, 0.0371,\n", + " 0.0147, 0.0078, 0.0137, 0.0355, 0.0463, 0.0223, 0.0724, 0.0293, 0.0059,\n", + " 0.1593, 0.0297, 0.0066, 0.0196, 0.0705, 0.0282, 0.0153],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "366000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 47, 42, 40, 41, 42, 26, 43, 30, 42, 22, 43, 37, 2, 44, 34, 29, 35,\n", + " 37, 24, 46, 34, 32, 35, 34])\n", + "loss= tensor(191.6346, grad_fn=) , actor= tensor(10.1071, grad_fn=) , critic= tensor(1815.2754, grad_fn=) , return= 174187.41014244812\n", + "probs of actions: tensor([0.0548, 0.0095, 0.0743, 0.0142, 0.0533, 0.0744, 0.0179, 0.0488, 0.0134,\n", + " 0.0740, 0.0080, 0.0472, 0.1455, 0.0003, 0.0313, 0.1571, 0.0648, 0.0277,\n", + " 0.1402, 0.0156, 0.0330, 0.1541, 0.0360, 0.0281, 0.1530],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "367000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 29, 23, 37, 31, 39, 39, 46, 46, 30, 47, 36, 31, 41, 24, 37, 29, 34,\n", + " 46, 37, 30, 37, 41, 42, 41])\n", + "loss= tensor(192.9023, grad_fn=) , actor= tensor(10.3594, grad_fn=) , critic= tensor(1825.4290, grad_fn=) , return= 174668.57706824408\n", + "probs of actions: tensor([0.0229, 0.0568, 0.0057, 0.1480, 0.0502, 0.0458, 0.0457, 0.0366, 0.0363,\n", + " 0.0134, 0.0095, 0.0090, 0.0516, 0.0502, 0.0151, 0.1408, 0.0637, 0.1568,\n", + " 0.0345, 0.1369, 0.0138, 0.1356, 0.0482, 0.0713, 0.0479],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "368000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 34, 37, 45, 37, 39, 28, 39, 37, 29, 34, 41, 32, 37, 39, 44, 35, 44,\n", + " 32, 31, 31, 41, 19, 37, 45])\n", + "loss= tensor(178.2415, grad_fn=) , actor= tensor(-14.0185, grad_fn=) , critic= tensor(1922.5996, grad_fn=) , return= 175240.4086688716\n", + "probs of actions: tensor([0.0283, 0.1539, 0.1519, 0.0135, 0.1520, 0.0447, 0.0215, 0.0445, 0.1504,\n", + " 0.0613, 0.1612, 0.0531, 0.0340, 0.1466, 0.0442, 0.0301, 0.0279, 0.0303,\n", + " 0.0342, 0.0530, 0.0531, 0.0506, 0.0042, 0.1378, 0.0148],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "369000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 23, 37, 43, 31, 26, 34, 23, 39, 31, 23, 37, 37, 34, 44, 31, 44, 37,\n", + " 46, 41, 34, 32, 46, 28, 29])\n", + "loss= tensor(177.1779, grad_fn=) , actor= tensor(4.7578, grad_fn=) , critic= tensor(1724.2012, grad_fn=) , return= 175490.8715909126\n", + "probs of actions: tensor([0.0410, 0.0057, 0.1549, 0.0533, 0.0511, 0.0164, 0.1612, 0.0054, 0.0430,\n", + " 0.0521, 0.0055, 0.1511, 0.1499, 0.1611, 0.0302, 0.0530, 0.0303, 0.1455,\n", + " 0.0362, 0.0513, 0.1578, 0.0334, 0.0357, 0.0223, 0.0636],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "370000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 31, 41, 37, 39, 41, 42, 46, 43, 43, 34, 37, 42, 29, 19, 31, 45, 34,\n", + " 47, 37, 42, 37, 37, 37, 31])\n", + "loss= tensor(190.1701, grad_fn=) , actor= tensor(10.3528, grad_fn=) , critic= tensor(1798.1729, grad_fn=) , return= 176395.6242476239\n", + "probs of actions: tensor([0.0148, 0.0508, 0.0555, 0.1584, 0.0417, 0.0542, 0.0706, 0.0385, 0.0509,\n", + " 0.0505, 0.1658, 0.1547, 0.0697, 0.0637, 0.0037, 0.0533, 0.0142, 0.1628,\n", + " 0.0100, 0.1468, 0.0680, 0.1452, 0.1445, 0.1435, 0.0543],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "371000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 43, 39, 29, 34, 39, 39, 29, 34, 29, 34, 16, 24, 39, 27, 34, 41, 43,\n", + " 28, 29, 39, 41, 32, 34, 20])\n", + "loss= tensor(167.4268, grad_fn=) , actor= tensor(-7.8093, grad_fn=) , critic= tensor(1752.3615, grad_fn=) , return= 175423.84746770278\n", + "probs of actions: tensor([0.0558, 0.0545, 0.0414, 0.0606, 0.1587, 0.0410, 0.0409, 0.0630, 0.1609,\n", + " 0.0641, 0.1610, 0.0058, 0.0143, 0.0407, 0.0131, 0.1596, 0.0494, 0.0482,\n", + " 0.0218, 0.0672, 0.0407, 0.0484, 0.0331, 0.1551, 0.0072],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "372000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 41, 29, 35, 35, 11, 39, 38, 32, 24, 46, 37, 34, 47, 34, 34, 41,\n", + " 33, 37, 43, 34, 30, 37, 41])\n", + "loss= tensor(186.3287, grad_fn=) , actor= tensor(7.3995, grad_fn=) , critic= tensor(1789.2917, grad_fn=) , return= 174573.1038688262\n", + "probs of actions: tensor([0.1548, 0.1551, 0.0534, 0.0609, 0.0251, 0.0253, 0.0014, 0.0407, 0.0265,\n", + " 0.0327, 0.0145, 0.0358, 0.1505, 0.1644, 0.0098, 0.1630, 0.1634, 0.0486,\n", + " 0.0120, 0.1444, 0.0485, 0.1599, 0.0135, 0.1408, 0.0472],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "373000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 37, 24, 34, 37, 34, 29, 34, 46, 38, 32, 26, 29, 42, 37, 34, 25, 34,\n", + " 34, 37, 37, 34, 37, 29, 32])\n", + "loss= tensor(185.2509, grad_fn=) , actor= tensor(5.2013, grad_fn=) , critic= tensor(1800.4958, grad_fn=) , return= 175458.81705886897\n", + "probs of actions: tensor([0.0692, 0.1538, 0.0151, 0.1606, 0.1549, 0.1620, 0.0637, 0.1632, 0.0363,\n", + " 0.0263, 0.0323, 0.0179, 0.0666, 0.0670, 0.1478, 0.1617, 0.0075, 0.1611,\n", + " 0.1600, 0.1431, 0.1422, 0.1582, 0.1406, 0.0691, 0.0330],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "374000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 48, 34, 37, 39, 31, 37, 46, 37, 16, 45, 37, 46, 37, 44, 42, 31, 49,\n", + " 34, 34, 41, 43, 26, 34, 34])\n", + "loss= tensor(189.6224, grad_fn=) , actor= tensor(10.2799, grad_fn=) , critic= tensor(1793.4248, grad_fn=) , return= 176158.9119843412\n", + "probs of actions: tensor([0.0219, 0.0047, 0.1604, 0.1562, 0.0418, 0.0550, 0.1557, 0.0367, 0.1542,\n", + " 0.0058, 0.0141, 0.1516, 0.0355, 0.1502, 0.0296, 0.0668, 0.0570, 0.0035,\n", + " 0.1619, 0.1622, 0.0498, 0.0475, 0.0191, 0.1600, 0.1589],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "375000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 29, 42, 43, 34, 29, 42, 29, 44, 19, 23, 37, 40, 34, 42, 41, 37, 39,\n", + " 37, 31, 44, 22, 37, 34, 38])\n", + "loss= tensor(184.4756, grad_fn=) , actor= tensor(2.4380, grad_fn=) , critic= tensor(1820.3767, grad_fn=) , return= 175044.56535533327\n", + "probs of actions: tensor([0.0144, 0.0611, 0.0683, 0.0539, 0.1643, 0.0636, 0.0681, 0.0647, 0.0280,\n", + " 0.0036, 0.0052, 0.1546, 0.0147, 0.1656, 0.0666, 0.0510, 0.1501, 0.0411,\n", + " 0.1481, 0.0569, 0.0293, 0.0080, 0.1446, 0.1600, 0.0273],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "376000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 42, 35, 34, 37, 40, 41, 43, 24, 37, 42, 28, 41, 31, 43, 34, 38,\n", + " 34, 41, 42, 39, 29, 37, 36])\n", + "loss= tensor(179.2249, grad_fn=) , actor= tensor(-2.8947, grad_fn=) , critic= tensor(1821.1956, grad_fn=) , return= 176240.92425241947\n", + "probs of actions: tensor([0.1590, 0.1605, 0.0671, 0.0236, 0.1647, 0.1558, 0.0143, 0.0539, 0.0504,\n", + " 0.0137, 0.1530, 0.0660, 0.0210, 0.0520, 0.0585, 0.0480, 0.1641, 0.0264,\n", + " 0.1632, 0.0505, 0.0643, 0.0403, 0.0729, 0.1411, 0.0095],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "377000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 31, 43, 34, 41, 42, 23, 42, 29, 32, 39, 34, 31, 30, 31, 42, 37, 31,\n", + " 32, 30, 29, 29, 46, 34, 22])\n", + "loss= tensor(175.3822, grad_fn=) , actor= tensor(-5.0706, grad_fn=) , critic= tensor(1804.5280, grad_fn=) , return= 175719.15978934942\n", + "probs of actions: tensor([0.1663, 0.0560, 0.0525, 0.1708, 0.0508, 0.0641, 0.0050, 0.0642, 0.0690,\n", + " 0.0337, 0.0411, 0.1739, 0.0584, 0.0133, 0.0586, 0.0626, 0.1490, 0.0590,\n", + " 0.0342, 0.0137, 0.0731, 0.0733, 0.0327, 0.1665, 0.0082],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "378000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 32, 29, 41, 37, 25, 46, 32, 34, 34, 46, 37, 42, 42, 45, 41, 33,\n", + " 35, 24, 35, 39, 38, 34, 34])\n", + "loss= tensor(181.4458, grad_fn=) , actor= tensor(0.7291, grad_fn=) , critic= tensor(1807.1672, grad_fn=) , return= 175991.13207668476\n", + "probs of actions: tensor([0.0665, 0.1586, 0.0341, 0.0683, 0.0499, 0.1587, 0.0063, 0.0342, 0.0344,\n", + " 0.1788, 0.1786, 0.0332, 0.1534, 0.0622, 0.0619, 0.0143, 0.0463, 0.0119,\n", + " 0.0242, 0.0138, 0.0243, 0.0417, 0.0247, 0.1707, 0.1702],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "379000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 37, 31, 34, 32, 41, 34, 29, 36, 31, 43, 34, 37, 37, 29, 43, 34, 28,\n", + " 38, 34, 34, 20, 37, 44, 27])\n", + "loss= tensor(172.5482, grad_fn=) , actor= tensor(-11.2090, grad_fn=) , critic= tensor(1837.5721, grad_fn=) , return= 175568.26870964587\n", + "probs of actions: tensor([0.0499, 0.1537, 0.0579, 0.1797, 0.0336, 0.0477, 0.1816, 0.0711, 0.0079,\n", + " 0.0596, 0.0472, 0.1817, 0.1494, 0.1485, 0.0742, 0.0458, 0.1790, 0.0228,\n", + " 0.0243, 0.1770, 0.1765, 0.0063, 0.1402, 0.0287, 0.0128],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "380000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 23, 43, 43, 47, 34, 31, 43, 37, 26, 32, 46, 34, 37, 29, 26, 34, 31,\n", + " 34, 46, 37, 27, 29, 43, 34])\n", + "loss= tensor(192.6334, grad_fn=) , actor= tensor(7.4898, grad_fn=) , critic= tensor(1851.4359, grad_fn=) , return= 175132.64712636528\n", + "probs of actions: tensor([0.1583, 0.0049, 0.0466, 0.0459, 0.0087, 0.1839, 0.0591, 0.0444, 0.1571,\n", + " 0.0165, 0.0343, 0.0329, 0.1838, 0.1530, 0.0753, 0.0171, 0.1825, 0.0611,\n", + " 0.1806, 0.0319, 0.1458, 0.0121, 0.0771, 0.0405, 0.1754],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "381000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 43, 37, 29, 41, 29, 28, 34, 34, 44, 34, 38, 41, 34, 37, 40, 31, 38,\n", + " 49, 34, 34, 43, 38, 37, 37])\n", + "loss= tensor(183.2398, grad_fn=) , actor= tensor(2.2737, grad_fn=) , critic= tensor(1809.6614, grad_fn=) , return= 176048.5550454566\n", + "probs of actions: tensor([0.0621, 0.0454, 0.1644, 0.0698, 0.0470, 0.0711, 0.0212, 0.1814, 0.1813,\n", + " 0.0267, 0.1806, 0.0251, 0.0444, 0.1794, 0.1573, 0.0145, 0.0607, 0.0257,\n", + " 0.0033, 0.1749, 0.1752, 0.0397, 0.0263, 0.1484, 0.1475],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "382000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 35, 42, 33, 43, 29, 39, 34, 29, 29, 41, 34, 37, 37, 37, 37, 29, 20,\n", + " 34, 31, 44, 33, 43, 41, 31])\n", + "loss= tensor(173.5097, grad_fn=) , actor= tensor(-8.3719, grad_fn=) , critic= tensor(1818.8157, grad_fn=) , return= 175304.4791133848\n", + "probs of actions: tensor([0.1760, 0.0230, 0.0609, 0.0117, 0.0434, 0.0737, 0.0441, 0.1830, 0.0756,\n", + " 0.0763, 0.0448, 0.1824, 0.1587, 0.1577, 0.1567, 0.1557, 0.0788, 0.0057,\n", + " 0.1790, 0.0625, 0.0271, 0.0130, 0.0389, 0.0424, 0.0628],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "383000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 26, 34, 14, 34, 31, 29, 37, 37, 29, 41, 31, 29, 37, 34, 35, 44,\n", + " 29, 43, 29, 37, 37, 30, 34])\n", + "loss= tensor(174.3934, grad_fn=) , actor= tensor(0.2431, grad_fn=) , critic= tensor(1741.5033, grad_fn=) , return= 174490.58954545343\n", + "probs of actions: tensor([0.1734, 0.1750, 0.0171, 0.1785, 0.0014, 0.1805, 0.0611, 0.0780, 0.1622,\n", + " 0.1611, 0.0796, 0.0437, 0.0624, 0.0808, 0.1565, 0.1780, 0.0240, 0.0264,\n", + " 0.0821, 0.0407, 0.0825, 0.1495, 0.1483, 0.0129, 0.1718],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "384000 adversary: AdversaryModes.myopic\n", + " actions: tensor([10, 34, 34, 32, 39, 34, 34, 37, 42, 29, 44, 34, 34, 37, 44, 37, 37, 29,\n", + " 31, 23, 35, 41, 31, 37, 34])\n", + "loss= tensor(179.8109, grad_fn=) , actor= tensor(-1.8095, grad_fn=) , critic= tensor(1816.2043, grad_fn=) , return= 174777.58803749015\n", + "probs of actions: tensor([0.0013, 0.1855, 0.1866, 0.0324, 0.0415, 0.1897, 0.1904, 0.1556, 0.0600,\n", + " 0.0793, 0.0257, 0.1898, 0.1900, 0.1505, 0.0261, 0.1485, 0.1478, 0.0822,\n", + " 0.0609, 0.0049, 0.0239, 0.0428, 0.0614, 0.1412, 0.1805],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "385000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 20, 38, 38, 34, 31, 34, 34, 39, 39, 39, 6, 34, 13, 34, 43, 16, 32,\n", + " 42, 37, 29, 39, 29, 42, 35])\n", + "loss= tensor(170.4272, grad_fn=) , actor= tensor(-4.6001, grad_fn=) , critic= tensor(1750.2723, grad_fn=) , return= 172323.61207408685\n", + "probs of actions: tensor([0.0718, 0.0051, 0.0249, 0.0248, 0.1919, 0.0576, 0.1935, 0.1936, 0.0428,\n", + " 0.0428, 0.0428, 0.0002, 0.1941, 0.0013, 0.1923, 0.0413, 0.0054, 0.0334,\n", + " 0.0579, 0.1459, 0.0809, 0.0428, 0.0813, 0.0574, 0.0237],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "386000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 32, 34, 34, 34, 37, 42, 37, 28, 37, 32, 41, 37, 32, 42, 39, 47, 31,\n", + " 46, 37, 46, 49, 34, 31, 11])\n", + "loss= tensor(149.3786, grad_fn=) , actor= tensor(-20.7314, grad_fn=) , critic= tensor(1701.1000, grad_fn=) , return= 177649.67577209967\n", + "probs of actions: tensor([0.1559, 0.0326, 0.1869, 0.1883, 0.1894, 0.1562, 0.0579, 0.1549, 0.0203,\n", + " 0.1537, 0.0331, 0.0443, 0.1507, 0.0333, 0.0569, 0.0434, 0.0088, 0.0620,\n", + " 0.0300, 0.1441, 0.0299, 0.0033, 0.1818, 0.0623, 0.0018],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "387000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 43, 27, 41, 38, 31, 29, 34, 41, 34, 29, 29, 29, 42, 37, 34, 39, 31,\n", + " 36, 37, 43, 34, 37, 37, 39])\n", + "loss= tensor(186.2162, grad_fn=) , actor= tensor(5.4514, grad_fn=) , critic= tensor(1807.6482, grad_fn=) , return= 175134.85459633183\n", + "probs of actions: tensor([0.0746, 0.0485, 0.0110, 0.0465, 0.0254, 0.0561, 0.0788, 0.1935, 0.0445,\n", + " 0.1930, 0.0811, 0.0816, 0.0820, 0.0579, 0.1473, 0.1901, 0.0430, 0.0583,\n", + " 0.0081, 0.1428, 0.0424, 0.1846, 0.1404, 0.1394, 0.0431],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "388000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 36, 32, 31, 29, 44, 37, 37, 29, 19, 29, 37, 43, 34, 13, 42, 34, 26,\n", + " 47, 37, 39, 29, 34, 34, 38])\n", + "loss= tensor(182.6854, grad_fn=) , actor= tensor(4.4805, grad_fn=) , critic= tensor(1782.0485, grad_fn=) , return= 173999.87189353764\n", + "probs of actions: tensor([0.1465, 0.0080, 0.0344, 0.0547, 0.0755, 0.0253, 0.1461, 0.1457, 0.0780,\n", + " 0.0030, 0.0792, 0.1426, 0.0455, 0.1941, 0.0013, 0.0584, 0.1915, 0.0176,\n", + " 0.0089, 0.1356, 0.0440, 0.0820, 0.1875, 0.1861, 0.0283],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "389000 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 26, 37, 29, 34, 34, 30, 46, 35, 31, 44, 39, 39, 37, 44, 36, 24, 30,\n", + " 34, 32, 32, 31, 24, 30, 42])\n", + "loss= tensor(179.0659, grad_fn=) , actor= tensor(-8.4428, grad_fn=) , critic= tensor(1875.0872, grad_fn=) , return= 174517.20107258295\n", + "probs of actions: tensor([0.0052, 0.0167, 0.1452, 0.0745, 0.2000, 0.2005, 0.0123, 0.0319, 0.0235,\n", + " 0.0553, 0.0262, 0.0443, 0.0442, 0.1394, 0.0266, 0.0082, 0.0154, 0.0125,\n", + " 0.1950, 0.0339, 0.0339, 0.0570, 0.0158, 0.0129, 0.0570],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "390000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 39, 37, 39, 42, 29, 34, 38, 33, 34, 32, 32, 43, 46, 29, 29, 40,\n", + " 30, 37, 31, 31, 42, 42, 42])\n", + "loss= tensor(181.6112, grad_fn=) , actor= tensor(-6.6364, grad_fn=) , critic= tensor(1882.4758, grad_fn=) , return= 175023.41809206284\n", + "probs of actions: tensor([0.1907, 0.1461, 0.0471, 0.1465, 0.0469, 0.0591, 0.0777, 0.1989, 0.0273,\n", + " 0.0109, 0.1985, 0.0324, 0.0325, 0.0450, 0.0316, 0.0816, 0.0821, 0.0140,\n", + " 0.0127, 0.1355, 0.0560, 0.0560, 0.0569, 0.0566, 0.0566],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "391000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 34, 31, 43, 29, 39, 34, 35, 41, 31, 34, 26, 42, 34, 34, 37, 31, 37,\n", + " 39, 39, 38, 47, 36, 34, 32])\n", + "loss= tensor(170.4967, grad_fn=) , actor= tensor(-7.8587, grad_fn=) , critic= tensor(1783.5541, grad_fn=) , return= 176178.22359350373\n", + "probs of actions: tensor([0.0516, 0.1852, 0.0532, 0.0497, 0.0759, 0.0459, 0.1914, 0.0234, 0.0456,\n", + " 0.0549, 0.1920, 0.0171, 0.0590, 0.1896, 0.1897, 0.1413, 0.0560, 0.1395,\n", + " 0.0456, 0.0456, 0.0288, 0.0091, 0.0086, 0.1824, 0.0333],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "392000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 37, 30, 37, 35, 37, 33, 35, 34, 42, 30, 34, 40, 34, 37, 34, 42, 34,\n", + " 46, 34, 39, 33, 33, 37, 41])\n", + "loss= tensor(185.9984, grad_fn=) , actor= tensor(0.8580, grad_fn=) , critic= tensor(1851.4043, grad_fn=) , return= 175816.10316614603\n", + "probs of actions: tensor([0.0139, 0.1463, 0.0134, 0.1473, 0.0232, 0.1468, 0.0108, 0.0233, 0.1916,\n", + " 0.0572, 0.0129, 0.1912, 0.0131, 0.1895, 0.1405, 0.1884, 0.0562, 0.1865,\n", + " 0.0311, 0.1847, 0.0448, 0.0120, 0.0121, 0.1328, 0.0422],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "393000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 43, 34, 46, 34, 32, 43, 35, 43, 34, 41, 34, 42, 24, 48, 28, 43, 37,\n", + " 37, 34, 34, 31, 37, 34, 33])\n", + "loss= tensor(188.8465, grad_fn=) , actor= tensor(5.1157, grad_fn=) , critic= tensor(1837.3076, grad_fn=) , return= 176292.31815675576\n", + "probs of actions: tensor([0.0749, 0.0517, 0.1939, 0.0337, 0.1965, 0.0310, 0.0493, 0.0232, 0.0484,\n", + " 0.1985, 0.0445, 0.1979, 0.0578, 0.0149, 0.0037, 0.0215, 0.0459, 0.1303,\n", + " 0.1297, 0.1920, 0.1912, 0.0570, 0.1265, 0.1881, 0.0120],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "394000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 37, 42, 42, 27, 37, 31, 34, 26, 37, 21, 28, 29, 42, 20, 42, 34, 34,\n", + " 29, 31, 46, 35, 37, 40, 37])\n", + "loss= tensor(179.6189, grad_fn=) , actor= tensor(1.0330, grad_fn=) , critic= tensor(1785.8583, grad_fn=) , return= 173980.62981574924\n", + "probs of actions: tensor([0.0139, 0.1382, 0.0580, 0.0578, 0.0108, 0.1381, 0.0534, 0.2058, 0.0163,\n", + " 0.1360, 0.0022, 0.0208, 0.0842, 0.0567, 0.0057, 0.0565, 0.2004, 0.2004,\n", + " 0.0858, 0.0554, 0.0293, 0.0234, 0.1262, 0.0134, 0.1248],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "395000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 29, 31, 42, 34, 22, 42, 16, 34, 38, 42, 34, 39, 32, 42, 29, 37,\n", + " 33, 31, 31, 34, 45, 29, 39])\n", + "loss= tensor(175.2803, grad_fn=) , actor= tensor(-3.8575, grad_fn=) , critic= tensor(1791.3773, grad_fn=) , return= 174245.4201633357\n", + "probs of actions: tensor([0.1956, 0.0778, 0.0788, 0.0518, 0.0578, 0.2028, 0.0079, 0.0576, 0.0055,\n", + " 0.2050, 0.0330, 0.0568, 0.2023, 0.0482, 0.0310, 0.0563, 0.0865, 0.1280,\n", + " 0.0104, 0.0546, 0.0547, 0.1950, 0.0147, 0.0877, 0.0480],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "396000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 29, 29, 37, 37, 28, 29, 34, 34, 37, 43, 29, 28, 37, 34, 29, 31, 29,\n", + " 22, 29, 41, 41, 34, 37, 34])\n", + "loss= tensor(181.2901, grad_fn=) , actor= tensor(0.0134, grad_fn=) , critic= tensor(1812.7670, grad_fn=) , return= 174437.51383516737\n", + "probs of actions: tensor([0.0496, 0.0765, 0.0775, 0.1323, 0.1321, 0.0199, 0.0806, 0.2025, 0.2024,\n", + " 0.1299, 0.0458, 0.0832, 0.0202, 0.1272, 0.1993, 0.0848, 0.0533, 0.0853,\n", + " 0.0087, 0.0857, 0.0462, 0.0460, 0.1919, 0.1202, 0.1904],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "397000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 38, 37, 43, 31, 29, 34, 39, 36, 19, 42, 41, 39, 37, 42, 40, 37, 34,\n", + " 30, 46, 29, 38, 45, 29, 37])\n", + "loss= tensor(182.3263, grad_fn=) , actor= tensor(1.6387, grad_fn=) , critic= tensor(1806.8759, grad_fn=) , return= 175762.6231494559\n", + "probs of actions: tensor([0.1907, 0.0340, 0.1297, 0.0519, 0.0514, 0.0757, 0.1991, 0.0511, 0.0086,\n", + " 0.0030, 0.0592, 0.0483, 0.0507, 0.1251, 0.0584, 0.0130, 0.1231, 0.1944,\n", + " 0.0143, 0.0303, 0.0815, 0.0355, 0.0146, 0.0819, 0.1178],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "398000 adversary: AdversaryModes.myopic\n", + " actions: tensor([33, 42, 46, 39, 37, 37, 27, 43, 42, 23, 42, 37, 39, 29, 34, 24, 37, 21,\n", + " 34, 24, 31, 30, 27, 37, 24])\n", + "loss= tensor(180.6196, grad_fn=) , actor= tensor(-6.7112, grad_fn=) , critic= tensor(1873.3085, grad_fn=) , return= 175313.51968867294\n", + "probs of actions: tensor([0.0101, 0.0591, 0.0330, 0.0515, 0.1266, 0.1264, 0.0114, 0.0490, 0.0583,\n", + " 0.0049, 0.0584, 0.1231, 0.0507, 0.0817, 0.2034, 0.0166, 0.1199, 0.0025,\n", + " 0.1998, 0.0169, 0.0526, 0.0152, 0.0126, 0.1153, 0.0172],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "399000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 34, 5, 10, 34, 29, 29, 32, 34, 34, 34, 43, 35, 44, 38, 34, 34, 46,\n", + " 42, 34, 37, 33, 43, 41, 32])\n", + "loss= tensor(168.3295, grad_fn=) , actor= tensor(0.5864, grad_fn=) , critic= tensor(1677.4307, grad_fn=) , return= 173608.03458900657\n", + "probs of actions: tensor([0.0604, 0.2019, 0.0004, 0.0012, 0.2088, 0.0811, 0.0818, 0.0319, 0.2099,\n", + " 0.2097, 0.2094, 0.0451, 0.0208, 0.0258, 0.0342, 0.2061, 0.2054, 0.0306,\n", + " 0.0574, 0.2021, 0.1224, 0.0112, 0.0426, 0.0442, 0.0330],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "400000 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 37, 38, 43, 37, 34, 46, 41, 41, 25, 41, 37, 34, 34, 39, 29, 37, 34,\n", + " 40, 31, 29, 34, 29, 39, 24])\n", + "loss= tensor(187.3206, grad_fn=) , actor= tensor(4.4875, grad_fn=) , critic= tensor(1828.3302, grad_fn=) , return= 176136.16295910956\n", + "probs of actions: tensor([0.0019, 0.1305, 0.0344, 0.0477, 0.1303, 0.2096, 0.0323, 0.0496, 0.0493,\n", + " 0.0073, 0.0486, 0.1268, 0.2087, 0.2082, 0.0475, 0.0873, 0.1235, 0.2043,\n", + " 0.0127, 0.0509, 0.0884, 0.2005, 0.0886, 0.0474, 0.0168],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "401000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 29, 40, 37, 37, 45, 39, 29, 31, 37, 37, 37, 37, 34, 44, 29, 38,\n", + " 27, 27, 34, 29, 39, 43, 34])\n", + "loss= tensor(186.9336, grad_fn=) , actor= tensor(0.4966, grad_fn=) , critic= tensor(1864.3699, grad_fn=) , return= 175353.02382741403\n", + "probs of actions: tensor([0.0772, 0.1299, 0.0786, 0.0117, 0.1299, 0.1298, 0.0138, 0.0488, 0.0830,\n", + " 0.0494, 0.1273, 0.1265, 0.1260, 0.1253, 0.1971, 0.0266, 0.0863, 0.0365,\n", + " 0.0125, 0.0126, 0.1918, 0.0873, 0.0483, 0.0447, 0.1876],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "402000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 20, 44, 43, 46, 26, 42, 39, 28, 32, 37, 31, 42, 37, 44, 24, 34, 34,\n", + " 32, 42, 34, 5, 34, 29, 40])\n", + "loss= tensor(188.3087, grad_fn=) , actor= tensor(-2.4345, grad_fn=) , critic= tensor(1907.4318, grad_fn=) , return= 173902.96468884798\n", + "probs of actions: tensor([0.0466, 0.0051, 0.0256, 0.0502, 0.0323, 0.0158, 0.0588, 0.0487, 0.0183,\n", + " 0.0330, 0.1329, 0.0491, 0.0579, 0.1306, 0.0268, 0.0155, 0.1936, 0.1918,\n", + " 0.0336, 0.0569, 0.1885, 0.0004, 0.1882, 0.0899, 0.0132],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "403000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 34, 34, 24, 26, 29, 29, 29, 37, 34, 34, 37, 37, 46, 37, 19, 43, 34,\n", + " 37, 38, 29, 37, 38, 41, 34])\n", + "loss= tensor(174.9963, grad_fn=) , actor= tensor(0.1140, grad_fn=) , critic= tensor(1748.8228, grad_fn=) , return= 174353.15084853457\n", + "probs of actions: tensor([0.0156, 0.1937, 0.1954, 0.0158, 0.0156, 0.0801, 0.0808, 0.0815, 0.1340,\n", + " 0.1995, 0.1995, 0.1320, 0.1313, 0.0313, 0.1298, 0.0030, 0.0476, 0.1937,\n", + " 0.1268, 0.0364, 0.0861, 0.1246, 0.0367, 0.0471, 0.1879],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "404000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 28, 42, 42, 46, 37, 37, 37, 34, 34, 34, 19, 41, 48, 28, 42, 37,\n", + " 34, 37, 37, 42, 18, 37, 32])\n", + "loss= tensor(176.9319, grad_fn=) , actor= tensor(-5.5161, grad_fn=) , critic= tensor(1824.4802, grad_fn=) , return= 175765.5844477487\n", + "probs of actions: tensor([0.0763, 0.1335, 0.0188, 0.0546, 0.0543, 0.0325, 0.1328, 0.1325, 0.1320,\n", + " 0.2032, 0.2030, 0.2025, 0.0030, 0.0493, 0.0035, 0.0192, 0.0531, 0.1255,\n", + " 0.1970, 0.1242, 0.1234, 0.0525, 0.0030, 0.1215, 0.0337],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "405000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 42, 36, 37, 41, 39, 31, 34, 10, 37, 41, 37, 34, 43, 37, 42, 34,\n", + " 31, 37, 32, 39, 37, 39, 34])\n", + "loss= tensor(188.8246, grad_fn=) , actor= tensor(8.6874, grad_fn=) , critic= tensor(1801.3713, grad_fn=) , return= 175507.61118701054\n", + "probs of actions: tensor([0.1339, 0.1340, 0.0539, 0.0080, 0.1342, 0.0516, 0.0507, 0.0478, 0.2036,\n", + " 0.0012, 0.1313, 0.0491, 0.1296, 0.2009, 0.0473, 0.1275, 0.0525, 0.1975,\n", + " 0.0495, 0.1246, 0.0334, 0.0502, 0.1223, 0.0501, 0.1909],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "406000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 39, 34, 29, 42, 42, 41, 29, 28, 34, 32, 25, 32, 34, 46, 46, 34, 34,\n", + " 34, 24, 37, 37, 42, 30, 37])\n", + "loss= tensor(185.1072, grad_fn=) , actor= tensor(1.9785, grad_fn=) , critic= tensor(1831.2871, grad_fn=) , return= 175310.66336780752\n", + "probs of actions: tensor([0.0504, 0.0528, 0.2046, 0.0791, 0.0530, 0.0527, 0.0506, 0.0820, 0.0180,\n", + " 0.2097, 0.0325, 0.0076, 0.0326, 0.2069, 0.0316, 0.0315, 0.2039, 0.2039,\n", + " 0.2027, 0.0150, 0.1232, 0.1222, 0.0511, 0.0143, 0.1207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "407000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 37, 34, 29, 29, 37, 34, 33, 28, 44, 42, 29, 32, 43, 34, 46, 39, 44,\n", + " 44, 24, 41, 31, 34, 29, 38])\n", + "loss= tensor(179.3179, grad_fn=) , actor= tensor(-1.9469, grad_fn=) , critic= tensor(1812.6479, grad_fn=) , return= 175727.20477339136\n", + "probs of actions: tensor([0.0477, 0.1319, 0.2112, 0.0773, 0.0782, 0.1318, 0.2153, 0.0108, 0.0183,\n", + " 0.0267, 0.0526, 0.0824, 0.0317, 0.0420, 0.2118, 0.0301, 0.0522, 0.0274,\n", + " 0.0276, 0.0149, 0.0462, 0.0511, 0.2044, 0.0857, 0.0388],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "408000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 45, 37, 39, 43, 34, 25, 29, 42, 37, 39, 34, 44, 37, 44, 32, 38, 34,\n", + " 34, 39, 44, 31, 37, 45, 39])\n", + "loss= tensor(184.0071, grad_fn=) , actor= tensor(-1.2086, grad_fn=) , critic= tensor(1852.1572, grad_fn=) , return= 175800.49180048183\n", + "probs of actions: tensor([0.2134, 0.0126, 0.1286, 0.0551, 0.0441, 0.2211, 0.0073, 0.0799, 0.0505,\n", + " 0.1259, 0.0545, 0.2212, 0.0263, 0.1234, 0.0265, 0.0316, 0.0381, 0.2158,\n", + " 0.2150, 0.0542, 0.0271, 0.0520, 0.1174, 0.0137, 0.0540],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "409000 adversary: AdversaryModes.myopic\n", + " actions: tensor([47, 10, 30, 41, 42, 34, 34, 37, 37, 30, 39, 38, 39, 38, 34, 25, 43, 34,\n", + " 35, 46, 34, 41, 44, 34, 29])\n", + "loss= tensor(189.0589, grad_fn=) , actor= tensor(13.7057, grad_fn=) , critic= tensor(1753.5320, grad_fn=) , return= 175532.06619452272\n", + "probs of actions: tensor([0.0079, 0.0011, 0.0135, 0.0529, 0.0494, 0.2263, 0.2273, 0.1296, 0.1289,\n", + " 0.0130, 0.0523, 0.0377, 0.0523, 0.0379, 0.2242, 0.0076, 0.0397, 0.2203,\n", + " 0.0208, 0.0301, 0.2170, 0.0476, 0.0267, 0.2141, 0.0882],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "410000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 26, 39, 45, 39, 42, 39, 33, 34, 34, 34, 31, 41, 42, 34, 26, 43, 34,\n", + " 34, 24, 28, 34, 16, 25, 22])\n", + "loss= tensor(170.5600, grad_fn=) , actor= tensor(-16.5570, grad_fn=) , critic= tensor(1871.1700, grad_fn=) , return= 176151.32489098687\n", + "probs of actions: tensor([0.2198, 0.0167, 0.0519, 0.0124, 0.0517, 0.0504, 0.0515, 0.0098, 0.2300,\n", + " 0.2298, 0.2294, 0.0485, 0.0501, 0.0496, 0.2259, 0.0175, 0.0389, 0.2225,\n", + " 0.2224, 0.0145, 0.0189, 0.2185, 0.0049, 0.0080, 0.0084],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "411000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 24, 37, 46, 46, 29, 29, 34, 34, 37, 42, 30, 39, 32, 31, 34, 29, 34,\n", + " 34, 34, 34, 42, 41, 42, 37])\n", + "loss= tensor(188.6001, grad_fn=) , actor= tensor(5.8193, grad_fn=) , critic= tensor(1827.8081, grad_fn=) , return= 174959.91238600982\n", + "probs of actions: tensor([0.2211, 0.0148, 0.1311, 0.0328, 0.0325, 0.0813, 0.0822, 0.2316, 0.2315,\n", + " 0.1282, 0.0481, 0.0136, 0.0512, 0.0305, 0.0500, 0.2274, 0.0874, 0.2253,\n", + " 0.2237, 0.2226, 0.2215, 0.0474, 0.0486, 0.0473, 0.1182],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "412000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 46, 43, 34, 43, 42, 37, 42, 34, 34, 37, 37, 41, 29, 29, 37, 31, 36,\n", + " 43, 37, 37, 46, 46, 37, 44])\n", + "loss= tensor(176.2024, grad_fn=) , actor= tensor(-11.2925, grad_fn=) , critic= tensor(1874.9484, grad_fn=) , return= 175751.08391131152\n", + "probs of actions: tensor([0.2140, 0.0339, 0.0450, 0.2196, 0.0442, 0.0484, 0.1324, 0.0483, 0.2232,\n", + " 0.2237, 0.1301, 0.1293, 0.0517, 0.0885, 0.0890, 0.1263, 0.0517, 0.0081,\n", + " 0.0397, 0.1233, 0.1228, 0.0300, 0.0299, 0.1209, 0.0255],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "413000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 24, 41, 32, 37, 29, 37, 42, 38, 29, 34, 37, 34, 31, 31, 31, 43,\n", + " 32, 34, 35, 46, 31, 24, 37])\n", + "loss= tensor(172.4269, grad_fn=) , actor= tensor(-8.8747, grad_fn=) , critic= tensor(1813.0159, grad_fn=) , return= 175356.6093264476\n", + "probs of actions: tensor([0.2172, 0.2192, 0.0145, 0.0551, 0.0289, 0.1309, 0.0861, 0.1300, 0.0473,\n", + " 0.0370, 0.0888, 0.2262, 0.1265, 0.2241, 0.0524, 0.0525, 0.0527, 0.0391,\n", + " 0.0299, 0.2186, 0.0213, 0.0293, 0.0535, 0.0148, 0.1185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "414000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 46, 41, 37, 34, 40, 34, 41, 34, 46, 47, 24, 35, 37, 26, 21, 35, 16,\n", + " 34, 37, 39, 37, 43, 28, 34])\n", + "loss= tensor(189.6437, grad_fn=) , actor= tensor(3.4011, grad_fn=) , critic= tensor(1862.4258, grad_fn=) , return= 175203.9872937841\n", + "probs of actions: tensor([0.0236, 0.0357, 0.0556, 0.1308, 0.2191, 0.0106, 0.2203, 0.0531, 0.2208,\n", + " 0.0329, 0.0075, 0.0141, 0.0211, 0.1253, 0.0175, 0.0024, 0.0215, 0.0046,\n", + " 0.2146, 0.1206, 0.0545, 0.1196, 0.0396, 0.0183, 0.2080],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "415000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 39, 29, 43, 26, 35, 27, 34, 41, 37, 29, 38, 41, 37, 46, 39, 41, 39,\n", + " 34, 42, 42, 34, 22, 34, 37])\n", + "loss= tensor(193.8923, grad_fn=) , actor= tensor(12.0409, grad_fn=) , critic= tensor(1818.5140, grad_fn=) , return= 176076.03841973984\n", + "probs of actions: tensor([0.0564, 0.0563, 0.0818, 0.0443, 0.0165, 0.0214, 0.0100, 0.2164, 0.0526,\n", + " 0.1266, 0.0879, 0.0409, 0.0512, 0.1240, 0.0311, 0.0553, 0.0503, 0.0553,\n", + " 0.2091, 0.0479, 0.0478, 0.2056, 0.0087, 0.2042, 0.1166],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "416000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 46, 29, 34, 34, 34, 21, 17, 34, 29, 43, 29, 29, 34, 43, 19, 40, 43,\n", + " 34, 31, 45, 35, 46, 26, 34])\n", + "loss= tensor(163.8594, grad_fn=) , actor= tensor(-8.7795, grad_fn=) , critic= tensor(1726.3892, grad_fn=) , return= 174154.70726644836\n", + "probs of actions: tensor([0.1312, 0.0350, 0.0800, 0.2193, 0.2204, 0.2212, 0.0022, 0.0015, 0.2230,\n", + " 0.0856, 0.0416, 0.0864, 0.0870, 0.2198, 0.0405, 0.0026, 0.0110, 0.0398,\n", + " 0.2141, 0.0537, 0.0140, 0.0230, 0.0309, 0.0185, 0.2087],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "417000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 29, 26, 43, 37, 39, 41, 37, 34, 34, 33, 41, 37, 38, 41, 34, 38, 32,\n", + " 31, 23, 43, 43, 37, 42, 44])\n", + "loss= tensor(174.9864, grad_fn=) , actor= tensor(-12.7967, grad_fn=) , critic= tensor(1877.8308, grad_fn=) , return= 174971.92765752887\n", + "probs of actions: tensor([0.1276, 0.0833, 0.0166, 0.0416, 0.1273, 0.0546, 0.0508, 0.1261, 0.2236,\n", + " 0.2237, 0.0100, 0.0491, 0.1228, 0.0422, 0.0483, 0.2189, 0.0426, 0.0280,\n", + " 0.0539, 0.0045, 0.0369, 0.0367, 0.1164, 0.0464, 0.0245],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "418000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 31, 29, 31, 34, 42, 32, 31, 42, 37, 36, 34, 42, 32, 44, 41, 37, 31,\n", + " 38, 35, 31, 41, 25, 35, 34])\n", + "loss= tensor(181.7278, grad_fn=) , actor= tensor(-0.9587, grad_fn=) , critic= tensor(1826.8647, grad_fn=) , return= 176051.63479935774\n", + "probs of actions: tensor([0.0109, 0.0488, 0.0872, 0.0489, 0.2182, 0.0461, 0.0278, 0.0497, 0.0459,\n", + " 0.1230, 0.0076, 0.2182, 0.0456, 0.0283, 0.0239, 0.0479, 0.1187, 0.0512,\n", + " 0.0438, 0.0251, 0.0515, 0.0468, 0.0079, 0.0253, 0.2044],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "419000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 25, 42, 32, 41, 38, 14, 34, 49, 37, 37, 34, 37, 29, 34, 29, 34,\n", + " 42, 41, 34, 41, 34, 32, 41])\n", + "loss= tensor(188.7188, grad_fn=) , actor= tensor(8.5654, grad_fn=) , critic= tensor(1801.5345, grad_fn=) , return= 174741.80064442492\n", + "probs of actions: tensor([0.1301, 0.2187, 0.0067, 0.0462, 0.0264, 0.0509, 0.0406, 0.0014, 0.2272,\n", + " 0.0022, 0.1262, 0.1259, 0.2242, 0.1245, 0.0990, 0.2220, 0.0997, 0.2196,\n", + " 0.0451, 0.0470, 0.2156, 0.0467, 0.2132, 0.0276, 0.0463],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "420000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 39, 39, 42, 34, 44, 34, 31, 44, 34, 36, 34, 29, 34, 37, 35, 48, 38,\n", + " 34, 34, 39, 29, 34, 40, 44])\n", + "loss= tensor(183.9951, grad_fn=) , actor= tensor(-4.6709, grad_fn=) , critic= tensor(1886.6604, grad_fn=) , return= 175383.04946230282\n", + "probs of actions: tensor([0.0899, 0.0525, 0.0524, 0.0456, 0.2294, 0.0227, 0.2305, 0.0473, 0.0229,\n", + " 0.2306, 0.0075, 0.2301, 0.0990, 0.2289, 0.1253, 0.0251, 0.0034, 0.0402,\n", + " 0.2232, 0.2221, 0.0514, 0.1009, 0.2184, 0.0119, 0.0244],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "421000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 37, 42, 42, 29, 37, 28, 34, 37, 34, 34, 29, 24, 38, 29, 39, 29, 34,\n", + " 34, 29, 37, 46, 46, 34, 31])\n", + "loss= tensor(178.7458, grad_fn=) , actor= tensor(-0.5154, grad_fn=) , critic= tensor(1792.6118, grad_fn=) , return= 175330.39653356513\n", + "probs of actions: tensor([0.0502, 0.1364, 0.0447, 0.0445, 0.0979, 0.1360, 0.0178, 0.2346, 0.1342,\n", + " 0.2338, 0.2336, 0.1034, 0.0134, 0.0397, 0.1045, 0.0490, 0.1051, 0.2271,\n", + " 0.2254, 0.1056, 0.1256, 0.0281, 0.0281, 0.2191, 0.0490],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "422000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 38, 46, 35, 33, 42, 32, 32, 34, 29, 34, 34, 42, 44, 42, 41, 29, 39,\n", + " 32, 38, 29, 34, 32, 29, 39])\n", + "loss= tensor(198.4785, grad_fn=) , actor= tensor(10.5171, grad_fn=) , critic= tensor(1879.6134, grad_fn=) , return= 176022.77073732164\n", + "probs of actions: tensor([0.0430, 0.0391, 0.0321, 0.0236, 0.0090, 0.0435, 0.0255, 0.0255, 0.2374,\n", + " 0.1002, 0.2368, 0.2356, 0.0431, 0.0234, 0.0429, 0.0453, 0.1028, 0.0500,\n", + " 0.0263, 0.0406, 0.1036, 0.2247, 0.0266, 0.1039, 0.0499],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "423000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 43, 37, 29, 31, 35, 29, 30, 34, 34, 43, 34, 42, 42, 34, 24, 34, 24,\n", + " 37, 20, 24, 32, 32, 37, 31])\n", + "loss= tensor(171.6536, grad_fn=) , actor= tensor(-15.3071, grad_fn=) , critic= tensor(1869.6072, grad_fn=) , return= 174656.44857910956\n", + "probs of actions: tensor([0.1383, 0.0423, 0.1383, 0.0961, 0.0419, 0.0234, 0.0991, 0.0129, 0.2355,\n", + " 0.2350, 0.0386, 0.2332, 0.0447, 0.0446, 0.2307, 0.0141, 0.2297, 0.0143,\n", + " 0.1287, 0.0053, 0.0145, 0.0258, 0.0259, 0.1252, 0.0448],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "424000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 39, 44, 39, 38, 34, 43, 38, 34, 29, 34, 37, 31, 34, 29, 39, 37, 41,\n", + " 29, 29, 43, 38, 20, 28, 42])\n", + "loss= tensor(176.8825, grad_fn=) , actor= tensor(-14.1486, grad_fn=) , critic= tensor(1910.3109, grad_fn=) , return= 175520.9864135934\n", + "probs of actions: tensor([0.0382, 0.0499, 0.0211, 0.0497, 0.0381, 0.2365, 0.0411, 0.0382, 0.2374,\n", + " 0.0982, 0.2373, 0.1385, 0.0441, 0.2348, 0.1007, 0.0490, 0.1346, 0.0441,\n", + " 0.1016, 0.1019, 0.0378, 0.0397, 0.0055, 0.0195, 0.0441],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "425000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 40, 41, 34, 37, 29, 29, 36, 39, 34, 31, 31, 34, 24, 29, 34, 47, 29,\n", + " 43, 31, 29, 37, 33, 29, 37])\n", + "loss= tensor(181.5779, grad_fn=) , actor= tensor(-1.4246, grad_fn=) , critic= tensor(1830.0251, grad_fn=) , return= 175054.597361053\n", + "probs of actions: tensor([0.2302, 0.0099, 0.0485, 0.2360, 0.1453, 0.0958, 0.0968, 0.0073, 0.0491,\n", + " 0.2389, 0.0429, 0.0430, 0.2374, 0.0131, 0.1018, 0.2344, 0.0076, 0.1024,\n", + " 0.0377, 0.0444, 0.1030, 0.1328, 0.0097, 0.1033, 0.1307],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "426000 adversary: AdversaryModes.myopic\n", + " actions: tensor([44, 19, 29, 29, 38, 46, 37, 36, 37, 38, 34, 31, 29, 34, 35, 31, 34, 28,\n", + " 29, 40, 31, 2, 38, 34, 37])\n", + "loss= tensor(183.4593, grad_fn=) , actor= tensor(-8.1459, grad_fn=) , critic= tensor(1916.0520, grad_fn=) , return= 173365.97347026668\n", + "probs of actions: tensor([2.0706e-02, 2.4865e-03, 9.4978e-02, 9.5938e-02, 3.8016e-02, 2.7850e-02,\n", + " 1.3852e-01, 7.1538e-03, 1.3749e-01, 3.8316e-02, 2.4918e-01, 4.4354e-02,\n", + " 1.0287e-01, 2.4718e-01, 2.3705e-02, 4.5047e-02, 2.4364e-01, 1.8745e-02,\n", + " 1.0483e-01, 1.0991e-02, 4.5782e-02, 2.0191e-04, 3.9825e-02, 2.3254e-01,\n", + " 1.2584e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "427000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 41, 34, 39, 29, 27, 31, 37, 34, 38, 37, 29, 34, 45, 29, 34, 34, 36,\n", + " 41, 39, 42, 32, 34, 31, 47])\n", + "loss= tensor(169.9167, grad_fn=) , actor= tensor(-14.4489, grad_fn=) , critic= tensor(1843.6564, grad_fn=) , return= 174743.34519810462\n", + "probs of actions: tensor([0.0955, 0.0476, 0.2352, 0.0521, 0.0994, 0.0083, 0.0442, 0.1445, 0.2402,\n", + " 0.0383, 0.1423, 0.1051, 0.2387, 0.0117, 0.1065, 0.2360, 0.2342, 0.0074,\n", + " 0.0427, 0.0515, 0.0426, 0.0266, 0.2272, 0.0467, 0.0076],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "428000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 38, 45, 34, 29, 40, 37, 34, 35, 46, 34, 37, 34, 34, 29, 43, 41,\n", + " 34, 22, 34, 41, 37, 34, 31])\n", + "loss= tensor(187.9799, grad_fn=) , actor= tensor(4.9856, grad_fn=) , critic= tensor(1829.9424, grad_fn=) , return= 176113.38503382017\n", + "probs of actions: tensor([0.0982, 0.1402, 0.0381, 0.0115, 0.2461, 0.1033, 0.0106, 0.1383, 0.2483,\n", + " 0.0243, 0.0244, 0.2461, 0.1349, 0.2451, 0.2443, 0.1100, 0.0402, 0.0425,\n", + " 0.2390, 0.0078, 0.2374, 0.0420, 0.1274, 0.2326, 0.0453],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "429000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 34, 46, 34, 34, 34, 29, 46, 46, 41, 46, 37, 34, 38, 34, 28, 42, 41,\n", + " 39, 43, 29, 29, 34, 40, 40])\n", + "loss= tensor(177.0206, grad_fn=) , actor= tensor(-9.1330, grad_fn=) , critic= tensor(1861.5358, grad_fn=) , return= 175609.45769166204\n", + "probs of actions: tensor([0.0069, 0.2422, 0.0267, 0.2448, 0.2473, 0.2481, 0.1029, 0.0252, 0.0251,\n", + " 0.0439, 0.0247, 0.1344, 0.2468, 0.0397, 0.2446, 0.0189, 0.0411, 0.0423,\n", + " 0.0498, 0.0405, 0.1094, 0.1096, 0.2347, 0.0119, 0.0120],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "430000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 34, 34, 34, 34, 34, 31, 34, 35, 47, 41, 35, 34, 32, 34, 38, 43, 34,\n", + " 41, 34, 36, 39, 29, 41, 37])\n", + "loss= tensor(177.5388, grad_fn=) , actor= tensor(-5.1472, grad_fn=) , critic= tensor(1826.8599, grad_fn=) , return= 175904.28999315036\n", + "probs of actions: tensor([0.0250, 0.2399, 0.2426, 0.2446, 0.2460, 0.2469, 0.0411, 0.2479, 0.0255,\n", + " 0.0066, 0.0464, 0.0258, 0.2457, 0.0255, 0.2440, 0.0405, 0.0404, 0.2398,\n", + " 0.0449, 0.2375, 0.0071, 0.0489, 0.1078, 0.0443, 0.1295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "431000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 21, 28, 37, 34, 39, 47, 35, 34, 34, 37, 19, 34, 37, 34, 33, 20,\n", + " 29, 43, 29, 44, 34, 41, 39])\n", + "loss= tensor(179.5696, grad_fn=) , actor= tensor(-2.3905, grad_fn=) , critic= tensor(1819.6013, grad_fn=) , return= 173801.67988524158\n", + "probs of actions: tensor([0.2329, 0.2349, 0.0021, 0.0180, 0.1421, 0.2413, 0.0479, 0.0065, 0.0259,\n", + " 0.2425, 0.2420, 0.1376, 0.0025, 0.2406, 0.1349, 0.2371, 0.0085, 0.0048,\n", + " 0.1030, 0.0409, 0.1032, 0.0207, 0.2281, 0.0442, 0.0478],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "432000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 35, 34, 37, 32, 34, 34, 38, 46, 37, 38, 34, 37, 34, 40, 37, 43,\n", + " 24, 37, 47, 29, 36, 32, 42])\n", + "loss= tensor(167.4750, grad_fn=) , actor= tensor(-18.5426, grad_fn=) , critic= tensor(1860.1764, grad_fn=) , return= 175725.82604049862\n", + "probs of actions: tensor([0.0425, 0.2381, 0.0249, 0.2430, 0.1414, 0.0259, 0.2460, 0.2461, 0.0427,\n", + " 0.0268, 0.1375, 0.0430, 0.2439, 0.1352, 0.2421, 0.0101, 0.1327, 0.0426,\n", + " 0.0142, 0.1305, 0.0071, 0.1030, 0.0077, 0.0273, 0.0401],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "433000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 37, 32, 21, 31, 34, 43, 34, 34, 34, 42, 34, 35, 42, 32, 34, 39, 46,\n", + " 43, 28, 38, 31, 34, 37, 34])\n", + "loss= tensor(189.4435, grad_fn=) , actor= tensor(9.5746, grad_fn=) , critic= tensor(1798.6887, grad_fn=) , return= 175787.33308269657\n", + "probs of actions: tensor([0.0473, 0.1395, 0.0254, 0.0019, 0.0432, 0.2530, 0.0456, 0.2528, 0.2538,\n", + " 0.2536, 0.0384, 0.2517, 0.0256, 0.0383, 0.0261, 0.2487, 0.0464, 0.0251,\n", + " 0.0420, 0.0188, 0.0442, 0.0461, 0.2394, 0.1256, 0.2363],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "434000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 24, 28, 37, 34, 32, 29, 34, 34, 34, 29, 34, 43, 15, 37, 37, 34, 30,\n", + " 32, 30, 41, 34, 34, 42, 39])\n", + "loss= tensor(172.3487, grad_fn=) , actor= tensor(-6.4280, grad_fn=) , critic= tensor(1787.7673, grad_fn=) , return= 173481.06440160022\n", + "probs of actions: tensor([0.0132, 0.0148, 0.0188, 0.1366, 0.2446, 0.0259, 0.0978, 0.2468, 0.2465,\n", + " 0.2463, 0.1009, 0.2454, 0.0453, 0.0012, 0.1296, 0.1285, 0.2397, 0.0123,\n", + " 0.0267, 0.0125, 0.0448, 0.2329, 0.2325, 0.0381, 0.0468],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "435000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 41, 34, 34, 29, 43, 31, 34, 40, 46, 19, 27, 34, 37, 37, 35, 35, 29,\n", + " 42, 32, 39, 38, 26, 34, 34])\n", + "loss= tensor(186.8148, grad_fn=) , actor= tensor(5.5509, grad_fn=) , critic= tensor(1812.6388, grad_fn=) , return= 175403.53297588447\n", + "probs of actions: tensor([0.0446, 0.0505, 0.2493, 0.2520, 0.0918, 0.0487, 0.0414, 0.2555, 0.0094,\n", + " 0.0252, 0.0022, 0.0090, 0.2533, 0.1340, 0.1333, 0.0278, 0.0278, 0.0998,\n", + " 0.0368, 0.0261, 0.0470, 0.0464, 0.0144, 0.2400, 0.2380],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "436000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 39, 16, 47, 37, 43, 37, 34, 37, 43, 29, 29, 43, 44, 28, 29, 32, 34,\n", + " 37, 34, 34, 32, 24, 33, 41])\n", + "loss= tensor(183.8441, grad_fn=) , actor= tensor(-4.8517, grad_fn=) , critic= tensor(1886.9575, grad_fn=) , return= 174818.48135555515\n", + "probs of actions: tensor([0.0453, 0.0452, 0.0038, 0.0065, 0.1390, 0.0463, 0.1382, 0.2621, 0.1370,\n", + " 0.0444, 0.1008, 0.1015, 0.0435, 0.0189, 0.0180, 0.1034, 0.0251, 0.2540,\n", + " 0.1292, 0.2509, 0.2499, 0.0255, 0.0142, 0.0087, 0.0432],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "437000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 41, 34, 32, 39, 37, 34, 46, 37, 37, 38, 29, 35, 34, 31, 44, 44, 26,\n", + " 37, 29, 29, 39, 37, 46, 38])\n", + "loss= tensor(182.8102, grad_fn=) , actor= tensor(-3.4860, grad_fn=) , critic= tensor(1862.9625, grad_fn=) , return= 175101.18188373104\n", + "probs of actions: tensor([0.0124, 0.0504, 0.2499, 0.0250, 0.0455, 0.1390, 0.2551, 0.0255, 0.1371,\n", + " 0.1366, 0.0469, 0.1066, 0.0276, 0.2522, 0.0426, 0.0185, 0.0187, 0.0135,\n", + " 0.1297, 0.1097, 0.1099, 0.0452, 0.1267, 0.0242, 0.0485],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "438000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 26, 38, 44, 34, 37, 41, 38, 46, 29, 31, 23, 46, 41, 39, 37, 38, 34,\n", + " 34, 41, 34, 39, 37, 34, 34])\n", + "loss= tensor(203.8638, grad_fn=) , actor= tensor(23.1084, grad_fn=) , critic= tensor(1807.5537, grad_fn=) , return= 176200.38818805036\n", + "probs of actions: tensor([0.2480, 0.0120, 0.0463, 0.0172, 0.2554, 0.1371, 0.0488, 0.0466, 0.0255,\n", + " 0.1051, 0.0410, 0.0030, 0.0249, 0.0466, 0.0435, 0.1301, 0.0477, 0.2499,\n", + " 0.2489, 0.0457, 0.2454, 0.0437, 0.1251, 0.2418, 0.2407],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "439000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 35, 42, 29, 42, 34, 34, 34, 42, 31, 35, 43, 34, 34, 14, 31, 28,\n", + " 39, 37, 29, 43, 34, 34, 31])\n", + "loss= tensor(180.5757, grad_fn=) , actor= tensor(-0.9576, grad_fn=) , critic= tensor(1815.3335, grad_fn=) , return= 175235.80563378314\n", + "probs of actions: tensor([0.2553, 0.2574, 0.0287, 0.0364, 0.0995, 0.0362, 0.2644, 0.2654, 0.2655,\n", + " 0.0359, 0.0412, 0.0294, 0.0435, 0.2610, 0.2609, 0.0014, 0.0419, 0.0183,\n", + " 0.0406, 0.1258, 0.1087, 0.0417, 0.2488, 0.2485, 0.0432],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "440000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 38, 43, 34, 34, 34, 34, 37, 28, 32, 37, 37, 34, 29, 41, 36, 38, 34,\n", + " 26, 34, 33, 35, 33, 29, 28])\n", + "loss= tensor(159.6803, grad_fn=) , actor= tensor(-22.0386, grad_fn=) , critic= tensor(1817.1882, grad_fn=) , return= 176073.09268032023\n", + "probs of actions: tensor([0.0975, 0.0446, 0.0483, 0.2565, 0.2587, 0.2596, 0.2600, 0.1392, 0.0172,\n", + " 0.0242, 0.1371, 0.1363, 0.2575, 0.1085, 0.0474, 0.0068, 0.0460, 0.2517,\n", + " 0.0125, 0.2497, 0.0078, 0.0298, 0.0079, 0.1112, 0.0183],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "441000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 43, 34, 34, 33, 37, 34, 35, 34, 26, 42, 43, 29, 41, 43, 46, 24,\n", + " 31, 34, 34, 35, 35, 34, 22])\n", + "loss= tensor(170.2209, grad_fn=) , actor= tensor(-8.4939, grad_fn=) , critic= tensor(1787.1487, grad_fn=) , return= 176479.71450705675\n", + "probs of actions: tensor([0.2556, 0.2577, 0.0485, 0.2619, 0.2642, 0.0066, 0.1378, 0.2657, 0.0278,\n", + " 0.2659, 0.0112, 0.0353, 0.0439, 0.1045, 0.0467, 0.0432, 0.0258, 0.0140,\n", + " 0.0403, 0.2550, 0.2532, 0.0292, 0.0293, 0.2491, 0.0076],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "442000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 39, 38, 38, 29, 37, 30, 37, 43, 35, 32, 43, 43, 34, 34, 37, 35,\n", + " 39, 34, 34, 34, 31, 34, 38])\n", + "loss= tensor(200.0867, grad_fn=) , actor= tensor(13.5961, grad_fn=) , critic= tensor(1864.9054, grad_fn=) , return= 176196.48765828402\n", + "probs of actions: tensor([0.0522, 0.2618, 0.0430, 0.0484, 0.0484, 0.0968, 0.1312, 0.0112, 0.1300,\n", + " 0.0469, 0.0270, 0.0254, 0.0460, 0.0456, 0.2659, 0.2657, 0.1245, 0.0277,\n", + " 0.0425, 0.2594, 0.2584, 0.2568, 0.0412, 0.2539, 0.0506],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "443000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 35, 44, 32, 20, 34, 19, 28, 34, 43, 37, 34, 31, 34, 44, 34, 34, 22,\n", + " 38, 44, 30, 27, 29, 29, 25])\n", + "loss= tensor(171.2928, grad_fn=) , actor= tensor(-4.7438, grad_fn=) , critic= tensor(1760.3662, grad_fn=) , return= 174932.40675021475\n", + "probs of actions: tensor([0.0380, 0.0261, 0.0162, 0.0254, 0.0039, 0.2762, 0.0019, 0.0168, 0.2769,\n", + " 0.0457, 0.1257, 0.2749, 0.0396, 0.2733, 0.0170, 0.2696, 0.2696, 0.0069,\n", + " 0.0510, 0.0176, 0.0120, 0.0096, 0.1026, 0.1027, 0.0094],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "444000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 44, 37, 34, 34, 37, 28, 34, 38, 43, 34, 34, 42, 44, 31, 34, 34, 37,\n", + " 35, 30, 37, 42, 34, 46, 32])\n", + "loss= tensor(175.6095, grad_fn=) , actor= tensor(-8.4233, grad_fn=) , critic= tensor(1840.3276, grad_fn=) , return= 176098.40764357382\n", + "probs of actions: tensor([0.0529, 0.0163, 0.1349, 0.2733, 0.2753, 0.1341, 0.0161, 0.2778, 0.0477,\n", + " 0.0467, 0.2760, 0.2761, 0.0357, 0.0170, 0.0407, 0.2722, 0.2703, 0.1260,\n", + " 0.0283, 0.0117, 0.1239, 0.0357, 0.2608, 0.0251, 0.0266],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "445000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 29, 38, 34, 41, 42, 34, 29, 34, 29, 37, 41, 34, 40, 21, 34, 37, 46,\n", + " 34, 42, 34, 31, 46, 46, 34])\n", + "loss= tensor(175.8284, grad_fn=) , actor= tensor(-3.6332, grad_fn=) , critic= tensor(1794.6158, grad_fn=) , return= 175163.28488343576\n", + "probs of actions: tensor([0.0381, 0.0821, 0.0482, 0.2778, 0.0516, 0.0359, 0.2809, 0.0870, 0.2825,\n", + " 0.0885, 0.1289, 0.0489, 0.2788, 0.0109, 0.0019, 0.2771, 0.1246, 0.0251,\n", + " 0.2705, 0.0356, 0.2681, 0.0412, 0.0250, 0.0250, 0.2623],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "446000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 36, 32, 26, 28, 22, 37, 29, 34, 37, 37, 42, 34, 34, 34, 31, 29, 26,\n", + " 29, 21, 16, 39, 43, 32, 34])\n", + "loss= tensor(178.3453, grad_fn=) , actor= tensor(-6.6038, grad_fn=) , critic= tensor(1849.4911, grad_fn=) , return= 173527.53166763176\n", + "probs of actions: tensor([0.0558, 0.0066, 0.0243, 0.0102, 0.0163, 0.0058, 0.1301, 0.0853, 0.2868,\n", + " 0.1283, 0.1276, 0.0357, 0.2831, 0.2828, 0.2815, 0.0385, 0.0900, 0.0113,\n", + " 0.0907, 0.0021, 0.0044, 0.0432, 0.0427, 0.0259, 0.2667],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "447000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 29, 39, 29, 44, 34, 34, 37, 32, 37, 34, 34, 43, 34, 25, 37, 34,\n", + " 41, 35, 28, 29, 37, 34, 26])\n", + "loss= tensor(170.6981, grad_fn=) , actor= tensor(-10.4271, grad_fn=) , critic= tensor(1811.2513, grad_fn=) , return= 176081.38917738653\n", + "probs of actions: tensor([0.1363, 0.2699, 0.0827, 0.0432, 0.0844, 0.0161, 0.2783, 0.2796, 0.1341,\n", + " 0.0252, 0.1328, 0.2780, 0.2773, 0.0463, 0.2742, 0.0086, 0.1285, 0.2705,\n", + " 0.0517, 0.0276, 0.0169, 0.0933, 0.1244, 0.2615, 0.0119],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "448000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 39, 43, 37, 43, 34, 34, 37, 42, 37, 32, 43, 29, 39, 34, 34, 34, 30,\n", + " 34, 34, 38, 25, 43, 36, 34])\n", + "loss= tensor(176.7278, grad_fn=) , actor= tensor(-10.9153, grad_fn=) , critic= tensor(1876.4308, grad_fn=) , return= 176084.70331569933\n", + "probs of actions: tensor([0.2815, 0.0423, 0.0509, 0.1339, 0.0499, 0.2915, 0.2929, 0.1324, 0.0344,\n", + " 0.1311, 0.0258, 0.0467, 0.0891, 0.0414, 0.2875, 0.2868, 0.2853, 0.0113,\n", + " 0.2824, 0.2802, 0.0484, 0.0089, 0.0443, 0.0068, 0.2727],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "449000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 34, 34, 41, 43, 34, 26, 39, 40, 29, 41, 34, 34, 34, 42, 31, 35, 38,\n", + " 29, 31, 30, 29, 37, 34, 12])\n", + "loss= tensor(170.8956, grad_fn=) , actor= tensor(-10.8914, grad_fn=) , critic= tensor(1817.8700, grad_fn=) , return= 176766.35641352503\n", + "probs of actions: tensor([0.0096, 0.2819, 0.2868, 0.0553, 0.0496, 0.2912, 0.0097, 0.0409, 0.0104,\n", + " 0.0874, 0.0523, 0.2906, 0.2903, 0.2890, 0.0355, 0.0376, 0.0267, 0.0490,\n", + " 0.0916, 0.0381, 0.0112, 0.0925, 0.1206, 0.2731, 0.0011],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "450000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 41, 37, 38, 34, 44, 47, 46, 34, 38, 34, 45, 34, 38, 29, 34, 34, 34,\n", + " 37, 40, 29, 40, 32, 29, 34])\n", + "loss= tensor(194.6282, grad_fn=) , actor= tensor(7.4085, grad_fn=) , critic= tensor(1872.1976, grad_fn=) , return= 176723.8750714494\n", + "probs of actions: tensor([0.0339, 0.0591, 0.1347, 0.0491, 0.2885, 0.0161, 0.0063, 0.0251, 0.2901,\n", + " 0.0495, 0.2901, 0.0101, 0.2875, 0.0500, 0.0883, 0.2853, 0.2831, 0.2816,\n", + " 0.1258, 0.0117, 0.0904, 0.0119, 0.0267, 0.0911, 0.2710],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "451000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 32, 37, 37, 30, 28, 31, 43, 40, 41, 29, 29, 42, 37, 40, 34, 34,\n", + " 44, 43, 35, 34, 29, 37, 35])\n", + "loss= tensor(186.1927, grad_fn=) , actor= tensor(6.2845, grad_fn=) , critic= tensor(1799.0819, grad_fn=) , return= 175927.28309841343\n", + "probs of actions: tensor([0.2747, 0.2770, 0.0260, 0.1318, 0.1315, 0.0119, 0.0146, 0.0359, 0.0457,\n", + " 0.0103, 0.0544, 0.0882, 0.0889, 0.0353, 0.1256, 0.0108, 0.2788, 0.2780,\n", + " 0.0178, 0.0428, 0.0261, 0.2720, 0.0923, 0.1201, 0.0265],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "452000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 43, 31, 37, 43, 28, 43, 35, 34, 31, 28, 40, 26, 43, 31, 26, 28, 34,\n", + " 34, 29, 27, 31, 34, 34, 37])\n", + "loss= tensor(204.6729, grad_fn=) , actor= tensor(16.7337, grad_fn=) , critic= tensor(1879.3915, grad_fn=) , return= 174632.7521834253\n", + "probs of actions: tensor([0.0239, 0.0457, 0.0336, 0.1302, 0.0440, 0.0141, 0.0431, 0.0244, 0.2974,\n", + " 0.0340, 0.0142, 0.0104, 0.0100, 0.0407, 0.0350, 0.0102, 0.0146, 0.2883,\n", + " 0.2861, 0.0903, 0.0102, 0.0359, 0.2798, 0.2781, 0.1180],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "453000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 31, 34, 39, 34, 34, 31, 37, 46, 34, 38, 31, 39, 43, 34, 34, 44, 34,\n", + " 40, 29, 41, 34, 30, 34, 34])\n", + "loss= tensor(189.4917, grad_fn=) , actor= tensor(6.6284, grad_fn=) , critic= tensor(1828.6328, grad_fn=) , return= 176367.7487568057\n", + "probs of actions: tensor([0.0409, 0.0312, 0.3200, 0.0403, 0.3241, 0.3261, 0.0311, 0.1264, 0.0218,\n", + " 0.3261, 0.0473, 0.0318, 0.0396, 0.0384, 0.3212, 0.3210, 0.0164, 0.3164,\n", + " 0.0108, 0.0894, 0.0535, 0.3094, 0.0119, 0.3070, 0.3047],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "454000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 42, 32, 31, 29, 35, 34, 34, 41, 26, 43, 29, 39, 34, 43, 41, 29,\n", + " 37, 34, 34, 38, 31, 37, 41])\n", + "loss= tensor(187.9630, grad_fn=) , actor= tensor(4.6171, grad_fn=) , critic= tensor(1833.4591, grad_fn=) , return= 175093.94049635658\n", + "probs of actions: tensor([0.0787, 0.1235, 0.0338, 0.0247, 0.0327, 0.0824, 0.0227, 0.3285, 0.3289,\n", + " 0.0589, 0.0090, 0.0388, 0.0872, 0.0399, 0.3227, 0.0379, 0.0568, 0.0894,\n", + " 0.1154, 0.3147, 0.3133, 0.0477, 0.0355, 0.1129, 0.0554],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "455000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 46, 31, 34, 34, 37, 34, 29, 31, 29, 38, 37, 34, 38, 29, 41, 34,\n", + " 34, 16, 29, 29, 34, 34, 31])\n", + "loss= tensor(182.5055, grad_fn=) , actor= tensor(-3.3457, grad_fn=) , critic= tensor(1858.5115, grad_fn=) , return= 174999.14337206306\n", + "probs of actions: tensor([0.3185, 0.3213, 0.0233, 0.0343, 0.3304, 0.3316, 0.1206, 0.3325, 0.0869,\n", + " 0.0346, 0.0884, 0.0462, 0.1172, 0.3283, 0.0467, 0.0910, 0.0559, 0.3214,\n", + " 0.3208, 0.0037, 0.0929, 0.0933, 0.3126, 0.3105, 0.0371],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "456000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 39, 34, 37, 35, 34, 38, 29, 34, 37, 22, 34, 39, 31, 34, 24, 37,\n", + " 34, 41, 22, 41, 34, 41, 34])\n", + "loss= tensor(183.8293, grad_fn=) , actor= tensor(0.1470, grad_fn=) , critic= tensor(1836.8225, grad_fn=) , return= 174900.567696959\n", + "probs of actions: tensor([0.3368, 0.0618, 0.0386, 0.3465, 0.1214, 0.0220, 0.3518, 0.0439, 0.0831,\n", + " 0.3530, 0.1183, 0.0060, 0.3507, 0.0378, 0.0317, 0.3455, 0.0119, 0.1145,\n", + " 0.3388, 0.0549, 0.0068, 0.0546, 0.3307, 0.0544, 0.3277],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "457000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 34, 41, 14, 46, 42, 31, 43, 37, 38, 20, 44, 44, 33, 38, 39, 34,\n", + " 41, 46, 45, 34, 34, 41, 41])\n", + "loss= tensor(192.0509, grad_fn=) , actor= tensor(12.7378, grad_fn=) , critic= tensor(1793.1309, grad_fn=) , return= 175127.14030038647\n", + "probs of actions: tensor([0.3373, 0.0415, 0.3431, 0.0587, 0.0009, 0.0226, 0.0309, 0.0324, 0.0381,\n", + " 0.1222, 0.0462, 0.0034, 0.0157, 0.0159, 0.0056, 0.0470, 0.0371, 0.3414,\n", + " 0.0535, 0.0213, 0.0094, 0.3338, 0.3330, 0.0528, 0.0527],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "458000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 34, 34, 42, 40, 41, 34, 34, 44, 38, 34, 38, 16, 34, 23, 37, 34, 24,\n", + " 37, 46, 40, 35, 34, 34, 32])\n", + "loss= tensor(178.4910, grad_fn=) , actor= tensor(-2.4833, grad_fn=) , critic= tensor(1809.7432, grad_fn=) , return= 175498.98335088493\n", + "probs of actions: tensor([0.0377, 0.3488, 0.3539, 0.0324, 0.0085, 0.0542, 0.3610, 0.3624, 0.0151,\n", + " 0.0456, 0.3613, 0.0458, 0.0032, 0.3594, 0.0024, 0.1204, 0.3514, 0.0117,\n", + " 0.1189, 0.0213, 0.0097, 0.0250, 0.3412, 0.3390, 0.0258],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "459000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 29, 30, 34, 32, 41, 34, 29, 42, 37, 32, 41, 34, 43, 34, 41, 41,\n", + " 37, 42, 34, 34, 31, 34, 44])\n", + "loss= tensor(187.1350, grad_fn=) , actor= tensor(2.5613, grad_fn=) , critic= tensor(1845.7371, grad_fn=) , return= 175552.6550868847\n", + "probs of actions: tensor([0.3571, 0.0398, 0.0720, 0.0102, 0.3704, 0.0237, 0.0539, 0.3719, 0.0762,\n", + " 0.0315, 0.1157, 0.0241, 0.0519, 0.3670, 0.0351, 0.3634, 0.0511, 0.0510,\n", + " 0.1119, 0.0318, 0.3539, 0.3528, 0.0329, 0.3483, 0.0167],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "460000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 45, 29, 45, 37, 41, 35, 41, 24, 29, 12, 34, 34, 34, 38, 31, 38,\n", + " 24, 47, 34, 34, 38, 34, 31])\n", + "loss= tensor(187.8641, grad_fn=) , actor= tensor(9.4098, grad_fn=) , critic= tensor(1784.5430, grad_fn=) , return= 174859.56410603228\n", + "probs of actions: tensor([0.1191, 0.3398, 0.0087, 0.0737, 0.0086, 0.1177, 0.0560, 0.0231, 0.0551,\n", + " 0.0119, 0.0787, 0.0008, 0.3503, 0.3460, 0.3450, 0.0487, 0.0329, 0.0490,\n", + " 0.0125, 0.0057, 0.3323, 0.3326, 0.0497, 0.3280, 0.0342],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "461000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 49, 18, 34, 37, 34, 37, 29, 34, 39, 34, 37, 34, 34, 31, 37, 34, 34,\n", + " 38, 34, 37, 27, 34, 34, 39])\n", + "loss= tensor(192.0264, grad_fn=) , actor= tensor(7.0616, grad_fn=) , critic= tensor(1849.6482, grad_fn=) , return= 174999.3791814532\n", + "probs of actions: tensor([0.1207, 0.0018, 0.0014, 0.3597, 0.1196, 0.3619, 0.1187, 0.0758, 0.3642,\n", + " 0.0390, 0.3619, 0.1162, 0.3596, 0.3584, 0.0316, 0.1140, 0.3526, 0.3512,\n", + " 0.0486, 0.3467, 0.1117, 0.0090, 0.3416, 0.3384, 0.0400],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "462000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 34, 34, 30, 43, 31, 38, 34, 43, 41, 46, 47, 46, 43, 37, 46, 33,\n", + " 34, 34, 34, 32, 38, 39, 37])\n", + "loss= tensor(191.0643, grad_fn=) , actor= tensor(6.9208, grad_fn=) , critic= tensor(1841.4347, grad_fn=) , return= 176461.22237865644\n", + "probs of actions: tensor([0.0706, 0.1236, 0.3669, 0.3705, 0.0101, 0.0365, 0.0304, 0.0446, 0.3753,\n", + " 0.0351, 0.0541, 0.0219, 0.0050, 0.0218, 0.0342, 0.1173, 0.0217, 0.0055,\n", + " 0.3623, 0.3595, 0.3571, 0.0230, 0.0468, 0.0377, 0.1129],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "463000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 41, 39, 35, 34, 34, 41, 37, 34, 41, 34, 29, 31, 34, 34, 41,\n", + " 41, 34, 34, 41, 34, 34, 34])\n", + "loss= tensor(193.1618, grad_fn=) , actor= tensor(10.7494, grad_fn=) , critic= tensor(1824.1235, grad_fn=) , return= 176323.52082218893\n", + "probs of actions: tensor([0.3636, 0.3666, 0.3709, 0.0551, 0.0355, 0.0222, 0.3787, 0.3792, 0.0527,\n", + " 0.1275, 0.3779, 0.0518, 0.3748, 0.0766, 0.0312, 0.3705, 0.3682, 0.0506,\n", + " 0.0505, 0.3619, 0.3607, 0.0502, 0.3553, 0.3542, 0.3519],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "464000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 37, 39, 34, 31, 33, 31, 23, 34, 29, 41, 42, 45, 30, 32, 34, 32, 34,\n", + " 34, 37, 29, 29, 37, 27, 42])\n", + "loss= tensor(190.0435, grad_fn=) , actor= tensor(3.7902, grad_fn=) , critic= tensor(1862.5334, grad_fn=) , return= 174765.48966820756\n", + "probs of actions: tensor([0.0430, 0.1238, 0.0345, 0.3830, 0.0288, 0.0048, 0.0290, 0.0020, 0.3901,\n", + " 0.0767, 0.0553, 0.0311, 0.0079, 0.0103, 0.0214, 0.3803, 0.0217, 0.3761,\n", + " 0.3736, 0.1152, 0.0820, 0.0824, 0.1138, 0.0084, 0.0319],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "465000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 34, 34, 46, 34, 43, 42, 38, 37, 34, 34, 28, 34, 39, 34, 34, 39,\n", + " 34, 42, 29, 43, 34, 43, 34])\n", + "loss= tensor(182.9741, grad_fn=) , actor= tensor(-1.3438, grad_fn=) , critic= tensor(1843.1786, grad_fn=) , return= 176132.32120246434\n", + "probs of actions: tensor([0.3781, 0.1212, 0.3853, 0.3890, 0.0218, 0.3913, 0.0333, 0.0292, 0.0425,\n", + " 0.1178, 0.3930, 0.3921, 0.0112, 0.3893, 0.0342, 0.3842, 0.3832, 0.0344,\n", + " 0.3782, 0.0296, 0.0838, 0.0311, 0.3689, 0.0310, 0.3650],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "466000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 37, 34, 34, 37, 43, 31, 41, 34, 38, 43, 34, 42, 37, 37, 34, 31, 34,\n", + " 34, 41, 43, 34, 34, 34, 47])\n", + "loss= tensor(190.8892, grad_fn=) , actor= tensor(0.2051, grad_fn=) , critic= tensor(1906.8406, grad_fn=) , return= 175657.02419750826\n", + "probs of actions: tensor([0.0217, 0.1235, 0.4028, 0.4066, 0.1224, 0.0319, 0.0299, 0.0520, 0.4109,\n", + " 0.0419, 0.0305, 0.4083, 0.0274, 0.1179, 0.1175, 0.4020, 0.0314, 0.3982,\n", + " 0.3953, 0.0494, 0.0296, 0.3879, 0.3869, 0.3842, 0.0054],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "467000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 35, 43, 34, 34, 34, 34, 29, 34, 37, 38, 27, 29, 41, 22, 39, 22, 34,\n", + " 29, 34, 44, 45, 35, 39, 38])\n", + "loss= tensor(158.4449, grad_fn=) , actor= tensor(-22.9681, grad_fn=) , critic= tensor(1814.1294, grad_fn=) , return= 174496.22670443036\n", + "probs of actions: tensor([0.1284, 0.0195, 0.0346, 0.3911, 0.3947, 0.3963, 0.3972, 0.0777, 0.3982,\n", + " 0.1245, 0.0411, 0.0072, 0.0809, 0.0559, 0.0050, 0.0332, 0.0052, 0.3852,\n", + " 0.0841, 0.3797, 0.0162, 0.0083, 0.0211, 0.0340, 0.0435],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "468000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 13, 42, 29, 37, 37, 34, 31, 37, 27, 38, 34, 29, 37, 34, 34, 39, 34,\n", + " 34, 34, 37, 34, 38, 37, 31])\n", + "loss= tensor(186.6892, grad_fn=) , actor= tensor(9.8709, grad_fn=) , critic= tensor(1768.1826, grad_fn=) , return= 174992.56129038602\n", + "probs of actions: tensor([0.3976, 0.0006, 0.0269, 0.0698, 0.1286, 0.1281, 0.4136, 0.0303, 0.1265,\n", + " 0.0068, 0.0406, 0.4113, 0.0754, 0.1237, 0.4062, 0.4049, 0.0319, 0.4001,\n", + " 0.3988, 0.3963, 0.1203, 0.3912, 0.0428, 0.1190, 0.0335],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "469000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 23, 34, 42, 37, 34, 29, 34, 34, 34, 38, 41, 35, 37, 41, 34, 38, 32,\n", + " 37, 37, 43, 45, 34, 34, 34])\n", + "loss= tensor(184.9763, grad_fn=) , actor= tensor(6.9703, grad_fn=) , critic= tensor(1780.0604, grad_fn=) , return= 176160.28801285618\n", + "probs of actions: tensor([0.1302, 0.0020, 0.4006, 0.0279, 0.1288, 0.4062, 0.0765, 0.4084, 0.4076,\n", + " 0.4072, 0.0422, 0.0522, 0.0186, 0.1240, 0.0516, 0.3974, 0.0432, 0.0210,\n", + " 0.1215, 0.1210, 0.0304, 0.0079, 0.3821, 0.3814, 0.3786],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "470000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 6, 37, 41, 34, 29, 31, 35, 34, 34, 29, 31, 34, 34, 44, 34, 38, 26,\n", + " 42, 34, 39, 34, 37, 37, 41])\n", + "loss= tensor(183.6356, grad_fn=) , actor= tensor(5.2276, grad_fn=) , critic= tensor(1784.0793, grad_fn=) , return= 173764.2183060313\n", + "probs of actions: tensor([1.3056e-01, 1.0708e-04, 1.2989e-01, 5.5706e-02, 4.0011e-01, 7.5482e-02,\n", + " 3.0474e-02, 1.9230e-02, 4.0339e-01, 4.0311e-01, 7.9007e-02, 3.1256e-02,\n", + " 3.9936e-01, 3.9724e-01, 1.5628e-02, 3.9237e-01, 4.2816e-02, 7.4471e-03,\n", + " 2.7314e-02, 3.8379e-01, 3.3430e-02, 3.8010e-01, 1.2000e-01, 1.1953e-01,\n", + " 5.0549e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "471000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 8, 37, 37, 43, 34, 31, 34, 37, 29, 24, 34, 43, 34, 37, 27, 34, 41, 29,\n", + " 41, 47, 35, 34, 41, 34, 34])\n", + "loss= tensor(185.1654, grad_fn=) , actor= tensor(10.5213, grad_fn=) , critic= tensor(1746.4406, grad_fn=) , return= 174581.42933774344\n", + "probs of actions: tensor([2.6206e-04, 1.2707e-01, 1.2671e-01, 3.2435e-02, 4.0883e-01, 3.0019e-02,\n", + " 4.1268e-01, 1.2446e-01, 7.7111e-02, 1.0720e-02, 4.1187e-01, 3.0009e-02,\n", + " 4.0664e-01, 1.2128e-01, 7.4795e-03, 4.0320e-01, 5.2528e-02, 8.2336e-02,\n", + " 5.2297e-02, 4.8561e-03, 2.0710e-02, 3.8946e-01, 5.1887e-02, 3.8346e-01,\n", + " 3.8219e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "472000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 46, 34, 29, 35, 29, 34, 32, 32, 37, 37, 34, 34, 34, 31, 34, 29,\n", + " 34, 34, 34, 37, 34, 34, 37])\n", + "loss= tensor(200.0570, grad_fn=) , actor= tensor(15.7199, grad_fn=) , critic= tensor(1843.3711, grad_fn=) , return= 175267.02696256418\n", + "probs of actions: tensor([0.3907, 0.1264, 0.0198, 0.3993, 0.0816, 0.0200, 0.0833, 0.4060, 0.0198,\n", + " 0.0198, 0.1222, 0.1217, 0.4001, 0.3986, 0.3966, 0.0325, 0.3928, 0.0903,\n", + " 0.3883, 0.3852, 0.3830, 0.1169, 0.3782, 0.3765, 0.1157],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "473000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 29, 43, 43, 34, 34, 22, 34, 42, 38, 34, 34, 24, 34, 34, 44, 34,\n", + " 44, 37, 34, 37, 34, 29, 34])\n", + "loss= tensor(192.5090, grad_fn=) , actor= tensor(13.0872, grad_fn=) , critic= tensor(1794.2180, grad_fn=) , return= 175821.4352347204\n", + "probs of actions: tensor([0.4038, 0.1236, 0.0829, 0.0313, 0.0308, 0.4168, 0.4187, 0.0041, 0.4199,\n", + " 0.0259, 0.0382, 0.4152, 0.4139, 0.0106, 0.4109, 0.4071, 0.0157, 0.4018,\n", + " 0.0159, 0.1154, 0.3966, 0.1146, 0.3913, 0.0956, 0.3871],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "474000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 44, 38, 34, 41, 29, 34, 37, 16, 37, 46, 34, 29, 37, 41, 34, 34, 32,\n", + " 37, 29, 34, 44, 34, 34, 32])\n", + "loss= tensor(185.8473, grad_fn=) , actor= tensor(5.9161, grad_fn=) , critic= tensor(1799.3116, grad_fn=) , return= 175510.5170548043\n", + "probs of actions: tensor([0.4138, 0.0141, 0.0361, 0.4243, 0.0553, 0.0845, 0.4300, 0.1188, 0.0024,\n", + " 0.1176, 0.0181, 0.4246, 0.0898, 0.1158, 0.0518, 0.4177, 0.4168, 0.0198,\n", + " 0.1137, 0.0937, 0.4074, 0.0157, 0.4007, 0.4002, 0.0207],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "475000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 32, 37, 13, 37, 34, 34, 21, 29, 37, 34, 34, 34, 34, 34, 35, 34,\n", + " 32, 10, 43, 38, 24, 31, 31])\n", + "loss= tensor(152.0088, grad_fn=) , actor= tensor(-25.9329, grad_fn=) , critic= tensor(1779.4176, grad_fn=) , return= 173433.67963866107\n", + "probs of actions: tensor([0.0787, 0.4230, 0.0186, 0.1189, 0.0006, 0.1178, 0.4342, 0.4349, 0.0010,\n", + " 0.0849, 0.1154, 0.4309, 0.4298, 0.4279, 0.4259, 0.4238, 0.0203, 0.4191,\n", + " 0.0196, 0.0006, 0.0278, 0.0372, 0.0111, 0.0311, 0.0314],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "476000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 41, 32, 41, 34, 37, 34, 34, 29, 34, 43, 34, 34, 34, 37, 33,\n", + " 30, 41, 37, 34, 28, 39, 31])\n", + "loss= tensor(159.0282, grad_fn=) , actor= tensor(-22.9387, grad_fn=) , critic= tensor(1819.6692, grad_fn=) , return= 175928.84289043513\n", + "probs of actions: tensor([0.4467, 0.4500, 0.0747, 0.0556, 0.0172, 0.0544, 0.4624, 0.1119, 0.4631,\n", + " 0.4630, 0.0800, 0.4608, 0.0279, 0.4551, 0.4545, 0.4521, 0.1083, 0.0044,\n", + " 0.0088, 0.0512, 0.1072, 0.4365, 0.0106, 0.0286, 0.0296],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "477000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 45, 34, 45, 39, 34, 34, 34, 34, 35, 27, 29, 34, 44, 34, 46, 34, 34,\n", + " 35, 34, 34, 39, 34, 34, 37])\n", + "loss= tensor(199.0721, grad_fn=) , actor= tensor(14.7014, grad_fn=) , critic= tensor(1843.7069, grad_fn=) , return= 175901.59279301233\n", + "probs of actions: tensor([0.4610, 0.0058, 0.4674, 0.0056, 0.0272, 0.4768, 0.4784, 0.4787, 0.4784,\n", + " 0.0184, 0.0059, 0.0774, 0.4733, 0.0134, 0.4672, 0.0163, 0.4626, 0.4624,\n", + " 0.0195, 0.4562, 0.4535, 0.0282, 0.4474, 0.4457, 0.1033],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "478000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 44, 24, 39, 34, 34, 34, 37, 34, 43, 34, 34, 37, 37, 19, 43, 42, 34,\n", + " 7, 43, 34, 37, 32, 34, 23])\n", + "loss= tensor(159.3212, grad_fn=) , actor= tensor(-19.0767, grad_fn=) , critic= tensor(1783.9797, grad_fn=) , return= 174945.56743555254\n", + "probs of actions: tensor([1.0074e-02, 1.3484e-02, 1.0677e-02, 2.8416e-02, 4.5448e-01, 4.5682e-01,\n", + " 4.5776e-01, 1.0924e-01, 4.5750e-01, 3.0046e-02, 4.5516e-01, 4.5518e-01,\n", + " 1.0719e-01, 1.0679e-01, 9.1840e-04, 2.9359e-02, 2.4488e-02, 4.4091e-01,\n", + " 2.3548e-04, 2.9320e-02, 4.3078e-01, 1.0460e-01, 2.0270e-02, 4.2656e-01,\n", + " 1.9830e-03], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "479000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 42, 34, 37, 38, 45, 37, 34, 34, 37, 34, 34, 34, 41, 34, 34, 41, 34,\n", + " 34, 32, 34, 34, 34, 39, 37])\n", + "loss= tensor(192.8861, grad_fn=) , actor= tensor(4.6990, grad_fn=) , critic= tensor(1881.8705, grad_fn=) , return= 176151.56713947628\n", + "probs of actions: tensor([0.1138, 0.0248, 0.4545, 0.1124, 0.0340, 0.0056, 0.1111, 0.4649, 0.4651,\n", + " 0.1097, 0.4631, 0.4620, 0.4601, 0.0511, 0.4550, 0.4541, 0.0507, 0.4481,\n", + " 0.4469, 0.0194, 0.4414, 0.4382, 0.4357, 0.0297, 0.1052],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "480000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 29, 41, 34, 37, 34, 37, 34, 28, 34, 29, 34, 37, 37, 39, 34,\n", + " 34, 34, 37, 32, 37, 29, 34])\n", + "loss= tensor(177.9283, grad_fn=) , actor= tensor(-2.7379, grad_fn=) , critic= tensor(1806.6621, grad_fn=) , return= 175690.30950698088\n", + "probs of actions: tensor([0.4611, 0.4646, 0.0718, 0.0723, 0.0542, 0.4769, 0.1043, 0.4789, 0.1034,\n", + " 0.4783, 0.0093, 0.4767, 0.0781, 0.4725, 0.1013, 0.1011, 0.0278, 0.4622,\n", + " 0.4605, 0.4575, 0.1001, 0.0190, 0.0997, 0.0832, 0.4447],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "481000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 45, 34, 34, 34, 34, 34, 39, 29, 29, 30, 29, 34, 34, 29, 34, 34,\n", + " 24, 37, 39, 37, 42, 34, 34])\n", + "loss= tensor(175.5561, grad_fn=) , actor= tensor(-5.6141, grad_fn=) , critic= tensor(1811.7023, grad_fn=) , return= 175057.3560224871\n", + "probs of actions: tensor([0.4704, 0.4739, 0.0053, 0.4810, 0.4856, 0.4872, 0.4882, 0.4885, 0.0267,\n", + " 0.0747, 0.0753, 0.0077, 0.0767, 0.4811, 0.4782, 0.0784, 0.4743, 0.4708,\n", + " 0.0096, 0.0993, 0.0281, 0.0991, 0.0243, 0.4545, 0.4532],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "482000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 39, 34, 27, 34, 41, 41, 34, 37, 39, 34, 35, 31, 41, 34, 38,\n", + " 34, 34, 37, 32, 34, 37, 43])\n", + "loss= tensor(181.3246, grad_fn=) , actor= tensor(-5.8067, grad_fn=) , critic= tensor(1871.3131, grad_fn=) , return= 175400.82739867657\n", + "probs of actions: tensor([0.4785, 0.4820, 0.4874, 0.0258, 0.4932, 0.0052, 0.4976, 0.0534, 0.0530,\n", + " 0.4955, 0.1018, 0.0254, 0.4914, 0.0169, 0.0260, 0.0516, 0.4815, 0.0333,\n", + " 0.4770, 0.4750, 0.0995, 0.0185, 0.4667, 0.0991, 0.0295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "483000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 34, 34, 43, 34, 35, 30, 39, 34, 31, 20, 34, 34, 34, 34, 29, 34,\n", + " 34, 37, 46, 34, 34, 34, 34])\n", + "loss= tensor(200.9666, grad_fn=) , actor= tensor(20.6466, grad_fn=) , critic= tensor(1803.1997, grad_fn=) , return= 175372.0256827827\n", + "probs of actions: tensor([0.4956, 0.0542, 0.5035, 0.5088, 0.0315, 0.5119, 0.0157, 0.0070, 0.0243,\n", + " 0.5133, 0.0257, 0.0026, 0.5106, 0.5062, 0.5042, 0.5020, 0.0768, 0.4975,\n", + " 0.4937, 0.0904, 0.0177, 0.4843, 0.4840, 0.4806, 0.4776],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "484000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 29, 19, 45, 43, 29, 34, 34, 34, 37, 31, 25, 34, 41, 34,\n", + " 29, 34, 38, 34, 34, 34, 38])\n", + "loss= tensor(193.5394, grad_fn=) , actor= tensor(12.2517, grad_fn=) , critic= tensor(1812.8763, grad_fn=) , return= 174638.78098626604\n", + "probs of actions: tensor([0.0936, 0.5170, 0.5233, 0.5273, 0.0690, 0.0006, 0.0044, 0.0297, 0.0715,\n", + " 0.5334, 0.5314, 0.5297, 0.0889, 0.0247, 0.0045, 0.5214, 0.0455, 0.5136,\n", + " 0.0771, 0.5100, 0.0311, 0.5027, 0.5007, 0.4978, 0.0319],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "485000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 41, 41, 34, 34, 34, 34, 34, 49, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 43, 34, 37, 29, 34, 29])\n", + "loss= tensor(175.4266, grad_fn=) , actor= tensor(-6.4235, grad_fn=) , critic= tensor(1818.5015, grad_fn=) , return= 176542.75118740657\n", + "probs of actions: tensor([0.5045, 0.5082, 0.5137, 0.0484, 0.0479, 0.5211, 0.5232, 0.5235, 0.5233,\n", + " 0.5226, 0.0011, 0.5174, 0.5183, 0.5158, 0.5131, 0.5106, 0.5079, 0.5051,\n", + " 0.5022, 0.0287, 0.4952, 0.0890, 0.0809, 0.4887, 0.0818],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "486000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 42, 34, 37, 34, 34, 20, 39, 34, 35, 34, 34, 38, 34, 29, 31, 34, 39,\n", + " 29, 34, 44, 27, 34, 34, 43])\n", + "loss= tensor(181.0156, grad_fn=) , actor= tensor(-5.8997, grad_fn=) , critic= tensor(1869.1531, grad_fn=) , return= 174636.42314448245\n", + "probs of actions: tensor([0.0554, 0.0242, 0.4845, 0.0977, 0.4921, 0.4942, 0.0025, 0.0263, 0.4944,\n", + " 0.0165, 0.4937, 0.4922, 0.0331, 0.4877, 0.0787, 0.0266, 0.4811, 0.0271,\n", + " 0.0808, 0.4737, 0.0148, 0.0064, 0.4659, 0.4616, 0.0303],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "487000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 47, 34, 34, 29, 34, 42, 37, 48, 34, 34, 41, 34, 34, 42, 25, 43, 29,\n", + " 44, 34, 34, 43, 34, 43, 34])\n", + "loss= tensor(191.7723, grad_fn=) , actor= tensor(9.5126, grad_fn=) , critic= tensor(1822.5972, grad_fn=) , return= 175842.83165991335\n", + "probs of actions: tensor([0.0268, 0.0044, 0.4756, 0.4820, 0.0730, 0.4870, 0.0229, 0.0996, 0.0011,\n", + " 0.4853, 0.4868, 0.0498, 0.4822, 0.4812, 0.0230, 0.0050, 0.0315, 0.0811,\n", + " 0.0147, 0.4643, 0.4638, 0.0315, 0.4568, 0.0315, 0.4519],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "488000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 34, 34, 34, 38, 42, 34, 46, 41, 37, 38, 34, 34, 37, 16, 43, 29, 24,\n", + " 34, 34, 34, 43, 41, 37, 34])\n", + "loss= tensor(188.5934, grad_fn=) , actor= tensor(4.0678, grad_fn=) , critic= tensor(1845.2565, grad_fn=) , return= 175382.54867165314\n", + "probs of actions: tensor([0.0370, 0.4549, 0.4620, 0.4657, 0.0307, 0.0235, 0.4699, 0.0190, 0.0538,\n", + " 0.1023, 0.0310, 0.4681, 0.4667, 0.1008, 0.0021, 0.0319, 0.0833, 0.0092,\n", + " 0.4531, 0.4488, 0.4466, 0.0318, 0.0516, 0.0988, 0.4374],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "489000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 37, 29, 41, 37, 43, 34,\n", + " 30, 34, 42, 34, 34, 34, 28])\n", + "loss= tensor(160.3025, grad_fn=) , actor= tensor(-17.8335, grad_fn=) , critic= tensor(1781.3595, grad_fn=) , return= 176217.1225065714\n", + "probs of actions: tensor([0.1053, 0.4550, 0.4607, 0.4643, 0.4668, 0.0744, 0.4699, 0.4695, 0.4694,\n", + " 0.4688, 0.4677, 0.4662, 0.1004, 0.0797, 0.0518, 0.0997, 0.0332, 0.4519,\n", + " 0.0077, 0.4483, 0.0241, 0.4410, 0.4400, 0.4371, 0.0107],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "490000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 37, 43, 41, 43, 38, 34, 34, 29, 34, 31, 34, 34, 38, 43, 34, 37,\n", + " 37, 34, 37, 37, 34, 47, 43])\n", + "loss= tensor(175.7726, grad_fn=) , actor= tensor(-12.5892, grad_fn=) , critic= tensor(1883.6182, grad_fn=) , return= 175338.10718459127\n", + "probs of actions: tensor([0.4517, 0.4551, 0.1034, 0.0365, 0.0544, 0.0356, 0.0308, 0.4685, 0.4688,\n", + " 0.0759, 0.4674, 0.0302, 0.4635, 0.4608, 0.0318, 0.0335, 0.4530, 0.0985,\n", + " 0.0983, 0.4462, 0.0979, 0.0978, 0.4380, 0.0047, 0.0334],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "491000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 37, 34, 37, 34, 43, 34, 37, 34, 34, 34, 34, 34, 37, 34, 32, 34, 30,\n", + " 42, 34, 34, 37, 34, 34, 34])\n", + "loss= tensor(187.9886, grad_fn=) , actor= tensor(3.9041, grad_fn=) , critic= tensor(1840.8445, grad_fn=) , return= 176134.86242699975\n", + "probs of actions: tensor([0.1043, 0.1038, 0.4612, 0.1028, 0.4676, 0.0355, 0.4693, 0.1011, 0.4705,\n", + " 0.4704, 0.4693, 0.4678, 0.4659, 0.0989, 0.4612, 0.0192, 0.4573, 0.0073,\n", + " 0.0243, 0.4477, 0.4469, 0.0973, 0.4409, 0.4388, 0.4361],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "492000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 43, 34, 39, 43, 34, 37, 34, 31, 34, 34, 34, 32, 29, 34, 34,\n", + " 34, 44, 32, 34, 34, 34, 34])\n", + "loss= tensor(191.7288, grad_fn=) , actor= tensor(7.4581, grad_fn=) , critic= tensor(1842.7068, grad_fn=) , return= 175963.34899797145\n", + "probs of actions: tensor([0.4640, 0.4675, 0.4727, 0.0362, 0.4777, 0.0275, 0.0348, 0.4808, 0.0974,\n", + " 0.4811, 0.0297, 0.4791, 0.4766, 0.4745, 0.0179, 0.0792, 0.4680, 0.4645,\n", + " 0.4620, 0.0135, 0.0187, 0.4549, 0.4515, 0.4487, 0.4460],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "493000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 34, 34, 46, 42, 34, 43, 29, 34, 41, 29, 34, 33, 41, 37, 37, 31,\n", + " 35, 31, 34, 34, 43, 34, 34])\n", + "loss= tensor(194.1644, grad_fn=) , actor= tensor(9.4582, grad_fn=) , critic= tensor(1847.0629, grad_fn=) , return= 176067.44312251103\n", + "probs of actions: tensor([0.0326, 0.4512, 0.4572, 0.4610, 0.0210, 0.0251, 0.4653, 0.0369, 0.0779,\n", + " 0.4671, 0.0524, 0.0799, 0.4627, 0.0038, 0.0516, 0.0947, 0.0945, 0.0327,\n", + " 0.0204, 0.0331, 0.4432, 0.4399, 0.0349, 0.4340, 0.4332],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "494000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 34, 22, 34, 43, 45, 34, 20, 46, 34, 34, 34, 34, 34, 37, 34, 34, 37,\n", + " 25, 37, 45, 34, 34, 38, 34])\n", + "loss= tensor(187.1433, grad_fn=) , actor= tensor(8.0221, grad_fn=) , critic= tensor(1791.2120, grad_fn=) , return= 175055.51595160068\n", + "probs of actions: tensor([0.0308, 0.4430, 0.0040, 0.4527, 0.0402, 0.0056, 0.4551, 0.0025, 0.0204,\n", + " 0.4547, 0.4560, 0.4544, 0.4526, 0.4506, 0.0921, 0.4459, 0.4442, 0.0914,\n", + " 0.0057, 0.0910, 0.0064, 0.4299, 0.4295, 0.0340, 0.4235],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "495000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 34, 34, 37, 34, 34, 38, 46, 24, 34, 34, 46, 34, 34, 34, 35, 34, 34,\n", + " 41, 34, 34, 34, 37, 31, 34])\n", + "loss= tensor(187.8078, grad_fn=) , actor= tensor(6.3958, grad_fn=) , critic= tensor(1814.1204, grad_fn=) , return= 175958.41881004832\n", + "probs of actions: tensor([0.0315, 0.4470, 0.4516, 0.0936, 0.4576, 0.4597, 0.0304, 0.0201, 0.0098,\n", + " 0.4621, 0.4596, 0.0196, 0.4548, 0.4549, 0.4526, 0.0200, 0.4477, 0.4454,\n", + " 0.0538, 0.4392, 0.4380, 0.4350, 0.0886, 0.0350, 0.4276],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "496000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 34, 29, 37, 34, 34, 34, 34, 34, 34, 32, 34, 29, 29, 34, 42, 29, 29,\n", + " 41, 34, 24, 29, 34, 34, 34])\n", + "loss= tensor(184.1691, grad_fn=) , actor= tensor(-1.0657, grad_fn=) , critic= tensor(1852.3477, grad_fn=) , return= 174978.79006594612\n", + "probs of actions: tensor([0.0219, 0.4536, 0.0748, 0.0955, 0.4679, 0.4701, 0.4713, 0.4717, 0.4717,\n", + " 0.4713, 0.0178, 0.4690, 0.0816, 0.0822, 0.4632, 0.0242, 0.0840, 0.0843,\n", + " 0.0522, 0.4492, 0.0103, 0.0860, 0.4423, 0.4392, 0.4371],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "497000 adversary: AdversaryModes.myopic\n", + " actions: tensor([46, 41, 34, 34, 34, 34, 34, 34, 34, 29, 25, 34, 34, 24, 29, 34, 39, 34,\n", + " 34, 31, 38, 34, 29, 30, 34])\n", + "loss= tensor(169.9603, grad_fn=) , actor= tensor(-13.0239, grad_fn=) , critic= tensor(1829.8413, grad_fn=) , return= 175124.9068798681\n", + "probs of actions: tensor([0.0228, 0.0571, 0.4446, 0.4495, 0.4521, 0.4538, 0.4548, 0.4552, 0.4552,\n", + " 0.0826, 0.0053, 0.4530, 0.4500, 0.0100, 0.0857, 0.4442, 0.0305, 0.4385,\n", + " 0.4371, 0.0348, 0.0334, 0.4285, 0.0892, 0.0078, 0.4216],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "498000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 31, 31, 34, 29, 37, 34, 34, 37, 43, 34, 32, 34, 42, 38, 44, 29, 46,\n", + " 34, 37, 34, 41, 34, 22, 41])\n", + "loss= tensor(174.2945, grad_fn=) , actor= tensor(-8.1133, grad_fn=) , critic= tensor(1824.0780, grad_fn=) , return= 175775.4741503169\n", + "probs of actions: tensor([0.0321, 0.0325, 0.0322, 0.4511, 0.0777, 0.1001, 0.4555, 0.4564, 0.0989,\n", + " 0.0348, 0.4538, 0.0190, 0.4521, 0.0252, 0.0324, 0.0137, 0.0854, 0.0200,\n", + " 0.4369, 0.0958, 0.4333, 0.0489, 0.4275, 0.0048, 0.0488],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "499000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 31, 34, 43, 34, 29, 37, 34, 34, 34, 41, 29, 35, 41, 29, 37, 34, 29,\n", + " 37, 13, 31, 41, 34, 34, 41])\n", + "loss= tensor(179.4912, grad_fn=) , actor= tensor(-9.9995, grad_fn=) , critic= tensor(1894.9069, grad_fn=) , return= 174339.769065684\n", + "probs of actions: tensor([0.0375, 0.0345, 0.4524, 0.0353, 0.4571, 0.0738, 0.1000, 0.4611, 0.4616,\n", + " 0.4612, 0.0513, 0.0779, 0.0189, 0.0506, 0.0797, 0.0970, 0.4479, 0.0812,\n", + " 0.0964, 0.0006, 0.0367, 0.0498, 0.4311, 0.4305, 0.0497],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "500000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 41, 38, 34, 34, 34, 32, 37, 37, 41, 34, 34, 34, 34, 41, 26, 43, 29,\n", + " 34, 24, 34, 38, 34, 37, 34])\n", + "loss= tensor(188.8793, grad_fn=) , actor= tensor(2.9498, grad_fn=) , critic= tensor(1859.2952, grad_fn=) , return= 175657.8523627844\n", + "probs of actions: tensor([0.1009, 0.0563, 0.0308, 0.4616, 0.4649, 0.4666, 0.0179, 0.0979, 0.0975,\n", + " 0.0519, 0.4657, 0.4654, 0.4634, 0.4613, 0.0507, 0.0057, 0.0316, 0.0806,\n", + " 0.4506, 0.0099, 0.4452, 0.0328, 0.4381, 0.0940, 0.4337],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "501000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 39, 37, 37, 34, 39, 34, 31, 46, 34, 28, 31, 37, 29, 29, 34,\n", + " 34, 24, 37, 34, 37, 41, 34])\n", + "loss= tensor(188.2494, grad_fn=) , actor= tensor(3.5211, grad_fn=) , critic= tensor(1847.2832, grad_fn=) , return= 175031.0122381054\n", + "probs of actions: tensor([0.4362, 0.4397, 0.0719, 0.0323, 0.1034, 0.1030, 0.4535, 0.0319, 0.4536,\n", + " 0.0366, 0.0207, 0.4498, 0.0102, 0.0374, 0.0996, 0.0800, 0.0805, 0.4392,\n", + " 0.4359, 0.0098, 0.0982, 0.4275, 0.0980, 0.0489, 0.4208],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "502000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 39, 37, 45, 34, 37, 37, 34, 34, 34, 42, 34, 34, 37, 46, 44, 34, 37,\n", + " 38, 37, 34, 34, 34, 30, 34])\n", + "loss= tensor(190.9467, grad_fn=) , actor= tensor(7.3834, grad_fn=) , critic= tensor(1835.6326, grad_fn=) , return= 176808.6866234646\n", + "probs of actions: tensor([0.0724, 0.0324, 0.1068, 0.0055, 0.4445, 0.1055, 0.1051, 0.4489, 0.4493,\n", + " 0.4489, 0.0258, 0.4454, 0.4450, 0.1024, 0.0203, 0.0143, 0.4358, 0.1014,\n", + " 0.0333, 0.1009, 0.4266, 0.4243, 0.4215, 0.0079, 0.4168],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "503000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 31, 34, 29, 37, 34, 34, 34, 37, 42, 34, 35, 24, 37, 48, 24, 34, 29,\n", + " 39, 34, 29, 34, 34, 37, 29])\n", + "loss= tensor(183.9790, grad_fn=) , actor= tensor(4.4404, grad_fn=) , critic= tensor(1795.3860, grad_fn=) , return= 175299.07128355413\n", + "probs of actions: tensor([0.0701, 0.0357, 0.4627, 0.0714, 0.1014, 0.4696, 0.4710, 0.4713, 0.0999,\n", + " 0.0252, 0.4684, 0.0184, 0.0088, 0.0982, 0.0012, 0.0091, 0.4588, 0.0800,\n", + " 0.0293, 0.4478, 0.0813, 0.4440, 0.4403, 0.0965, 0.0827],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "504000 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 34, 34, 34, 39, 34, 34, 43, 25, 34, 28, 34, 48, 38, 41, 34, 46, 39,\n", + " 40, 29, 34, 37, 37, 34, 41])\n", + "loss= tensor(183.6846, grad_fn=) , actor= tensor(2.9433, grad_fn=) , critic= tensor(1807.4137, grad_fn=) , return= 175239.45463567128\n", + "probs of actions: tensor([0.0036, 0.4697, 0.4728, 0.4765, 0.0281, 0.4798, 0.4814, 0.0292, 0.0048,\n", + " 0.4820, 0.0093, 0.4785, 0.0012, 0.0318, 0.0476, 0.4686, 0.0182, 0.0286,\n", + " 0.0077, 0.0771, 0.4571, 0.1008, 0.1006, 0.4474, 0.0471],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "505000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 37, 34, 31, 39, 29, 34, 39, 34, 34, 34, 27, 32, 25, 34, 39, 34,\n", + " 37, 28, 38, 34, 34, 39, 34])\n", + "loss= tensor(180.8233, grad_fn=) , actor= tensor(-0.9582, grad_fn=) , critic= tensor(1817.8158, grad_fn=) , return= 175108.7478866129\n", + "probs of actions: tensor([0.4640, 0.4673, 0.1064, 0.4757, 0.0344, 0.0285, 0.0678, 0.4822, 0.0284,\n", + " 0.4798, 0.4796, 0.4779, 0.0061, 0.0199, 0.0051, 0.4699, 0.0291, 0.4629,\n", + " 0.1010, 0.0101, 0.0328, 0.4521, 0.4504, 0.0300, 0.4445],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "506000 adversary: AdversaryModes.myopic\n", + " actions: tensor([45, 34, 38, 34, 34, 34, 34, 37, 34, 34, 29, 34, 34, 34, 46, 34, 34, 34,\n", + " 34, 24, 34, 20, 39, 34, 37])\n", + "loss= tensor(171.7909, grad_fn=) , actor= tensor(-17.2629, grad_fn=) , critic= tensor(1890.5388, grad_fn=) , return= 175055.04857217884\n", + "probs of actions: tensor([0.0053, 0.4583, 0.0326, 0.4690, 0.4721, 0.4737, 0.4745, 0.1042, 0.4740,\n", + " 0.4739, 0.0719, 0.4717, 0.4689, 0.4668, 0.0184, 0.4605, 0.4606, 0.4577,\n", + " 0.4548, 0.0097, 0.4501, 0.0033, 0.0304, 0.4389, 0.0998],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "507000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 31, 25, 34, 41, 30, 34, 37, 39, 34, 37, 41, 29, 38, 35, 39, 47, 42,\n", + " 34, 34, 37, 39, 37, 29, 22])\n", + "loss= tensor(170.8671, grad_fn=) , actor= tensor(-3.6141, grad_fn=) , critic= tensor(1744.8121, grad_fn=) , return= 176925.8782599267\n", + "probs of actions: tensor([0.4562, 0.0345, 0.0047, 0.4693, 0.0519, 0.0071, 0.4737, 0.1028, 0.0303,\n", + " 0.4719, 0.1017, 0.0493, 0.0732, 0.0326, 0.0176, 0.0307, 0.0038, 0.0242,\n", + " 0.4536, 0.4519, 0.0994, 0.0316, 0.0991, 0.0782, 0.0045],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "508000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 41, 34, 34, 41, 34, 38, 29, 31, 34, 34, 34, 34, 34, 34, 34, 44,\n", + " 37, 46, 34, 24, 31, 34, 34])\n", + "loss= tensor(177.5112, grad_fn=) , actor= tensor(-5.7081, grad_fn=) , critic= tensor(1832.1929, grad_fn=) , return= 175962.28571352735\n", + "probs of actions: tensor([0.4572, 0.1072, 0.0532, 0.4681, 0.4717, 0.0513, 0.4731, 0.0317, 0.0707,\n", + " 0.0350, 0.4727, 0.4706, 0.4687, 0.4666, 0.4643, 0.4621, 0.4596, 0.0138,\n", + " 0.1015, 0.0196, 0.4481, 0.0096, 0.0379, 0.4406, 0.4377],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "509000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 29, 34, 34, 29, 34, 34, 40, 34, 34, 31, 34, 34, 34, 23, 31, 41, 34,\n", + " 34, 34, 34, 31, 31, 34, 37])\n", + "loss= tensor(179.4925, grad_fn=) , actor= tensor(-3.7758, grad_fn=) , critic= tensor(1832.6833, grad_fn=) , return= 174917.1030976171\n", + "probs of actions: tensor([0.1107, 0.0639, 0.4586, 0.4615, 0.0654, 0.4662, 0.4664, 0.0067, 0.4656,\n", + " 0.4662, 0.0358, 0.4638, 0.4614, 0.4594, 0.0013, 0.0369, 0.0509, 0.4487,\n", + " 0.4479, 0.4452, 0.4424, 0.0385, 0.0386, 0.4345, 0.1028],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "510000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 38, 29, 34, 32, 39, 34, 41, 34, 37, 34, 34, 26, 34, 42, 34, 41,\n", + " 34, 32, 34, 32, 37, 42, 34])\n", + "loss= tensor(183.9114, grad_fn=) , actor= tensor(0.2321, grad_fn=) , critic= tensor(1836.7928, grad_fn=) , return= 175672.79113360174\n", + "probs of actions: tensor([0.4496, 0.0234, 0.0336, 0.0629, 0.4651, 0.0203, 0.0319, 0.4668, 0.0526,\n", + " 0.4661, 0.1055, 0.4643, 0.4630, 0.0058, 0.4598, 0.0227, 0.4528, 0.0508,\n", + " 0.4485, 0.0216, 0.4445, 0.0219, 0.1020, 0.0235, 0.4330],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "511000 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 7, 41, 34, 34, 28, 38, 29, 29, 34, 38, 24, 34, 40, 34, 34, 34, 34, 34,\n", + " 34, 38, 31, 29, 35, 26, 34])\n", + "loss= tensor(177.8116, grad_fn=) , actor= tensor(-0.2799, grad_fn=) , critic= tensor(1780.9148, grad_fn=) , return= 174181.91415654923\n", + "probs of actions: tensor([2.1894e-04, 5.7340e-02, 4.5593e-01, 4.6116e-01, 9.9164e-03, 3.3213e-02,\n", + " 6.5929e-02, 6.6539e-02, 4.6742e-01, 3.3513e-02, 8.6273e-03, 4.6498e-01,\n", + " 7.2338e-03, 4.5912e-01, 4.5817e-01, 4.5592e-01, 4.5354e-01, 4.5107e-01,\n", + " 4.4853e-01, 3.5398e-02, 3.6581e-02, 7.4113e-02, 1.9336e-02, 6.6758e-03,\n", + " 4.3358e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "512000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 28, 41, 34, 38, 34, 31, 35, 47, 46, 34, 25, 46, 29, 29, 31, 46,\n", + " 37, 31, 34, 37, 29, 34, 41])\n", + "loss= tensor(194.6074, grad_fn=) , actor= tensor(10.3246, grad_fn=) , critic= tensor(1842.8289, grad_fn=) , return= 174980.1916510541\n", + "probs of actions: tensor([0.4599, 0.0608, 0.0092, 0.0542, 0.4739, 0.0325, 0.4773, 0.0321, 0.0169,\n", + " 0.0031, 0.0194, 0.4741, 0.0046, 0.0192, 0.0682, 0.0685, 0.0339, 0.0192,\n", + " 0.1077, 0.0347, 0.4555, 0.1068, 0.0719, 0.4475, 0.0498],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "513000 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 34, 34, 34, 34, 13, 37, 34, 34, 34, 40, 22, 37, 37, 34, 34, 34, 34,\n", + " 34, 34, 27, 34, 22, 34, 37])\n", + "loss= tensor(179.5388, grad_fn=) , actor= tensor(-2.1622, grad_fn=) , critic= tensor(1817.0099, grad_fn=) , return= 174017.85787481949\n", + "probs of actions: tensor([9.1354e-03, 4.8844e-01, 4.9272e-01, 4.9664e-01, 4.9941e-01, 3.5898e-04,\n", + " 1.0630e-01, 5.0176e-01, 5.0239e-01, 5.0195e-01, 6.4466e-03, 3.2972e-03,\n", + " 1.0429e-01, 1.0402e-01, 4.9269e-01, 4.9110e-01, 4.8859e-01, 4.8598e-01,\n", + " 4.8330e-01, 4.8055e-01, 6.2776e-03, 4.7572e-01, 4.0303e-03, 4.7037e-01,\n", + " 1.0171e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "514000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 38, 34, 34, 34, 46, 43, 37, 34, 34, 34, 34, 31, 34,\n", + " 29, 43, 38, 41, 37, 34, 29])\n", + "loss= tensor(164.6962, grad_fn=) , actor= tensor(-15.0021, grad_fn=) , critic= tensor(1796.9832, grad_fn=) , return= 176487.6804671122\n", + "probs of actions: tensor([0.4769, 0.4802, 0.4855, 0.4894, 0.4921, 0.0311, 0.4942, 0.4952, 0.4950,\n", + " 0.0176, 0.0282, 0.1072, 0.4903, 0.4885, 0.4860, 0.4837, 0.0326, 0.4790,\n", + " 0.0720, 0.0276, 0.0336, 0.0518, 0.1045, 0.4631, 0.0744],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "515000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 34, 43, 29, 41, 34, 34, 44, 34, 34, 38, 34, 34, 39, 16, 28, 29, 34,\n", + " 29, 41, 34, 39, 45, 42, 37])\n", + "loss= tensor(165.4387, grad_fn=) , actor= tensor(-18.8927, grad_fn=) , critic= tensor(1843.3132, grad_fn=) , return= 174658.32023722227\n", + "probs of actions: tensor([0.0200, 0.4844, 0.0306, 0.0642, 0.0568, 0.4990, 0.5012, 0.0103, 0.4999,\n", + " 0.5012, 0.0309, 0.4980, 0.4968, 0.0289, 0.0016, 0.0087, 0.0724, 0.4848,\n", + " 0.0734, 0.0529, 0.4756, 0.0300, 0.0050, 0.0197, 0.1038],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "516000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 34, 34, 41, 34, 28, 34, 34, 43, 34, 34, 34, 34, 34, 43, 34, 28,\n", + " 34, 31, 34, 34, 34, 37, 34])\n", + "loss= tensor(188.8885, grad_fn=) , actor= tensor(4.1680, grad_fn=) , critic= tensor(1847.2047, grad_fn=) , return= 175718.8053322649\n", + "probs of actions: tensor([0.4801, 0.0589, 0.4875, 0.4927, 0.0567, 0.4961, 0.0083, 0.4995, 0.4985,\n", + " 0.0280, 0.4957, 0.4959, 0.4939, 0.4918, 0.4896, 0.0274, 0.4836, 0.0089,\n", + " 0.4809, 0.0328, 0.4746, 0.4714, 0.4689, 0.1067, 0.4636],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "517000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 43, 43, 34, 34, 25, 42, 34, 34, 37, 34, 39, 34, 34, 37, 31,\n", + " 34, 37, 34, 29, 31, 29, 34])\n", + "loss= tensor(185.6350, grad_fn=) , actor= tensor(0.2564, grad_fn=) , critic= tensor(1853.7865, grad_fn=) , return= 176023.43995260302\n", + "probs of actions: tensor([0.4642, 0.4673, 0.4724, 0.0302, 0.0297, 0.4790, 0.4813, 0.0041, 0.0194,\n", + " 0.4794, 0.4798, 0.1126, 0.4761, 0.0310, 0.4716, 0.4703, 0.1111, 0.0330,\n", + " 0.4632, 0.1102, 0.4569, 0.0787, 0.0340, 0.0797, 0.4470],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "518000 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 34, 31, 34, 34, 38, 42, 34, 34, 29, 34, 37, 37, 29, 34, 34, 34, 28,\n", + " 34, 34, 14, 37, 37, 34, 33])\n", + "loss= tensor(168.0482, grad_fn=) , actor= tensor(-18.2312, grad_fn=) , critic= tensor(1862.7942, grad_fn=) , return= 174894.06553978892\n", + "probs of actions: tensor([0.0155, 0.4485, 0.0307, 0.4575, 0.4596, 0.0333, 0.0204, 0.4612, 0.4623,\n", + " 0.0715, 0.4612, 0.1169, 0.1166, 0.0741, 0.4542, 0.4510, 0.4488, 0.0095,\n", + " 0.4447, 0.4411, 0.0008, 0.1135, 0.1133, 0.4305, 0.0054],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "519000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 34, 39, 43, 34, 34, 45, 41, 41, 34, 31, 34, 34, 29, 34, 37, 28,\n", + " 34, 34, 31, 34, 34, 41, 37])\n", + "loss= tensor(194.8386, grad_fn=) , actor= tensor(5.1494, grad_fn=) , critic= tensor(1896.8916, grad_fn=) , return= 175657.02730534307\n", + "probs of actions: tensor([0.4454, 0.0664, 0.4521, 0.0314, 0.0346, 0.4595, 0.4618, 0.0043, 0.0620,\n", + " 0.0617, 0.4597, 0.0316, 0.4576, 0.4551, 0.0744, 0.4515, 0.1161, 0.0092,\n", + " 0.4445, 0.4408, 0.0339, 0.4363, 0.4333, 0.0592, 0.1139],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "520000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 38, 32, 37, 34, 32, 34, 38, 20, 43, 37, 29, 39, 25, 35, 34, 42, 34,\n", + " 41, 34, 31, 29, 34, 34, 37])\n", + "loss= tensor(204.6050, grad_fn=) , actor= tensor(22.7389, grad_fn=) , critic= tensor(1818.6605, grad_fn=) , return= 175027.92068046535\n", + "probs of actions: tensor([0.0185, 0.0324, 0.0182, 0.1232, 0.4566, 0.0180, 0.4597, 0.0322, 0.0020,\n", + " 0.0320, 0.1206, 0.0751, 0.0312, 0.0045, 0.0165, 0.4481, 0.0209, 0.4429,\n", + " 0.0613, 0.4386, 0.0329, 0.0807, 0.4321, 0.4288, 0.1160],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "521000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 37, 42, 34, 34, 34, 29, 37, 34, 43, 34, 34, 46, 31, 35, 34, 34, 34,\n", + " 34, 34, 34, 29, 34, 29, 29])\n", + "loss= tensor(188.5279, grad_fn=) , actor= tensor(5.6509, grad_fn=) , critic= tensor(1828.7700, grad_fn=) , return= 176256.1501998997\n", + "probs of actions: tensor([0.0680, 0.1258, 0.0215, 0.4457, 0.4494, 0.4510, 0.0713, 0.1238, 0.4516,\n", + " 0.0331, 0.4496, 0.4497, 0.0179, 0.0308, 0.0167, 0.4420, 0.4399, 0.4375,\n", + " 0.4351, 0.4327, 0.4302, 0.0803, 0.4258, 0.0812, 0.0816],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "522000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 47, 38, 40, 41, 34, 34, 34, 31, 29, 41, 34, 33, 34, 34, 38, 37,\n", + " 29, 44, 39, 34, 34, 29, 34])\n", + "loss= tensor(201.4064, grad_fn=) , actor= tensor(16.7799, grad_fn=) , critic= tensor(1846.2649, grad_fn=) , return= 176451.11387931564\n", + "probs of actions: tensor([0.4357, 0.0377, 0.0032, 0.0327, 0.0058, 0.0671, 0.4511, 0.4525, 0.4523,\n", + " 0.0282, 0.0727, 0.0642, 0.4467, 0.0045, 0.4442, 0.4419, 0.0342, 0.1227,\n", + " 0.0774, 0.0121, 0.0314, 0.4279, 0.4261, 0.0796, 0.4213],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "523000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 37, 29, 37, 34, 25, 41, 31, 31, 25, 43, 34, 34, 34, 29,\n", + " 34, 34, 37, 34, 32, 34, 29])\n", + "loss= tensor(184.1649, grad_fn=) , actor= tensor(4.9499, grad_fn=) , critic= tensor(1792.1500, grad_fn=) , return= 175470.11525646597\n", + "probs of actions: tensor([0.1232, 0.4597, 0.4654, 0.4690, 0.1218, 0.0669, 0.1210, 0.4740, 0.0042,\n", + " 0.0616, 0.0269, 0.0269, 0.0044, 0.0327, 0.4641, 0.4640, 0.4616, 0.0745,\n", + " 0.4573, 0.4538, 0.1161, 0.4486, 0.0191, 0.4444, 0.0777],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "524000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 31, 34, 29, 34, 34, 37, 34, 34, 41, 34, 34, 34, 39, 34, 43, 34, 37,\n", + " 37, 29, 35, 37, 31, 37, 39])\n", + "loss= tensor(158.5533, grad_fn=) , actor= tensor(-25.3099, grad_fn=) , critic= tensor(1838.6316, grad_fn=) , return= 175521.53236800514\n", + "probs of actions: tensor([0.4638, 0.0256, 0.4726, 0.0659, 0.4791, 0.4801, 0.1178, 0.4811, 0.4816,\n", + " 0.0615, 0.4792, 0.4790, 0.4771, 0.0294, 0.4724, 0.0322, 0.4675, 0.1139,\n", + " 0.1137, 0.0757, 0.0179, 0.1129, 0.0287, 0.1124, 0.0309],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "525000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 43, 34, 41, 29, 29, 34, 34, 34, 34, 34, 38, 34, 27, 37, 34, 37, 34,\n", + " 12, 37, 39, 34, 41, 46, 34])\n", + "loss= tensor(168.9035, grad_fn=) , actor= tensor(-15.1215, grad_fn=) , critic= tensor(1840.2496, grad_fn=) , return= 174439.3698779358\n", + "probs of actions: tensor([0.1260, 0.0368, 0.4510, 0.0679, 0.0704, 0.0710, 0.4617, 0.4613, 0.4612,\n", + " 0.4607, 0.4598, 0.0335, 0.4563, 0.0047, 0.1205, 0.4500, 0.1198, 0.4459,\n", + " 0.0005, 0.1186, 0.0312, 0.4353, 0.0619, 0.0171, 0.4287],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "526000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 34, 34, 37, 34, 31, 24, 34, 34, 34, 34, 38, 29, 34, 38, 34, 34, 34,\n", + " 43, 34, 34, 34, 31, 34, 34])\n", + "loss= tensor(189.8580, grad_fn=) , actor= tensor(8.7530, grad_fn=) , critic= tensor(1811.0496, grad_fn=) , return= 175583.96912074555\n", + "probs of actions: tensor([0.0359, 0.4527, 0.4596, 0.1227, 0.4654, 0.0253, 0.0075, 0.4700, 0.4685,\n", + " 0.4682, 0.4673, 0.0324, 0.0775, 0.4631, 0.0331, 0.4578, 0.4564, 0.4540,\n", + " 0.0304, 0.4479, 0.4472, 0.4444, 0.0286, 0.4395, 0.4366],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "527000 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 34, 25, 38, 35, 34, 41, 31, 6, 31, 34, 29, 38, 42, 34, 34, 37, 34,\n", + " 34, 30, 34, 34, 37, 34, 32])\n", + "loss= tensor(194.8922, grad_fn=) , actor= tensor(21.1149, grad_fn=) , critic= tensor(1737.7729, grad_fn=) , return= 174082.9542665731\n", + "probs of actions: tensor([4.8985e-03, 4.7615e-01, 4.2240e-03, 3.2890e-02, 1.7189e-02, 4.8781e-01,\n", + " 6.6917e-02, 2.6177e-02, 8.5141e-05, 2.6030e-02, 4.8729e-01, 7.1654e-02,\n", + " 3.3639e-02, 1.9383e-02, 4.7949e-01, 4.7882e-01, 1.0741e-01, 4.7337e-01,\n", + " 4.7140e-01, 6.8326e-03, 4.6642e-01, 4.6301e-01, 1.0606e-01, 4.5785e-01,\n", + " 1.8566e-02], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "528000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 48, 41, 37, 36, 34, 37, 34, 38, 34, 34, 36, 41, 34, 37, 34, 34,\n", + " 41, 34, 34, 34, 29, 34, 29])\n", + "loss= tensor(205.1631, grad_fn=) , actor= tensor(20.3083, grad_fn=) , critic= tensor(1848.5479, grad_fn=) , return= 176865.48541713753\n", + "probs of actions: tensor([0.4841, 0.4875, 0.0009, 0.0686, 0.1110, 0.0029, 0.5021, 0.1097, 0.5022,\n", + " 0.0332, 0.5008, 0.5000, 0.0030, 0.0638, 0.4932, 0.1071, 0.4893, 0.4873,\n", + " 0.0630, 0.4810, 0.4797, 0.4768, 0.0728, 0.4719, 0.0737],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "529000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 46, 37, 39, 34, 34, 29, 37, 34, 34, 34, 29, 41, 34, 34, 34, 34,\n", + " 29, 34, 34, 34, 43, 34, 31])\n", + "loss= tensor(181.4294, grad_fn=) , actor= tensor(-1.5997, grad_fn=) , critic= tensor(1830.2908, grad_fn=) , return= 175903.88169499137\n", + "probs of actions: tensor([0.5032, 0.5067, 0.0154, 0.1051, 0.0269, 0.5200, 0.5219, 0.0621, 0.1030,\n", + " 0.5211, 0.5206, 0.5191, 0.0653, 0.0629, 0.5118, 0.5110, 0.5085, 0.5058,\n", + " 0.0688, 0.5010, 0.4972, 0.4947, 0.0263, 0.4885, 0.0295],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "530000 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 31, 34, 28, 34, 34, 34, 40, 42, 34, 29, 34, 34, 37, 34, 35, 42, 37,\n", + " 34, 34, 34, 46, 46, 34, 34])\n", + "loss= tensor(187.7766, grad_fn=) , actor= tensor(10.5991, grad_fn=) , critic= tensor(1771.7750, grad_fn=) , return= 175686.82895770628\n", + "probs of actions: tensor([0.0060, 0.0248, 0.5381, 0.0074, 0.5453, 0.5464, 0.5476, 0.0054, 0.0168,\n", + " 0.5464, 0.0596, 0.5458, 0.5431, 0.0981, 0.5383, 0.0172, 0.0172, 0.0976,\n", + " 0.5289, 0.5265, 0.5234, 0.0135, 0.0136, 0.5145, 0.5137],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "531000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 39, 34, 43, 37, 34, 37, 34, 29, 34, 34, 34, 34, 35, 34, 31,\n", + " 25, 34, 34, 37, 34, 43, 34])\n", + "loss= tensor(180.0551, grad_fn=) , actor= tensor(-5.7835, grad_fn=) , critic= tensor(1858.3859, grad_fn=) , return= 175362.20644039492\n", + "probs of actions: tensor([0.5428, 0.5466, 0.5524, 0.0237, 0.5589, 0.0260, 0.0986, 0.5633, 0.0978,\n", + " 0.5629, 0.0535, 0.5615, 0.5589, 0.5569, 0.5547, 0.0166, 0.5498, 0.0257,\n", + " 0.0044, 0.5426, 0.5380, 0.0957, 0.5328, 0.0245, 0.5270],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "532000 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 34, 34, 34, 38, 31, 34, 37, 34, 43, 34, 34, 34, 39, 34, 34, 34, 37,\n", + " 34, 34, 34, 29, 34, 37, 14])\n", + "loss= tensor(165.4991, grad_fn=) , actor= tensor(-11.9247, grad_fn=) , critic= tensor(1774.2373, grad_fn=) , return= 176459.60650237874\n", + "probs of actions: tensor([0.0015, 0.5646, 0.5681, 0.5724, 0.0276, 0.0217, 0.5793, 0.0983, 0.5789,\n", + " 0.0229, 0.5767, 0.5770, 0.5751, 0.0223, 0.5699, 0.5685, 0.5659, 0.0963,\n", + " 0.5600, 0.5578, 0.5548, 0.0582, 0.5496, 0.0959, 0.0007],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "533000 adversary: AdversaryModes.myopic\n", + " actions: tensor([40, 29, 42, 15, 34, 30, 37, 34, 34, 32, 34, 34, 34, 34, 34, 34, 29, 39,\n", + " 34, 46, 34, 28, 46, 37, 34])\n", + "loss= tensor(183.3532, grad_fn=) , actor= tensor(6.0716, grad_fn=) , critic= tensor(1772.8158, grad_fn=) , return= 174663.20193005164\n", + "probs of actions: tensor([5.7707e-03, 4.7734e-02, 1.6618e-02, 3.1701e-04, 5.7643e-01, 4.9192e-03,\n", + " 9.7471e-02, 5.7799e-01, 5.7857e-01, 1.2313e-02, 5.7742e-01, 5.7558e-01,\n", + " 5.7383e-01, 5.7175e-01, 5.6942e-01, 5.6711e-01, 5.4635e-02, 2.3898e-02,\n", + " 5.5808e-01, 1.2342e-02, 5.5195e-01, 7.4942e-03, 1.2506e-02, 9.5138e-02,\n", + " 5.4295e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "534000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 38, 38, 34, 34, 34, 34, 37, 46, 40, 34, 32, 39, 31, 37, 34, 34, 32,\n", + " 34, 41, 34, 34, 34, 38, 46])\n", + "loss= tensor(186.8115, grad_fn=) , actor= tensor(-3.2062, grad_fn=) , critic= tensor(1900.1766, grad_fn=) , return= 175216.07332726612\n", + "probs of actions: tensor([0.5591, 0.0294, 0.0292, 0.5721, 0.5757, 0.5776, 0.5790, 0.0955, 0.0122,\n", + " 0.0055, 0.5772, 0.0126, 0.0249, 0.0223, 0.0939, 0.5668, 0.5649, 0.0132,\n", + " 0.5595, 0.0546, 0.5524, 0.5511, 0.5480, 0.0322, 0.0127],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "535000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 34, 34, 41, 34, 34, 22, 29, 24, 37, 34, 34, 34, 41, 37, 20, 14,\n", + " 37, 29, 34, 34, 34, 46, 35])\n", + "loss= tensor(164.9133, grad_fn=) , actor= tensor(-18.7279, grad_fn=) , critic= tensor(1836.4117, grad_fn=) , return= 173428.6146107834\n", + "probs of actions: tensor([5.6661e-01, 5.8566e-02, 5.7474e-01, 5.8038e-01, 5.6151e-02, 5.8417e-01,\n", + " 5.8665e-01, 2.3323e-03, 4.9858e-02, 6.0309e-03, 8.9386e-02, 5.8255e-01,\n", + " 5.8152e-01, 5.7942e-01, 5.3002e-02, 8.9001e-02, 1.6510e-03, 5.4781e-04,\n", + " 8.8373e-02, 5.6330e-02, 5.6028e-01, 5.5674e-01, 5.5430e-01, 1.2362e-02,\n", + " 1.6788e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "536000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 32, 34, 34, 39, 37, 34, 38, 34, 34, 34, 28, 41, 34, 42, 34, 34, 34,\n", + " 34, 34, 37, 34, 34, 34, 34])\n", + "loss= tensor(203.2097, grad_fn=) , actor= tensor(20.4739, grad_fn=) , critic= tensor(1827.3577, grad_fn=) , return= 176035.4788794694\n", + "probs of actions: tensor([0.5710, 0.0122, 0.5810, 0.5850, 0.0237, 0.0904, 0.5909, 0.0279, 0.5911,\n", + " 0.5913, 0.5903, 0.0070, 0.0540, 0.5833, 0.0159, 0.5786, 0.5778, 0.5748,\n", + " 0.5718, 0.5688, 0.0879, 0.5625, 0.5602, 0.5572, 0.5543],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "537000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 38, 34, 34, 34, 38, 34, 34, 34, 34, 34, 34, 34, 34, 29, 37,\n", + " 35, 31, 41, 37, 34, 34, 29])\n", + "loss= tensor(161.7606, grad_fn=) , actor= tensor(-18.6686, grad_fn=) , critic= tensor(1804.2925, grad_fn=) , return= 176171.60931726935\n", + "probs of actions: tensor([0.5853, 0.5892, 0.5952, 0.0264, 0.6022, 0.6049, 0.6064, 0.0263, 0.6062,\n", + " 0.6065, 0.6055, 0.6039, 0.6020, 0.5999, 0.5974, 0.5950, 0.0520, 0.0826,\n", + " 0.0147, 0.0224, 0.0536, 0.0828, 0.5753, 0.5728, 0.0558],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "538000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 34, 34, 46, 34, 37, 34, 34, 34, 38, 34, 34, 34, 34, 37, 34, 41, 34,\n", + " 34, 42, 34, 34, 27, 37, 34])\n", + "loss= tensor(176.0413, grad_fn=) , actor= tensor(-7.8730, grad_fn=) , critic= tensor(1839.1433, grad_fn=) , return= 176137.39178370778\n", + "probs of actions: tensor([0.0121, 0.5827, 0.5882, 0.0130, 0.5936, 0.0898, 0.5989, 0.5999, 0.5999,\n", + " 0.0261, 0.5978, 0.5970, 0.5951, 0.5929, 0.0876, 0.5876, 0.0555, 0.5819,\n", + " 0.5806, 0.0159, 0.5732, 0.5720, 0.0047, 0.0872, 0.5617],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "539000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 42, 41, 34, 34, 41, 37, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34,\n", + " 34, 44, 37, 34, 37, 34, 39])\n", + "loss= tensor(172.6889, grad_fn=) , actor= tensor(-12.2329, grad_fn=) , critic= tensor(1849.2180, grad_fn=) , return= 176069.31598143984\n", + "probs of actions: tensor([0.5886, 0.5925, 0.0157, 0.0615, 0.6050, 0.6082, 0.0593, 0.0844, 0.6098,\n", + " 0.6099, 0.6088, 0.6072, 0.6054, 0.6032, 0.6007, 0.0569, 0.5946, 0.5935,\n", + " 0.5904, 0.0097, 0.0833, 0.5819, 0.0831, 0.5755, 0.0238],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "540000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 38, 34, 37, 38, 34, 34, 34, 34, 41, 25, 38, 37, 34,\n", + " 34, 34, 34, 34, 37, 34, 34])\n", + "loss= tensor(190.2236, grad_fn=) , actor= tensor(7.3217, grad_fn=) , critic= tensor(1829.0190, grad_fn=) , return= 175908.1448274008\n", + "probs of actions: tensor([0.6033, 0.6070, 0.6130, 0.6174, 0.6204, 0.0249, 0.6231, 0.0845, 0.0251,\n", + " 0.6230, 0.6226, 0.6209, 0.6189, 0.0515, 0.0040, 0.0262, 0.0835, 0.6059,\n", + " 0.6036, 0.6005, 0.5974, 0.5944, 0.0835, 0.5881, 0.5858],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "541000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 44, 34, 34, 34, 34, 37, 46, 34, 34, 34, 34, 34, 37, 32, 34, 29, 34,\n", + " 37, 34, 28, 35, 34, 34, 34])\n", + "loss= tensor(183.2719, grad_fn=) , actor= tensor(-2.9582, grad_fn=) , critic= tensor(1862.3008, grad_fn=) , return= 175850.3927805704\n", + "probs of actions: tensor([0.6191, 0.0082, 0.6267, 0.6331, 0.6362, 0.6381, 0.0802, 0.0116, 0.6374,\n", + " 0.6392, 0.6379, 0.6361, 0.6341, 0.0791, 0.0111, 0.6270, 0.0429, 0.6216,\n", + " 0.0793, 0.6143, 0.0070, 0.0135, 0.6051, 0.6025, 0.5996],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "542000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 34, 34, 34, 34, 34, 38, 43, 34, 34, 34, 34, 43, 34, 42, 34, 34,\n", + " 40, 34, 32, 39, 34, 34, 34])\n", + "loss= tensor(179.3558, grad_fn=) , actor= tensor(-3.8835, grad_fn=) , critic= tensor(1832.3921, grad_fn=) , return= 176432.38413377118\n", + "probs of actions: tensor([0.6186, 0.0226, 0.6264, 0.6325, 0.6356, 0.6374, 0.6387, 0.0238, 0.0201,\n", + " 0.6368, 0.6374, 0.6356, 0.6335, 0.0197, 0.6274, 0.0147, 0.6223, 0.6212,\n", + " 0.0053, 0.6138, 0.0124, 0.0212, 0.6046, 0.6027, 0.5995],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "543000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 41, 37, 35, 34, 34, 34, 34, 34, 34, 28, 34, 43, 29, 34, 34, 29,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(201.9488, grad_fn=) , actor= tensor(18.0061, grad_fn=) , critic= tensor(1839.4266, grad_fn=) , return= 175590.96161171384\n", + "probs of actions: tensor([0.6295, 0.6334, 0.0535, 0.0848, 0.0106, 0.6487, 0.6503, 0.6507, 0.6506,\n", + " 0.6500, 0.6489, 0.0058, 0.6461, 0.0194, 0.0383, 0.6394, 0.6356, 0.0396,\n", + " 0.6306, 0.6265, 0.6237, 0.6208, 0.6179, 0.6150, 0.6121],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "544000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 34, 34, 46, 37, 37, 34, 34, 34, 34, 34, 34, 38, 29, 34, 34, 34,\n", + " 34, 46, 34, 34, 34, 34, 34])\n", + "loss= tensor(195.8436, grad_fn=) , actor= tensor(12.6099, grad_fn=) , critic= tensor(1832.3372, grad_fn=) , return= 176111.7213517271\n", + "probs of actions: tensor([0.6278, 0.0855, 0.6371, 0.6420, 0.0112, 0.0833, 0.0827, 0.6487, 0.6490,\n", + " 0.6485, 0.6473, 0.6458, 0.6439, 0.0230, 0.0391, 0.6377, 0.6339, 0.6313,\n", + " 0.6284, 0.0110, 0.6209, 0.6207, 0.6172, 0.6140, 0.6109],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "545000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 39, 34, 34, 34, 34, 34, 41, 34, 24, 38, 34, 38, 34, 34, 24, 43,\n", + " 34, 41, 34, 34, 34, 34, 29])\n", + "loss= tensor(178.6830, grad_fn=) , actor= tensor(-0.6389, grad_fn=) , critic= tensor(1793.2191, grad_fn=) , return= 175971.46848183658\n", + "probs of actions: tensor([0.6269, 0.6307, 0.0198, 0.6402, 0.6441, 0.6462, 0.6476, 0.6480, 0.0512,\n", + " 0.6462, 0.0046, 0.0225, 0.6419, 0.0230, 0.6377, 0.6360, 0.0050, 0.0186,\n", + " 0.6253, 0.0504, 0.6208, 0.6193, 0.6160, 0.6129, 0.0451],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "546000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 34, 35, 34, 37, 34, 34, 34, 34, 34, 34, 40, 43, 42, 29, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(201.8763, grad_fn=) , actor= tensor(19.3107, grad_fn=) , critic= tensor(1825.6564, grad_fn=) , return= 175942.3662476517\n", + "probs of actions: tensor([0.0367, 0.6314, 0.6363, 0.0108, 0.6436, 0.0817, 0.6467, 0.6476, 0.6474,\n", + " 0.6469, 0.6458, 0.6442, 0.0046, 0.0183, 0.0145, 0.0416, 0.6341, 0.6299,\n", + " 0.6269, 0.6239, 0.6209, 0.6179, 0.6149, 0.6120, 0.6090],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "547000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 36, 39, 34, 34, 34, 34, 37, 34, 27, 32, 37, 34, 34, 34,\n", + " 34, 29, 34, 34, 7, 46, 47])\n", + "loss= tensor(153.6668, grad_fn=) , actor= tensor(-44.4258, grad_fn=) , critic= tensor(1980.9255, grad_fn=) , return= 173496.34173239855\n", + "probs of actions: tensor([5.6792e-02, 6.2633e-01, 6.3402e-01, 6.3829e-01, 2.2218e-03, 1.8623e-02,\n", + " 6.4382e-01, 6.4507e-01, 6.4480e-01, 6.4422e-01, 8.3940e-02, 6.4103e-01,\n", + " 3.6699e-03, 1.0260e-02, 8.3658e-02, 6.3145e-01, 6.2965e-01, 6.2685e-01,\n", + " 6.2395e-01, 4.5308e-02, 6.1851e-01, 6.1446e-01, 2.1037e-04, 1.1169e-02,\n", + " 2.3893e-03], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "548000 adversary: AdversaryModes.myopic\n", + " actions: tensor([43, 34, 34, 34, 34, 34, 34, 34, 34, 46, 28, 34, 37, 20, 32, 34, 34, 34,\n", + " 27, 29, 29, 34, 37, 41, 34])\n", + "loss= tensor(173.4062, grad_fn=) , actor= tensor(-11.9919, grad_fn=) , critic= tensor(1853.9810, grad_fn=) , return= 174620.98128466547\n", + "probs of actions: tensor([0.0211, 0.6260, 0.6342, 0.6385, 0.6415, 0.6435, 0.6448, 0.6452, 0.6450,\n", + " 0.0105, 0.0064, 0.6429, 0.0831, 0.0013, 0.0103, 0.6320, 0.6293, 0.6268,\n", + " 0.0040, 0.0458, 0.0464, 0.6150, 0.0834, 0.0521, 0.6058],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "549000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 24, 34, 34, 41, 34, 34, 37, 34, 34, 34, 38,\n", + " 37, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(179.5394, grad_fn=) , actor= tensor(-1.2541, grad_fn=) , critic= tensor(1807.9343, grad_fn=) , return= 175635.4493739915\n", + "probs of actions: tensor([0.6121, 0.6160, 0.6219, 0.6262, 0.6293, 0.6313, 0.6327, 0.0050, 0.6343,\n", + " 0.6322, 0.0515, 0.6287, 0.6282, 0.0888, 0.6231, 0.6211, 0.6184, 0.0273,\n", + " 0.0888, 0.6098, 0.6073, 0.6042, 0.6011, 0.0889, 0.5949],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "550000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 34, 34, 34, 34, 34, 38, 34, 37, 39, 34, 34, 34, 34, 39, 31, 34,\n", + " 34, 29, 37, 34, 34, 34, 46])\n", + "loss= tensor(180.1007, grad_fn=) , actor= tensor(-10.5162, grad_fn=) , critic= tensor(1906.1692, grad_fn=) , return= 175039.07948022298\n", + "probs of actions: tensor([0.6293, 0.0138, 0.6375, 0.6434, 0.6465, 0.6486, 0.6500, 0.0247, 0.6496,\n", + " 0.0870, 0.0169, 0.6466, 0.6456, 0.6434, 0.6408, 0.0174, 0.0190, 0.6337,\n", + " 0.6301, 0.0457, 0.0864, 0.6204, 0.6184, 0.6154, 0.0116],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "551000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 34, 37, 42, 34, 34, 37, 35, 34, 38, 34, 37, 34, 17, 46, 34, 34,\n", + " 34, 29, 37, 31, 34, 34, 38])\n", + "loss= tensor(183.5538, grad_fn=) , actor= tensor(-2.5939, grad_fn=) , critic= tensor(1861.4771, grad_fn=) , return= 175243.88374310348\n", + "probs of actions: tensor([2.4712e-02, 6.3547e-01, 6.4235e-01, 8.8394e-02, 1.2773e-02, 6.5036e-01,\n", + " 6.5309e-01, 8.6587e-02, 1.0321e-02, 6.5270e-01, 2.4080e-02, 6.4960e-01,\n", + " 8.5662e-02, 6.4586e-01, 4.8889e-04, 1.0285e-02, 6.3541e-01, 6.3615e-01,\n", + " 6.3315e-01, 4.6369e-02, 8.5699e-02, 2.0530e-02, 6.2161e-01, 6.1804e-01,\n", + " 2.7288e-02], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "552000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 44, 34, 34, 34, 32, 32, 34, 34, 37, 37, 34, 34, 34, 34, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 24])\n", + "loss= tensor(187.7997, grad_fn=) , actor= tensor(7.0484, grad_fn=) , critic= tensor(1807.5127, grad_fn=) , return= 176567.60322610073\n", + "probs of actions: tensor([0.0248, 0.6372, 0.0070, 0.6467, 0.6517, 0.6538, 0.0092, 0.0092, 0.6558,\n", + " 0.6550, 0.0845, 0.0844, 0.6505, 0.6489, 0.6463, 0.6438, 0.6413, 0.6385,\n", + " 0.0842, 0.6324, 0.6301, 0.6271, 0.6241, 0.6212, 0.0057],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "553000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 39, 34, 38, 34, 40, 34, 37, 34, 34, 34, 34, 34, 34, 43, 35, 34, 34,\n", + " 34, 42, 26, 34, 34, 34, 38])\n", + "loss= tensor(180.7768, grad_fn=) , actor= tensor(-5.7781, grad_fn=) , critic= tensor(1865.5491, grad_fn=) , return= 175827.82460302158\n", + "probs of actions: tensor([0.6305, 0.0158, 0.6394, 0.0247, 0.6471, 0.0042, 0.6502, 0.0814, 0.6510,\n", + " 0.6510, 0.6499, 0.6483, 0.6465, 0.6443, 0.0178, 0.0118, 0.6373, 0.6345,\n", + " 0.6314, 0.0132, 0.0033, 0.6239, 0.6191, 0.6163, 0.0281],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "554000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 37, 29, 43, 37, 34, 34, 34, 34, 39, 34, 39, 34, 43, 43, 39, 34, 34,\n", + " 34, 34, 34, 32, 34, 34, 34])\n", + "loss= tensor(209.4581, grad_fn=) , actor= tensor(23.9444, grad_fn=) , critic= tensor(1855.1376, grad_fn=) , return= 176471.93922467917\n", + "probs of actions: tensor([0.0129, 0.0821, 0.0389, 0.0192, 0.0800, 0.6516, 0.6535, 0.6540, 0.6538,\n", + " 0.0152, 0.6515, 0.0153, 0.6483, 0.0175, 0.0176, 0.0157, 0.6394, 0.6373,\n", + " 0.6340, 0.6309, 0.6277, 0.0107, 0.6220, 0.6186, 0.6158],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "555000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 39, 31, 31, 34, 34, 34, 34, 34, 32, 34, 34, 34, 34, 37, 29, 22,\n", + " 34, 34, 34, 31, 34, 34, 34])\n", + "loss= tensor(192.1259, grad_fn=) , actor= tensor(8.2050, grad_fn=) , critic= tensor(1839.2089, grad_fn=) , return= 175063.12326072654\n", + "probs of actions: tensor([0.6409, 0.6448, 0.0157, 0.0168, 0.0166, 0.6609, 0.6618, 0.6623, 0.6622,\n", + " 0.6618, 0.0092, 0.6595, 0.6574, 0.6553, 0.6529, 0.0787, 0.0439, 0.0020,\n", + " 0.6435, 0.6382, 0.6359, 0.0195, 0.6309, 0.6274, 0.6247],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "556000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 39, 34, 41, 34, 38, 41, 34, 34, 41, 34, 29, 34, 41,\n", + " 34, 34, 43, 34, 34, 29, 34])\n", + "loss= tensor(182.8514, grad_fn=) , actor= tensor(0.2960, grad_fn=) , critic= tensor(1825.5537, grad_fn=) , return= 176420.31508919477\n", + "probs of actions: tensor([0.6257, 0.6297, 0.6358, 0.6402, 0.6434, 0.0163, 0.6463, 0.0555, 0.6464,\n", + " 0.0240, 0.0545, 0.6439, 0.6433, 0.0539, 0.6377, 0.0450, 0.6344, 0.0538,\n", + " 0.6268, 0.6256, 0.0181, 0.6182, 0.6172, 0.0490, 0.6113],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "557000 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 34, 34, 37, 42, 29, 37, 39, 37, 34, 43, 29, 37, 29, 37, 34, 37, 34,\n", + " 41, 41, 41, 34, 34, 35, 34])\n", + "loss= tensor(198.0456, grad_fn=) , actor= tensor(19.4377, grad_fn=) , critic= tensor(1786.0787, grad_fn=) , return= 175808.61131489422\n", + "probs of actions: tensor([6.4479e-04, 6.4496e-01, 6.4838e-01, 8.3044e-02, 1.1561e-02, 3.7149e-02,\n", + " 8.1428e-02, 1.5840e-02, 8.1025e-02, 6.5970e-01, 1.7662e-02, 3.9652e-02,\n", + " 8.0204e-02, 4.0629e-02, 8.0102e-02, 6.4842e-01, 8.0209e-02, 6.4354e-01,\n", + " 5.2094e-02, 5.2185e-02, 5.2221e-02, 6.3260e-01, 6.3075e-01, 1.3194e-02,\n", + " 6.2406e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "558000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 34, 34, 37, 38, 34, 34, 29, 41, 38, 34, 34, 34, 38, 37, 36, 34, 37,\n", + " 34, 34, 34, 37, 34, 34, 34])\n", + "loss= tensor(204.3555, grad_fn=) , actor= tensor(20.6970, grad_fn=) , critic= tensor(1836.5845, grad_fn=) , return= 176263.98786301794\n", + "probs of actions: tensor([0.0172, 0.6376, 0.6449, 0.0858, 0.0230, 0.6541, 0.6563, 0.0374, 0.0530,\n", + " 0.0232, 0.6550, 0.6542, 0.6523, 0.0238, 0.0829, 0.0028, 0.6429, 0.0828,\n", + " 0.6371, 0.6348, 0.6317, 0.0831, 0.6255, 0.6232, 0.6202],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "559000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 44, 40, 34, 34, 34, 34, 34, 34, 34, 24, 44, 34, 34, 37, 34, 34,\n", + " 34, 34, 34, 43, 34, 34, 34])\n", + "loss= tensor(196.3549, grad_fn=) , actor= tensor(14.2584, grad_fn=) , critic= tensor(1820.9658, grad_fn=) , return= 175868.4123281468\n", + "probs of actions: tensor([0.6441, 0.6482, 0.0070, 0.0041, 0.6612, 0.6645, 0.6661, 0.6668, 0.6668,\n", + " 0.6665, 0.6656, 0.0043, 0.0072, 0.6588, 0.6586, 0.0811, 0.6533, 0.6513,\n", + " 0.6484, 0.6455, 0.6426, 0.0180, 0.6359, 0.6350, 0.6318],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "560000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34,\n", + " 29, 37, 31, 41, 34, 34, 34])\n", + "loss= tensor(166.1448, grad_fn=) , actor= tensor(-16.1584, grad_fn=) , critic= tensor(1823.0316, grad_fn=) , return= 175709.2110463816\n", + "probs of actions: tensor([0.6404, 0.6444, 0.6506, 0.6551, 0.6584, 0.6606, 0.6622, 0.6629, 0.6629,\n", + " 0.6626, 0.6616, 0.6602, 0.0146, 0.6559, 0.6545, 0.6521, 0.6495, 0.6469,\n", + " 0.0450, 0.0814, 0.0187, 0.0510, 0.6315, 0.6303, 0.6272],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "561000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 31, 34, 34, 34, 34, 39, 34, 34, 34, 34, 37, 34, 34, 34, 34, 37, 34,\n", + " 40, 34, 34, 43, 43, 34, 34])\n", + "loss= tensor(169.1104, grad_fn=) , actor= tensor(-10.2261, grad_fn=) , critic= tensor(1793.3647, grad_fn=) , return= 175953.10208960978\n", + "probs of actions: tensor([0.6348, 0.0161, 0.6457, 0.6498, 0.6531, 0.6554, 0.0148, 0.6571, 0.6580,\n", + " 0.6577, 0.6568, 0.0819, 0.6534, 0.6520, 0.6496, 0.6473, 0.0816, 0.6418,\n", + " 0.0056, 0.6359, 0.6343, 0.0190, 0.0191, 0.6252, 0.6238],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "562000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 41, 42, 34, 37, 32, 34, 34, 34, 41, 34, 34, 37, 34, 29, 34, 37,\n", + " 34, 35, 41, 34, 34, 34, 34])\n", + "loss= tensor(196.2766, grad_fn=) , actor= tensor(12.6497, grad_fn=) , critic= tensor(1836.2688, grad_fn=) , return= 176180.10197479295\n", + "probs of actions: tensor([0.6264, 0.6305, 0.0570, 0.0123, 0.6435, 0.0836, 0.0092, 0.6500, 0.6499,\n", + " 0.6496, 0.0522, 0.6465, 0.6461, 0.0814, 0.6413, 0.0466, 0.6377, 0.0813,\n", + " 0.6310, 0.0120, 0.0516, 0.6224, 0.6210, 0.6178, 0.6148],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "563000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 32, 34, 34, 34, 27, 33, 31, 29, 34, 34, 34, 37, 34, 34, 34, 34, 34,\n", + " 37, 34, 41, 34, 34, 34, 43])\n", + "loss= tensor(192.7690, grad_fn=) , actor= tensor(10.2153, grad_fn=) , critic= tensor(1825.5376, grad_fn=) , return= 174730.08301572144\n", + "probs of actions: tensor([0.6352, 0.0093, 0.6459, 0.6502, 0.6536, 0.0032, 0.0021, 0.0161, 0.0439,\n", + " 0.6588, 0.6572, 0.6559, 0.0785, 0.6521, 0.6503, 0.6480, 0.6455, 0.6429,\n", + " 0.0784, 0.6369, 0.0529, 0.6310, 0.6296, 0.6264, 0.0195],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "564000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 10, 34, 34, 34, 34, 34, 34, 38, 34, 38, 34, 37, 24, 34,\n", + " 34, 28, 37, 34, 43, 29, 34])\n", + "loss= tensor(163.5320, grad_fn=) , actor= tensor(-13.9973, grad_fn=) , critic= tensor(1775.2931, grad_fn=) , return= 174421.67937426438\n", + "probs of actions: tensor([6.4612e-01, 6.5027e-01, 6.5656e-01, 6.6120e-01, 1.5745e-04, 6.6922e-01,\n", + " 6.6860e-01, 6.6940e-01, 6.6963e-01, 6.6943e-01, 6.6865e-01, 2.0510e-02,\n", + " 6.6532e-01, 2.0853e-02, 6.6133e-01, 7.8909e-02, 4.1522e-03, 6.5600e-01,\n", + " 6.5119e-01, 6.3661e-03, 7.9120e-02, 6.4247e-01, 1.8748e-02, 4.8370e-02,\n", + " 6.3647e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "565000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 43, 34, 34, 34, 34, 37, 34, 34, 34, 37, 44, 34, 34, 37, 41, 34,\n", + " 34, 34, 41, 34, 34, 34, 29])\n", + "loss= tensor(178.4943, grad_fn=) , actor= tensor(-2.3783, grad_fn=) , critic= tensor(1808.7256, grad_fn=) , return= 176706.59423802706\n", + "probs of actions: tensor([0.6718, 0.6759, 0.0192, 0.6851, 0.6901, 0.6925, 0.6942, 0.0751, 0.6947,\n", + " 0.6949, 0.6941, 0.0742, 0.0073, 0.6881, 0.6876, 0.0741, 0.0455, 0.6791,\n", + " 0.6778, 0.6747, 0.0457, 0.6680, 0.6666, 0.6635, 0.0453],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "566000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 37, 34, 39, 28, 24, 34, 37, 34, 37, 14, 37, 39, 41, 37,\n", + " 31, 44, 37, 34, 37, 46, 37])\n", + "loss= tensor(162.8728, grad_fn=) , actor= tensor(-15.7477, grad_fn=) , critic= tensor(1786.2045, grad_fn=) , return= 174521.17298064663\n", + "probs of actions: tensor([6.7165e-01, 6.7569e-01, 6.8191e-01, 8.0237e-02, 7.9623e-02, 6.9171e-01,\n", + " 1.3162e-02, 5.3472e-03, 3.4316e-03, 6.9567e-01, 7.7357e-02, 6.9172e-01,\n", + " 7.7144e-02, 3.2076e-04, 7.6715e-02, 1.3623e-02, 4.4686e-02, 7.7378e-02,\n", + " 1.5608e-02, 7.8411e-03, 7.7736e-02, 6.6894e-01, 7.7702e-02, 9.0293e-03,\n", + " 7.8151e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "567000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 29, 34, 40, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 37,\n", + " 34, 41, 37, 34, 41, 37, 34])\n", + "loss= tensor(176.5204, grad_fn=) , actor= tensor(-4.0456, grad_fn=) , critic= tensor(1805.6599, grad_fn=) , return= 175994.51236086903\n", + "probs of actions: tensor([0.0189, 0.0351, 0.6849, 0.0042, 0.6911, 0.6945, 0.6962, 0.6970, 0.6972,\n", + " 0.6970, 0.6962, 0.6949, 0.0165, 0.6903, 0.6898, 0.6874, 0.6849, 0.0790,\n", + " 0.6792, 0.0432, 0.0795, 0.6716, 0.0434, 0.0797, 0.6635],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "568000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 41, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 34, 43, 34, 34, 39, 39, 34])\n", + "loss= tensor(158.8300, grad_fn=) , actor= tensor(-22.9034, grad_fn=) , critic= tensor(1817.3344, grad_fn=) , return= 175909.03644832945\n", + "probs of actions: tensor([0.6746, 0.0477, 0.6835, 0.6895, 0.6929, 0.6953, 0.0790, 0.6973, 0.6979,\n", + " 0.6977, 0.6968, 0.6955, 0.6940, 0.6920, 0.6898, 0.6876, 0.6852, 0.0777,\n", + " 0.6796, 0.0167, 0.6733, 0.6724, 0.0153, 0.0155, 0.6633],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "569000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 41, 41, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 31, 34, 34, 34, 34])\n", + "loss= tensor(189.6358, grad_fn=) , actor= tensor(4.2517, grad_fn=) , critic= tensor(1853.8418, grad_fn=) , return= 175958.40460379428\n", + "probs of actions: tensor([0.6765, 0.6806, 0.6869, 0.0470, 0.0463, 0.6962, 0.6991, 0.6999, 0.7002,\n", + " 0.7000, 0.0787, 0.6975, 0.6966, 0.6947, 0.6925, 0.6903, 0.6879, 0.6854,\n", + " 0.6827, 0.6800, 0.0158, 0.6748, 0.6715, 0.6689, 0.6662],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "570000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 41, 34, 14, 40, 34, 38, 34,\n", + " 34, 46, 41, 36, 41, 34, 29])\n", + "loss= tensor(141.5088, grad_fn=) , actor= tensor(-33.4168, grad_fn=) , critic= tensor(1749.2565, grad_fn=) , return= 175808.22003618945\n", + "probs of actions: tensor([6.6168e-01, 6.6582e-01, 6.7203e-01, 6.7660e-01, 6.7994e-01, 6.8234e-01,\n", + " 4.4587e-02, 6.8373e-01, 6.8505e-01, 6.8480e-01, 6.8397e-01, 4.3049e-02,\n", + " 6.8018e-01, 2.9757e-04, 4.6211e-03, 6.7265e-01, 2.1083e-02, 6.6914e-01,\n", + " 6.6740e-01, 8.9878e-03, 4.3212e-02, 2.7636e-03, 4.3244e-02, 6.5331e-01,\n", + " 4.7210e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "571000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 47, 42, 46, 34, 34, 34, 41, 34, 34, 31, 29, 34, 37,\n", + " 34, 34, 37, 41, 34, 34, 34])\n", + "loss= tensor(198.5199, grad_fn=) , actor= tensor(14.2901, grad_fn=) , critic= tensor(1842.2975, grad_fn=) , return= 176236.11707096465\n", + "probs of actions: tensor([0.6741, 0.6782, 0.6844, 0.6890, 0.6924, 0.0013, 0.0110, 0.0084, 0.6957,\n", + " 0.6975, 0.6966, 0.0440, 0.6927, 0.6920, 0.0147, 0.0407, 0.6853, 0.0788,\n", + " 0.6789, 0.6769, 0.0791, 0.0442, 0.6680, 0.6665, 0.6634],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "572000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 29, 34, 34, 34, 34, 31, 34, 34,\n", + " 35, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(183.4644, grad_fn=) , actor= tensor(0.9846, grad_fn=) , critic= tensor(1824.7981, grad_fn=) , return= 175578.69581403307\n", + "probs of actions: tensor([0.6778, 0.6818, 0.6880, 0.6925, 0.6958, 0.6982, 0.6999, 0.0810, 0.7003,\n", + " 0.7006, 0.0372, 0.6990, 0.6967, 0.6948, 0.6927, 0.0142, 0.6885, 0.6853,\n", + " 0.0092, 0.6800, 0.6774, 0.6746, 0.6718, 0.6691, 0.6663],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "573000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 28, 46, 34, 29, 34, 34, 37, 37, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 44, 34, 34, 29, 34, 34, 34])\n", + "loss= tensor(199.5985, grad_fn=) , actor= tensor(16.6826, grad_fn=) , critic= tensor(1829.1593, grad_fn=) , return= 175764.14484752013\n", + "probs of actions: tensor([0.0857, 0.6749, 0.0056, 0.0093, 0.6875, 0.0365, 0.6943, 0.6943, 0.0807,\n", + " 0.0805, 0.6930, 0.6922, 0.6905, 0.6885, 0.6863, 0.6840, 0.6815, 0.6790,\n", + " 0.0074, 0.6721, 0.6715, 0.0439, 0.6658, 0.6619, 0.6592],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "574000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 30, 34, 34, 34, 44, 34, 34, 43, 29, 24, 39, 34, 37, 34,\n", + " 34, 34, 34, 34, 37, 31, 34])\n", + "loss= tensor(189.0451, grad_fn=) , actor= tensor(6.7307, grad_fn=) , critic= tensor(1823.1447, grad_fn=) , return= 175701.9902234638\n", + "probs of actions: tensor([0.0451, 0.7008, 0.7085, 0.7129, 0.0028, 0.7189, 0.7199, 0.7206, 0.0061,\n", + " 0.7187, 0.7197, 0.0138, 0.0365, 0.0035, 0.0123, 0.7086, 0.0748, 0.7046,\n", + " 0.7025, 0.6996, 0.6967, 0.6939, 0.0757, 0.0149, 0.6861],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "575000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 31, 34, 34, 34, 34, 39, 25, 34, 34, 29, 34, 41, 34, 34,\n", + " 34, 32, 34, 34, 34, 34, 41])\n", + "loss= tensor(183.3689, grad_fn=) , actor= tensor(-0.9785, grad_fn=) , critic= tensor(1843.4734, grad_fn=) , return= 174847.55914476348\n", + "probs of actions: tensor([0.7025, 0.7064, 0.7124, 0.7168, 0.0116, 0.7226, 0.7236, 0.7243, 0.7243,\n", + " 0.0116, 0.0022, 0.7228, 0.7198, 0.0371, 0.7163, 0.0387, 0.7098, 0.7089,\n", + " 0.7060, 0.0085, 0.7004, 0.6972, 0.6945, 0.6918, 0.0396],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "576000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 30, 34, 34, 34, 34, 34, 34, 34, 46, 37, 37, 34, 34, 34, 34, 34,\n", + " 34, 43, 34, 34, 38, 34, 34])\n", + "loss= tensor(182.1665, grad_fn=) , actor= tensor(1.3456, grad_fn=) , critic= tensor(1808.2081, grad_fn=) , return= 176006.86339733016\n", + "probs of actions: tensor([0.6951, 0.6992, 0.0029, 0.7102, 0.7128, 0.7151, 0.7167, 0.7174, 0.7174,\n", + " 0.7171, 0.0073, 0.0760, 0.0757, 0.7114, 0.7095, 0.7070, 0.7045, 0.7019,\n", + " 0.6991, 0.0134, 0.6924, 0.6915, 0.0204, 0.6849, 0.6828],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "577000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 32, 40, 34, 34, 34, 34, 34, 43, 34, 37, 42, 34, 29, 34, 41,\n", + " 32, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(199.7454, grad_fn=) , actor= tensor(16.4845, grad_fn=) , critic= tensor(1832.6086, grad_fn=) , return= 176040.13687959797\n", + "probs of actions: tensor([0.7030, 0.7070, 0.7131, 0.0080, 0.0042, 0.7220, 0.7246, 0.7253, 0.7253,\n", + " 0.7250, 0.0135, 0.7215, 0.0713, 0.0101, 0.7163, 0.0375, 0.7132, 0.0387,\n", + " 0.0087, 0.7050, 0.7015, 0.6987, 0.6959, 0.6930, 0.6903],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "578000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 37, 37, 37, 28, 29, 34, 37, 34, 34, 37, 34, 34,\n", + " 34, 34, 34, 42, 34, 40, 34])\n", + "loss= tensor(174.0603, grad_fn=) , actor= tensor(-7.1800, grad_fn=) , critic= tensor(1812.4032, grad_fn=) , return= 175591.12275599936\n", + "probs of actions: tensor([0.7221, 0.7260, 0.7319, 0.7362, 0.7393, 0.7416, 0.0671, 0.0668, 0.0666,\n", + " 0.0048, 0.0337, 0.7415, 0.0662, 0.7370, 0.7354, 0.0664, 0.7301, 0.7282,\n", + " 0.7254, 0.7226, 0.7197, 0.0102, 0.7133, 0.0050, 0.7084],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "579000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 43, 37, 34, 34, 34, 34, 41, 34, 34, 34, 29, 39, 34, 34, 42, 34,\n", + " 34, 34, 34, 37, 34, 34, 29])\n", + "loss= tensor(184.6541, grad_fn=) , actor= tensor(3.6529, grad_fn=) , critic= tensor(1810.0117, grad_fn=) , return= 176345.41109136253\n", + "probs of actions: tensor([0.0310, 0.7342, 0.0135, 0.0649, 0.7459, 0.7485, 0.7500, 0.7506, 0.0372,\n", + " 0.7491, 0.7494, 0.7479, 0.0335, 0.0110, 0.7412, 0.7398, 0.0096, 0.7336,\n", + " 0.7326, 0.7295, 0.7266, 0.0636, 0.7205, 0.7183, 0.0392],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "580000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 41, 34, 42, 34, 34, 34, 34, 37, 34, 37, 41, 34, 37, 37, 37,\n", + " 34, 46, 43, 37, 39, 34, 37])\n", + "loss= tensor(154.9456, grad_fn=) , actor= tensor(-25.5881, grad_fn=) , critic= tensor(1805.3374, grad_fn=) , return= 176442.36211337388\n", + "probs of actions: tensor([0.7249, 0.7289, 0.7348, 0.0416, 0.7413, 0.0093, 0.7451, 0.7470, 0.7470,\n", + " 0.7467, 0.0635, 0.7441, 0.0634, 0.0382, 0.7382, 0.0636, 0.0638, 0.0640,\n", + " 0.7289, 0.0079, 0.0126, 0.0648, 0.0125, 0.7156, 0.0652],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "581000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 37, 34, 39, 34, 34, 23, 34, 16,\n", + " 34, 34, 34, 34, 42, 34, 37])\n", + "loss= tensor(165.1273, grad_fn=) , actor= tensor(-20.1697, grad_fn=) , critic= tensor(1852.9697, grad_fn=) , return= 174652.83073700342\n", + "probs of actions: tensor([7.3449e-01, 7.3846e-01, 7.4441e-01, 7.4877e-01, 7.5194e-01, 7.5427e-01,\n", + " 3.8346e-02, 7.5556e-01, 7.5671e-01, 7.5641e-01, 5.9304e-02, 7.5387e-01,\n", + " 1.0888e-02, 7.5034e-01, 7.4899e-01, 4.2455e-04, 7.4537e-01, 7.2176e-04,\n", + " 7.4033e-01, 7.3451e-01, 7.3263e-01, 7.3034e-01, 9.8763e-03, 7.2432e-01,\n", + " 6.1134e-02], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "582000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 39, 34, 34, 34, 34, 26, 34, 31, 34, 34, 34, 34, 34, 26, 34,\n", + " 34, 34, 34, 34, 34, 34, 29])\n", + "loss= tensor(189.5216, grad_fn=) , actor= tensor(9.8117, grad_fn=) , critic= tensor(1797.0983, grad_fn=) , return= 175410.23149782972\n", + "probs of actions: tensor([0.7444, 0.7483, 0.0305, 0.0109, 0.7610, 0.7640, 0.7656, 0.7663, 0.0020,\n", + " 0.7671, 0.0097, 0.7643, 0.7624, 0.7606, 0.7586, 0.7563, 0.0023, 0.7525,\n", + " 0.7484, 0.7460, 0.7434, 0.7408, 0.7381, 0.7354, 0.0387],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "583000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 32, 43, 34, 34, 34, 34, 34, 34, 24, 34, 34,\n", + " 40, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(187.8707, grad_fn=) , actor= tensor(5.5460, grad_fn=) , critic= tensor(1823.2469, grad_fn=) , return= 175575.93252010073\n", + "probs of actions: tensor([0.7506, 0.7545, 0.7604, 0.7647, 0.7678, 0.7701, 0.7717, 0.0068, 0.0120,\n", + " 0.7708, 0.7715, 0.7702, 0.7687, 0.7668, 0.7647, 0.0031, 0.7612, 0.7570,\n", + " 0.0041, 0.7515, 0.7501, 0.7472, 0.7444, 0.7416, 0.7389],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "584000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 21, 34, 34, 34, 44, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(199.3659, grad_fn=) , actor= tensor(18.2302, grad_fn=) , critic= tensor(1811.3574, grad_fn=) , return= 175401.66831691904\n", + "probs of actions: tensor([7.6376e-01, 7.6751e-01, 7.7326e-01, 7.7745e-01, 3.5377e-04, 7.8411e-01,\n", + " 7.8420e-01, 7.8484e-01, 4.7710e-03, 7.8310e-01, 7.8402e-01, 7.8266e-01,\n", + " 7.8113e-01, 7.7927e-01, 7.7714e-01, 7.7484e-01, 7.7253e-01, 7.7007e-01,\n", + " 7.6749e-01, 7.6482e-01, 7.6211e-01, 7.5945e-01, 7.5676e-01, 7.5406e-01,\n", + " 7.5136e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "585000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 34, 37, 42, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 37, 34,\n", + " 34, 34, 29, 34, 34, 34, 34])\n", + "loss= tensor(195.4884, grad_fn=) , actor= tensor(11.4772, grad_fn=) , critic= tensor(1840.1119, grad_fn=) , return= 175788.7594664134\n", + "probs of actions: tensor([0.7849, 0.7885, 0.0262, 0.7987, 0.0446, 0.0065, 0.8036, 0.8054, 0.8054,\n", + " 0.8051, 0.8043, 0.8031, 0.8017, 0.7999, 0.0436, 0.7953, 0.0440, 0.7908,\n", + " 0.7888, 0.7862, 0.0318, 0.7813, 0.7778, 0.7754, 0.7729],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "586000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 30, 46, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(188.4955, grad_fn=) , actor= tensor(7.1111, grad_fn=) , critic= tensor(1813.8440, grad_fn=) , return= 175769.95771932093\n", + "probs of actions: tensor([0.7889, 0.0255, 0.7987, 0.8020, 0.8049, 0.8072, 0.8086, 0.8093, 0.8093,\n", + " 0.8090, 0.0105, 0.8060, 0.8060, 0.8041, 0.8020, 0.0019, 0.0060, 0.7934,\n", + " 0.7935, 0.7906, 0.7878, 0.7852, 0.7826, 0.7800, 0.7774],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "587000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 42, 34, 34, 32,\n", + " 34, 34, 29, 34, 34, 34, 34])\n", + "loss= tensor(184.0108, grad_fn=) , actor= tensor(0.7511, grad_fn=) , critic= tensor(1832.5963, grad_fn=) , return= 175673.46889872308\n", + "probs of actions: tensor([0.7922, 0.7957, 0.0235, 0.8059, 0.8082, 0.8104, 0.8118, 0.8125, 0.8125,\n", + " 0.8122, 0.0292, 0.8095, 0.8091, 0.8073, 0.0062, 0.8022, 0.8013, 0.0067,\n", + " 0.7964, 0.7934, 0.0286, 0.7889, 0.7854, 0.7830, 0.7806],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "588000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 38, 34, 34, 37, 34, 29,\n", + " 25, 34, 44, 34, 34, 34, 34])\n", + "loss= tensor(171.7264, grad_fn=) , actor= tensor(-11.3651, grad_fn=) , critic= tensor(1830.9154, grad_fn=) , return= 175655.82202908787\n", + "probs of actions: tensor([0.7974, 0.8010, 0.8065, 0.8105, 0.8134, 0.8156, 0.8171, 0.0292, 0.8168,\n", + " 0.8177, 0.8169, 0.8157, 0.0104, 0.8122, 0.8109, 0.0408, 0.8061, 0.0262,\n", + " 0.0016, 0.7997, 0.0055, 0.7926, 0.7922, 0.7894, 0.7867],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "589000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 46, 34, 34, 34, 34, 35,\n", + " 34, 20, 34, 34, 32, 34, 34])\n", + "loss= tensor(160.7761, grad_fn=) , actor= tensor(-24.3115, grad_fn=) , critic= tensor(1850.8763, grad_fn=) , return= 175413.08324434364\n", + "probs of actions: tensor([8.0957e-01, 8.1302e-01, 8.1833e-01, 8.2221e-01, 8.2502e-01, 8.2721e-01,\n", + " 8.2863e-01, 8.2927e-01, 8.2933e-01, 8.2908e-01, 8.2833e-01, 8.2725e-01,\n", + " 5.3008e-03, 8.2298e-01, 8.2298e-01, 8.2065e-01, 8.1843e-01, 5.9499e-03,\n", + " 8.1366e-01, 6.9221e-04, 8.1007e-01, 8.0534e-01, 6.5018e-03, 8.0138e-01,\n", + " 7.9869e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "590000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 37, 34, 34, 29])\n", + "loss= tensor(160.3433, grad_fn=) , actor= tensor(-20.0554, grad_fn=) , critic= tensor(1803.9868, grad_fn=) , return= 176060.57182978964\n", + "probs of actions: tensor([0.7892, 0.7928, 0.7984, 0.8025, 0.8054, 0.8077, 0.8092, 0.8099, 0.8100,\n", + " 0.8098, 0.8090, 0.8079, 0.8065, 0.8048, 0.8029, 0.8008, 0.7986, 0.7963,\n", + " 0.7939, 0.7914, 0.7889, 0.0451, 0.7835, 0.7815, 0.0303],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "591000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 31, 34, 34, 34, 34, 34, 34, 34, 34, 31, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(193.1143, grad_fn=) , actor= tensor(11.1014, grad_fn=) , critic= tensor(1820.1298, grad_fn=) , return= 175566.12338598282\n", + "probs of actions: tensor([0.7807, 0.0091, 0.7906, 0.7944, 0.7975, 0.7999, 0.8015, 0.8022, 0.8024,\n", + " 0.8022, 0.0088, 0.8007, 0.7990, 0.7974, 0.7955, 0.7934, 0.7913, 0.7890,\n", + " 0.7866, 0.7841, 0.7816, 0.7791, 0.7765, 0.7739, 0.7714],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "592000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 41, 34,\n", + " 34, 34, 32, 34, 42, 42, 34])\n", + "loss= tensor(147.4684, grad_fn=) , actor= tensor(-35.0571, grad_fn=) , critic= tensor(1825.2557, grad_fn=) , return= 175635.82238253858\n", + "probs of actions: tensor([0.7712, 0.7750, 0.7808, 0.7850, 0.7881, 0.7905, 0.7920, 0.7928, 0.0333,\n", + " 0.7916, 0.7920, 0.7908, 0.7894, 0.7876, 0.7855, 0.7834, 0.0330, 0.7779,\n", + " 0.7768, 0.7740, 0.0073, 0.7688, 0.0075, 0.0076, 0.7605],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "593000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 46, 34, 34, 34, 34, 34, 38, 37, 34, 34,\n", + " 40, 34, 34, 34, 34, 29, 34])\n", + "loss= tensor(173.2590, grad_fn=) , actor= tensor(-9.3135, grad_fn=) , critic= tensor(1825.7250, grad_fn=) , return= 176206.79442280004\n", + "probs of actions: tensor([0.7737, 0.7775, 0.7832, 0.7874, 0.7904, 0.7927, 0.7943, 0.7950, 0.0058,\n", + " 0.7930, 0.7943, 0.7930, 0.7915, 0.7897, 0.0115, 0.0480, 0.7831, 0.7812,\n", + " 0.0038, 0.7752, 0.7737, 0.7709, 0.7681, 0.0318, 0.7632],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "594000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 22, 34, 41, 34, 34, 39, 34, 37, 44, 34, 31, 34, 29, 34, 34, 34,\n", + " 34, 34, 32, 34, 34, 29, 34])\n", + "loss= tensor(197.0891, grad_fn=) , actor= tensor(14.0693, grad_fn=) , critic= tensor(1830.1987, grad_fn=) , return= 175569.3084269277\n", + "probs of actions: tensor([0.7680, 0.7719, 0.0012, 0.7834, 0.0352, 0.7866, 0.7893, 0.0098, 0.7896,\n", + " 0.0498, 0.0050, 0.7871, 0.0087, 0.7857, 0.0281, 0.7816, 0.7785, 0.7763,\n", + " 0.7739, 0.7714, 0.0073, 0.7664, 0.7635, 0.0319, 0.7588],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "595000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 42,\n", + " 29, 34, 34, 34, 37, 34, 34])\n", + "loss= tensor(172.0085, grad_fn=) , actor= tensor(-10.7231, grad_fn=) , critic= tensor(1827.3167, grad_fn=) , return= 175838.84652663633\n", + "probs of actions: tensor([0.0384, 0.7668, 0.7742, 0.7785, 0.7817, 0.7841, 0.7857, 0.7865, 0.7866,\n", + " 0.7864, 0.7857, 0.7845, 0.7832, 0.7814, 0.7794, 0.7773, 0.0536, 0.0071,\n", + " 0.0305, 0.7689, 0.7650, 0.7625, 0.0549, 0.7570, 0.7549],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "596000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 38, 34, 34, 34, 34, 34, 34, 38, 34,\n", + " 34, 42, 34, 34, 34, 34, 34])\n", + "loss= tensor(183.1155, grad_fn=) , actor= tensor(0.7819, grad_fn=) , critic= tensor(1823.3359, grad_fn=) , return= 176063.77690943985\n", + "probs of actions: tensor([0.0352, 0.7836, 0.7908, 0.7949, 0.7980, 0.8003, 0.8019, 0.8026, 0.8028,\n", + " 0.0098, 0.8013, 0.8008, 0.7994, 0.7977, 0.7957, 0.7936, 0.0106, 0.7887,\n", + " 0.7870, 0.0065, 0.7809, 0.7799, 0.7770, 0.7743, 0.7716],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "597000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 29, 41, 34, 34, 34, 37, 34, 39, 34, 34, 34, 41, 34, 34, 34, 34,\n", + " 26, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(199.7020, grad_fn=) , actor= tensor(15.1337, grad_fn=) , critic= tensor(1845.6831, grad_fn=) , return= 175741.27330981765\n", + "probs of actions: tensor([0.7819, 0.7856, 0.0249, 0.0333, 0.7973, 0.8006, 0.8021, 0.0478, 0.8025,\n", + " 0.0100, 0.8013, 0.8009, 0.7994, 0.0305, 0.7949, 0.7939, 0.7915, 0.7891,\n", + " 0.0024, 0.7848, 0.7808, 0.7785, 0.7761, 0.7735, 0.7710],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "598000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 42, 41, 37, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 38])\n", + "loss= tensor(177.0667, grad_fn=) , actor= tensor(-8.1724, grad_fn=) , critic= tensor(1852.3904, grad_fn=) , return= 175755.64422674937\n", + "probs of actions: tensor([0.7999, 0.8034, 0.8088, 0.8127, 0.8156, 0.8178, 0.8192, 0.8199, 0.8199,\n", + " 0.8197, 0.0060, 0.0291, 0.0439, 0.8150, 0.8133, 0.8111, 0.8089, 0.8066,\n", + " 0.8042, 0.8018, 0.7993, 0.7968, 0.7943, 0.7918, 0.0107],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "599000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 42, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 20])\n", + "loss= tensor(150.1053, grad_fn=) , actor= tensor(-27.9874, grad_fn=) , critic= tensor(1780.9268, grad_fn=) , return= 176604.22770286244\n", + "probs of actions: tensor([8.0928e-01, 8.1273e-01, 8.1803e-01, 8.2191e-01, 8.2472e-01, 8.2692e-01,\n", + " 8.2835e-01, 8.2900e-01, 8.2909e-01, 8.2886e-01, 8.2813e-01, 8.2708e-01,\n", + " 8.2581e-01, 8.2422e-01, 8.2236e-01, 6.3522e-03, 8.1733e-01, 8.1660e-01,\n", + " 8.1409e-01, 8.1159e-01, 8.0912e-01, 8.0668e-01, 8.0422e-01, 8.0177e-01,\n", + " 8.0302e-04], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "600000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 34, 25, 34, 34, 34, 34, 29, 34, 29, 16, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 35])\n", + "loss= tensor(186.9990, grad_fn=) , actor= tensor(8.5660, grad_fn=) , critic= tensor(1784.3300, grad_fn=) , return= 174413.55911890604\n", + "probs of actions: tensor([8.2769e-01, 3.9637e-02, 8.3542e-01, 1.0599e-03, 8.4295e-01, 8.4412e-01,\n", + " 8.4538e-01, 8.4594e-01, 2.0615e-02, 8.4619e-01, 2.1180e-02, 4.3590e-04,\n", + " 8.4363e-01, 8.4020e-01, 8.3878e-01, 8.3699e-01, 8.3513e-01, 8.3309e-01,\n", + " 8.3090e-01, 8.2862e-01, 8.2631e-01, 8.2399e-01, 8.2164e-01, 8.1927e-01,\n", + " 5.8535e-03], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "601000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 34, 38, 38, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 44, 34,\n", + " 34, 34, 34, 34, 34, 34, 44])\n", + "loss= tensor(184.3396, grad_fn=) , actor= tensor(-3.4212, grad_fn=) , critic= tensor(1877.6083, grad_fn=) , return= 175359.91083356994\n", + "probs of actions: tensor([0.8365, 0.0382, 0.8439, 0.0074, 0.0073, 0.8518, 0.8535, 0.8540, 0.8540,\n", + " 0.8536, 0.8529, 0.8519, 0.8506, 0.8491, 0.8473, 0.0356, 0.0040, 0.8404,\n", + " 0.8399, 0.8373, 0.8349, 0.8325, 0.8301, 0.8278, 0.0046],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "602000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 46, 34, 34, 34, 34, 34, 41, 34, 34, 29, 34, 34, 34, 34, 34, 34,\n", + " 34, 32, 34, 34, 34, 34, 34])\n", + "loss= tensor(194.0251, grad_fn=) , actor= tensor(9.2779, grad_fn=) , critic= tensor(1847.4719, grad_fn=) , return= 175785.43454255973\n", + "probs of actions: tensor([0.8451, 0.8480, 0.0039, 0.8543, 0.8583, 0.8602, 0.8613, 0.8618, 0.0212,\n", + " 0.8605, 0.8607, 0.0212, 0.8587, 0.8566, 0.8549, 0.8531, 0.8511, 0.8491,\n", + " 0.8470, 0.0046, 0.8427, 0.8402, 0.8380, 0.8358, 0.8335],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "603000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34,\n", + " 27, 34, 34, 34, 34, 31, 31])\n", + "loss= tensor(140.1531, grad_fn=) , actor= tensor(-42.1279, grad_fn=) , critic= tensor(1822.8101, grad_fn=) , return= 175888.05919476645\n", + "probs of actions: tensor([0.8522, 0.8550, 0.8595, 0.8627, 0.8650, 0.8668, 0.8679, 0.8683, 0.8682,\n", + " 0.8678, 0.8670, 0.8660, 0.8648, 0.8633, 0.0199, 0.8591, 0.8581, 0.8560,\n", + " 0.0014, 0.8522, 0.8489, 0.8469, 0.8448, 0.0066, 0.0067],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "604000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.3591, grad_fn=) , actor= tensor(-0.3797, grad_fn=) , critic= tensor(1827.3875, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.8487, 0.8515, 0.8560, 0.8593, 0.8616, 0.8634, 0.8645, 0.8649, 0.8648,\n", + " 0.8644, 0.8636, 0.8626, 0.8614, 0.8599, 0.8582, 0.8562, 0.8543, 0.8523,\n", + " 0.8502, 0.8480, 0.8458, 0.8436, 0.8413, 0.8391, 0.8368],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "605000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 29, 34, 34, 26, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 29, 34, 34, 34, 34, 45, 34])\n", + "loss= tensor(170.1425, grad_fn=) , actor= tensor(-11.7643, grad_fn=) , critic= tensor(1819.0685, grad_fn=) , return= 174837.33135351702\n", + "probs of actions: tensor([0.8500, 0.8528, 0.8573, 0.0164, 0.8633, 0.8647, 0.0014, 0.8669, 0.8660,\n", + " 0.8656, 0.8649, 0.8639, 0.8627, 0.8612, 0.8595, 0.8576, 0.8557, 0.8537,\n", + " 0.0200, 0.8499, 0.8469, 0.8449, 0.8428, 0.0009, 0.8374],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "606000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 42, 37, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 22,\n", + " 34, 37, 37, 34, 34, 34, 42])\n", + "loss= tensor(169.7115, grad_fn=) , actor= tensor(-18.0853, grad_fn=) , critic= tensor(1877.9672, grad_fn=) , return= 175091.8235554241\n", + "probs of actions: tensor([0.8539, 0.8567, 0.8612, 0.8644, 0.8667, 0.0049, 0.0326, 0.8698, 0.8701,\n", + " 0.0078, 0.8684, 0.8680, 0.8668, 0.8653, 0.8636, 0.8617, 0.8598, 0.0010,\n", + " 0.8567, 0.0339, 0.0341, 0.8490, 0.8473, 0.8450, 0.0059],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "607000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 43, 34, 37, 34, 34, 34, 34,\n", + " 34, 34, 44, 34, 34, 34, 34])\n", + "loss= tensor(181.2020, grad_fn=) , actor= tensor(-0.3278, grad_fn=) , critic= tensor(1815.2979, grad_fn=) , return= 176077.83529608074\n", + "probs of actions: tensor([0.8431, 0.8460, 0.8506, 0.8540, 0.8563, 0.8582, 0.8593, 0.8598, 0.0351,\n", + " 0.8589, 0.8586, 0.0070, 0.8553, 0.0353, 0.8528, 0.8512, 0.8491, 0.8470,\n", + " 0.8448, 0.8426, 0.0045, 0.8371, 0.8365, 0.8338, 0.8313],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "608000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(191.3853, grad_fn=) , actor= tensor(7.5846, grad_fn=) , critic= tensor(1838.0077, grad_fn=) , return= 175822.33347042403\n", + "probs of actions: tensor([0.8498, 0.0056, 0.8559, 0.8603, 0.8626, 0.8644, 0.8655, 0.8659, 0.8658,\n", + " 0.8654, 0.8646, 0.8635, 0.8622, 0.8607, 0.8590, 0.8570, 0.8550, 0.8530,\n", + " 0.8509, 0.8487, 0.8464, 0.8442, 0.8420, 0.8397, 0.8374],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "609000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 41, 34, 34,\n", + " 34, 34, 37, 34, 34, 34, 34])\n", + "loss= tensor(187.3682, grad_fn=) , actor= tensor(4.5952, grad_fn=) , critic= tensor(1827.7292, grad_fn=) , return= 176107.05513103947\n", + "probs of actions: tensor([0.8591, 0.0089, 0.8655, 0.8693, 0.8716, 0.8733, 0.8743, 0.8747, 0.8746,\n", + " 0.8742, 0.8735, 0.0069, 0.8704, 0.8701, 0.8683, 0.0194, 0.8637, 0.8628,\n", + " 0.8605, 0.8583, 0.0307, 0.8537, 0.8519, 0.8496, 0.8474],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "610000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 37, 34, 34, 34])\n", + "loss= tensor(174.0657, grad_fn=) , actor= tensor(-8.1178, grad_fn=) , critic= tensor(1821.8345, grad_fn=) , return= 175745.57182978964\n", + "probs of actions: tensor([0.8620, 0.8646, 0.8689, 0.8720, 0.8742, 0.8759, 0.8769, 0.8773, 0.8771,\n", + " 0.8767, 0.8760, 0.8749, 0.8738, 0.8723, 0.8706, 0.8687, 0.8668, 0.8649,\n", + " 0.8628, 0.8607, 0.8586, 0.0296, 0.8540, 0.8523, 0.8500],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "611000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 36, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(191.2178, grad_fn=) , actor= tensor(8.2648, grad_fn=) , critic= tensor(1829.5309, grad_fn=) , return= 175760.61069846147\n", + "probs of actions: tensor([0.8659, 0.8686, 0.8728, 0.8759, 0.8781, 0.8798, 0.8808, 0.8812, 0.0011,\n", + " 0.8805, 0.8800, 0.8790, 0.8778, 0.8764, 0.8748, 0.8729, 0.8711, 0.8692,\n", + " 0.8672, 0.8651, 0.8630, 0.8609, 0.8588, 0.8567, 0.8545],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "612000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.5917, grad_fn=) , actor= tensor(6.6709, grad_fn=) , critic= tensor(1829.2080, grad_fn=) , return= 175636.7447540575\n", + "probs of actions: tensor([0.8580, 0.8608, 0.8651, 0.8683, 0.8705, 0.0280, 0.8730, 0.8737, 0.8736,\n", + " 0.8732, 0.8725, 0.8714, 0.8702, 0.0182, 0.8674, 0.8649, 0.8631, 0.8612,\n", + " 0.8592, 0.8570, 0.8549, 0.8527, 0.8505, 0.8483, 0.8461],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "613000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 34, 34, 46, 34, 34, 41, 34, 34, 34, 34, 34, 38, 34, 34,\n", + " 29, 43, 34, 34, 37, 34, 31])\n", + "loss= tensor(159.9970, grad_fn=) , actor= tensor(-22.1985, grad_fn=) , critic= tensor(1821.9551, grad_fn=) , return= 176286.26946693618\n", + "probs of actions: tensor([0.0356, 0.8443, 0.8495, 0.8528, 0.8552, 0.8570, 0.0034, 0.8571, 0.8586,\n", + " 0.0212, 0.8565, 0.8563, 0.8549, 0.8533, 0.8514, 0.0084, 0.8469, 0.8455,\n", + " 0.0228, 0.0081, 0.8373, 0.8367, 0.0348, 0.8314, 0.0066],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "614000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 39, 34, 34, 34, 34, 37, 34,\n", + " 34, 41, 34, 34, 34, 34, 34])\n", + "loss= tensor(183.3295, grad_fn=) , actor= tensor(1.4327, grad_fn=) , critic= tensor(1818.9675, grad_fn=) , return= 176043.49359930423\n", + "probs of actions: tensor([0.8446, 0.8476, 0.8523, 0.8556, 0.8581, 0.8600, 0.8611, 0.8616, 0.0308,\n", + " 0.8609, 0.8605, 0.0094, 0.8577, 0.8569, 0.8550, 0.8530, 0.0317, 0.8487,\n", + " 0.8470, 0.0228, 0.8418, 0.8407, 0.8382, 0.8357, 0.8334],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "615000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 45, 34, 34, 31, 34, 34, 37, 41, 34, 34, 34, 34, 34, 34, 41, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(212.4773, grad_fn=) , actor= tensor(28.1898, grad_fn=) , critic= tensor(1842.8754, grad_fn=) , return= 176062.08238787486\n", + "probs of actions: tensor([8.3759e-01, 8.0156e-04, 8.4370e-01, 8.4893e-01, 4.7951e-03, 8.5375e-01,\n", + " 8.5467e-01, 3.2661e-02, 2.3224e-02, 8.5405e-01, 8.5429e-01, 8.5314e-01,\n", + " 8.5187e-01, 8.5032e-01, 8.4853e-01, 2.3185e-02, 8.4381e-01, 8.4287e-01,\n", + " 8.4051e-01, 8.3815e-01, 8.3582e-01, 8.3352e-01, 8.3119e-01, 8.2887e-01,\n", + " 8.2654e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "616000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 38, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(186.5800, grad_fn=) , actor= tensor(3.6355, grad_fn=) , critic= tensor(1829.4452, grad_fn=) , return= 175797.60862324658\n", + "probs of actions: tensor([0.8522, 0.8551, 0.8597, 0.8631, 0.8655, 0.8674, 0.8686, 0.8691, 0.8691,\n", + " 0.8688, 0.8681, 0.0066, 0.8656, 0.8647, 0.8630, 0.8611, 0.8591, 0.8572,\n", + " 0.8551, 0.8530, 0.8508, 0.8486, 0.8465, 0.8442, 0.8420],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "617000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34,\n", + " 34, 34, 34, 41, 34, 34, 41])\n", + "loss= tensor(161.2889, grad_fn=) , actor= tensor(-23.1659, grad_fn=) , critic= tensor(1844.5483, grad_fn=) , return= 175091.34284158226\n", + "probs of actions: tensor([0.8460, 0.8490, 0.8537, 0.8570, 0.8595, 0.8614, 0.8626, 0.8631, 0.8631,\n", + " 0.8628, 0.8620, 0.8610, 0.8598, 0.8583, 0.0202, 0.8551, 0.8524, 0.8505,\n", + " 0.8484, 0.8463, 0.8441, 0.0228, 0.8390, 0.8379, 0.0232],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "618000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 43, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(168.3477, grad_fn=) , actor= tensor(-12.0852, grad_fn=) , critic= tensor(1804.3289, grad_fn=) , return= 175696.02672204166\n", + "probs of actions: tensor([0.8560, 0.8588, 0.8634, 0.0156, 0.8694, 0.8708, 0.8719, 0.8724, 0.8724,\n", + " 0.8720, 0.8713, 0.8703, 0.8691, 0.8677, 0.8660, 0.8642, 0.8622, 0.0284,\n", + " 0.0079, 0.8554, 0.8546, 0.8522, 0.8498, 0.0299, 0.8450],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "619000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 49, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 41, 34])\n", + "loss= tensor(187.4334, grad_fn=) , actor= tensor(2.6570, grad_fn=) , critic= tensor(1847.7642, grad_fn=) , return= 175754.20394058336\n", + "probs of actions: tensor([8.6597e-01, 8.6869e-01, 8.7306e-01, 2.2643e-04, 8.7667e-01, 8.8030e-01,\n", + " 8.8145e-01, 8.8194e-01, 8.8192e-01, 8.8160e-01, 8.8093e-01, 8.7998e-01,\n", + " 8.7889e-01, 8.0962e-03, 8.7554e-01, 8.7441e-01, 8.7248e-01, 8.7057e-01,\n", + " 8.6858e-01, 8.6653e-01, 8.6448e-01, 8.6242e-01, 8.6032e-01, 2.0231e-02,\n", + " 8.5555e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "620000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 37, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4864, grad_fn=) , actor= tensor(1.0035, grad_fn=) , critic= tensor(1814.8290, grad_fn=) , return= 175629.0764240607\n", + "probs of actions: tensor([0.8608, 0.8636, 0.8681, 0.8714, 0.8737, 0.8756, 0.0141, 0.8777, 0.8772,\n", + " 0.8769, 0.8762, 0.8753, 0.8741, 0.8728, 0.8712, 0.8694, 0.8675, 0.8656,\n", + " 0.8636, 0.0272, 0.8592, 0.8575, 0.8553, 0.8531, 0.8509],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "621000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(187.2435, grad_fn=) , actor= tensor(4.2909, grad_fn=) , critic= tensor(1829.5259, grad_fn=) , return= 175840.1926604132\n", + "probs of actions: tensor([0.8655, 0.8683, 0.8726, 0.0273, 0.8777, 0.8798, 0.8809, 0.8813, 0.8813,\n", + " 0.8809, 0.8802, 0.8792, 0.8781, 0.8767, 0.8751, 0.8733, 0.0270, 0.8693,\n", + " 0.8678, 0.8657, 0.8635, 0.8614, 0.8593, 0.8572, 0.8550],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "622000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 39, 34, 34, 34, 34])\n", + "loss= tensor(173.1263, grad_fn=) , actor= tensor(-8.6896, grad_fn=) , critic= tensor(1818.1592, grad_fn=) , return= 175784.65872101797\n", + "probs of actions: tensor([0.8664, 0.8691, 0.8735, 0.8766, 0.8789, 0.8807, 0.8818, 0.8823, 0.8823,\n", + " 0.8820, 0.8813, 0.8804, 0.8793, 0.8779, 0.8764, 0.8746, 0.8728, 0.8710,\n", + " 0.8690, 0.8670, 0.0084, 0.8625, 0.8612, 0.8589, 0.8567],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "623000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34,\n", + " 34, 38, 34, 34, 34, 34, 41])\n", + "loss= tensor(175.3332, grad_fn=) , actor= tensor(-11.4179, grad_fn=) , critic= tensor(1867.5106, grad_fn=) , return= 175315.67713532023\n", + "probs of actions: tensor([0.0194, 0.8769, 0.8822, 0.8853, 0.8875, 0.0169, 0.8896, 0.8909, 0.8909,\n", + " 0.8906, 0.8899, 0.8891, 0.8880, 0.8867, 0.0144, 0.8840, 0.8816, 0.8800,\n", + " 0.8782, 0.0069, 0.8740, 0.8726, 0.8705, 0.8685, 0.0176],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "624000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 37, 34, 34, 35])\n", + "loss= tensor(154.0535, grad_fn=) , actor= tensor(-28.5230, grad_fn=) , critic= tensor(1825.7646, grad_fn=) , return= 175676.57182978964\n", + "probs of actions: tensor([0.8682, 0.8709, 0.8753, 0.8784, 0.8807, 0.8826, 0.8837, 0.8842, 0.8842,\n", + " 0.8839, 0.8833, 0.8824, 0.8813, 0.8800, 0.8785, 0.8768, 0.8750, 0.8732,\n", + " 0.8712, 0.8693, 0.8673, 0.0282, 0.8630, 0.8613, 0.0059],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "625000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4352, grad_fn=) , actor= tensor(-0.3051, grad_fn=) , critic= tensor(1827.4028, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.8723, 0.8749, 0.8791, 0.8822, 0.8844, 0.8862, 0.8872, 0.8877, 0.8876,\n", + " 0.8873, 0.8867, 0.8857, 0.8847, 0.8833, 0.8818, 0.8801, 0.8783, 0.8764,\n", + " 0.8745, 0.8726, 0.8706, 0.8685, 0.8665, 0.8644, 0.8624],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "626000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.6082, grad_fn=) , actor= tensor(6.1579, grad_fn=) , critic= tensor(1834.5038, grad_fn=) , return= 175857.8306895082\n", + "probs of actions: tensor([0.8889, 0.8913, 0.8951, 0.8979, 0.8999, 0.9015, 0.9025, 0.9029, 0.0058,\n", + " 0.9016, 0.9020, 0.9011, 0.9000, 0.8988, 0.8973, 0.8957, 0.8940, 0.8924,\n", + " 0.8906, 0.8887, 0.8869, 0.8850, 0.8831, 0.8812, 0.8793],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "627000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34,\n", + " 34, 34, 34, 37, 34, 39, 34])\n", + "loss= tensor(156.0961, grad_fn=) , actor= tensor(-26.0193, grad_fn=) , critic= tensor(1821.1536, grad_fn=) , return= 175708.8375811207\n", + "probs of actions: tensor([0.8932, 0.8956, 0.8993, 0.9021, 0.9041, 0.9056, 0.9066, 0.9070, 0.9069,\n", + " 0.9066, 0.9060, 0.9052, 0.9042, 0.9030, 0.9017, 0.0059, 0.8981, 0.8971,\n", + " 0.8952, 0.8934, 0.8916, 0.0211, 0.8877, 0.0067, 0.8839],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "628000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 41, 29, 34, 34, 34, 8, 43, 34, 34, 34,\n", + " 34, 20, 34, 34, 34, 34, 46])\n", + "loss= tensor(164.4417, grad_fn=) , actor= tensor(-22.7868, grad_fn=) , critic= tensor(1872.2849, grad_fn=) , return= 173137.62659266475\n", + "probs of actions: tensor([9.0210e-01, 9.0433e-01, 9.0788e-01, 9.1044e-01, 9.1231e-01, 9.1375e-01,\n", + " 9.1461e-01, 9.1496e-01, 1.1813e-02, 1.1170e-02, 9.1447e-01, 9.1315e-01,\n", + " 9.1223e-01, 2.8896e-05, 5.4230e-03, 9.0662e-01, 9.0658e-01, 9.0509e-01,\n", + " 9.0350e-01, 3.5643e-04, 9.0092e-01, 8.9762e-01, 8.9624e-01, 8.9467e-01,\n", + " 3.0583e-03], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "629000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 28, 34, 34, 42, 34, 34, 34, 34, 34, 42, 34, 34, 34, 34, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(201.9765, grad_fn=) , actor= tensor(19.3765, grad_fn=) , critic= tensor(1826.0001, grad_fn=) , return= 175873.04404790062\n", + "probs of actions: tensor([0.9037, 0.9059, 0.0020, 0.9124, 0.9138, 0.0033, 0.9154, 0.9164, 0.9164,\n", + " 0.9160, 0.9154, 0.0033, 0.9131, 0.9128, 0.9114, 0.9099, 0.9083, 0.9067,\n", + " 0.0187, 0.9032, 0.9019, 0.9001, 0.8983, 0.8966, 0.8948],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "630000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 42, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 25, 34, 34])\n", + "loss= tensor(171.2487, grad_fn=) , actor= tensor(-13.4955, grad_fn=) , critic= tensor(1847.4419, grad_fn=) , return= 175765.864425175\n", + "probs of actions: tensor([0.8962, 0.8986, 0.9023, 0.9050, 0.9069, 0.9084, 0.9093, 0.9097, 0.9096,\n", + " 0.0035, 0.9080, 0.9080, 0.9070, 0.9058, 0.9044, 0.9028, 0.9012, 0.8996,\n", + " 0.8979, 0.8961, 0.8943, 0.8926, 0.0009, 0.8894, 0.8865],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "631000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 32, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(187.9598, grad_fn=) , actor= tensor(6.2875, grad_fn=) , critic= tensor(1816.7227, grad_fn=) , return= 175783.14522534353\n", + "probs of actions: tensor([0.9029, 0.9051, 0.9086, 0.9112, 0.9131, 0.0024, 0.9155, 0.9157, 0.9157,\n", + " 0.9154, 0.9148, 0.9140, 0.9131, 0.9119, 0.9106, 0.9092, 0.9076, 0.0115,\n", + " 0.9039, 0.9031, 0.9013, 0.8995, 0.8977, 0.8959, 0.8941],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "632000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 24, 34, 34, 36, 34, 34])\n", + "loss= tensor(155.0125, grad_fn=) , actor= tensor(-29.0554, grad_fn=) , critic= tensor(1840.6791, grad_fn=) , return= 175411.33075562803\n", + "probs of actions: tensor([0.9044, 0.9066, 0.9101, 0.9126, 0.9144, 0.9158, 0.9167, 0.9170, 0.9169,\n", + " 0.9166, 0.9160, 0.9152, 0.9143, 0.9131, 0.9118, 0.9104, 0.9088, 0.9072,\n", + " 0.9056, 0.0012, 0.9028, 0.9000, 0.0010, 0.8968, 0.8953],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "633000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 31, 34, 34, 34, 43, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(185.8708, grad_fn=) , actor= tensor(3.8955, grad_fn=) , critic= tensor(1819.7531, grad_fn=) , return= 175775.9769203224\n", + "probs of actions: tensor([0.8986, 0.9008, 0.9044, 0.9070, 0.9089, 0.9104, 0.9113, 0.9116, 0.9115,\n", + " 0.9112, 0.9106, 0.0037, 0.9089, 0.9075, 0.9061, 0.0056, 0.9024, 0.9018,\n", + " 0.8999, 0.8980, 0.8962, 0.8944, 0.8926, 0.8908, 0.8889],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "634000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 38, 34, 34, 34, 34, 34, 34, 28,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(184.4478, grad_fn=) , actor= tensor(0.9306, grad_fn=) , critic= tensor(1835.1720, grad_fn=) , return= 175624.89911943267\n", + "probs of actions: tensor([0.8950, 0.8973, 0.9010, 0.9037, 0.9056, 0.9071, 0.9079, 0.9083, 0.9082,\n", + " 0.9078, 0.0047, 0.9060, 0.9054, 0.9041, 0.9026, 0.9010, 0.8993, 0.0023,\n", + " 0.8963, 0.8938, 0.8921, 0.8903, 0.8885, 0.8867, 0.8848],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "635000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 41, 34,\n", + " 37, 34, 34, 31, 34, 34, 34])\n", + "loss= tensor(170.2924, grad_fn=) , actor= tensor(-12.3829, grad_fn=) , critic= tensor(1826.7537, grad_fn=) , return= 175948.2801512768\n", + "probs of actions: tensor([0.8893, 0.8917, 0.8955, 0.8983, 0.9002, 0.9018, 0.9027, 0.9030, 0.9029,\n", + " 0.9025, 0.0065, 0.9005, 0.9000, 0.8986, 0.8971, 0.8955, 0.0133, 0.8913,\n", + " 0.0224, 0.8882, 0.8866, 0.0051, 0.8828, 0.8804, 0.8785],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "636000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 26, 34, 36, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(203.7798, grad_fn=) , actor= tensor(22.0367, grad_fn=) , critic= tensor(1817.4318, grad_fn=) , return= 175574.61273292234\n", + "probs of actions: tensor([8.9018e-01, 8.9257e-01, 8.9637e-01, 8.9910e-01, 9.0106e-01, 1.1806e-03,\n", + " 9.0404e-01, 8.1202e-04, 9.0348e-01, 9.0334e-01, 9.0268e-01, 9.0173e-01,\n", + " 2.1080e-02, 8.9918e-01, 8.9804e-01, 8.9636e-01, 8.9457e-01, 8.9284e-01,\n", + " 8.9104e-01, 8.8916e-01, 8.8729e-01, 8.8540e-01, 8.8348e-01, 8.8155e-01,\n", + " 8.7961e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "637000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(179.0687, grad_fn=) , actor= tensor(-4.7635, grad_fn=) , critic= tensor(1838.3221, grad_fn=) , return= 175781.72261491916\n", + "probs of actions: tensor([0.8840, 0.8864, 0.8904, 0.8932, 0.8952, 0.0059, 0.8968, 0.8982, 0.8980,\n", + " 0.8976, 0.8969, 0.8959, 0.8948, 0.8935, 0.8920, 0.8903, 0.8885, 0.8867,\n", + " 0.8848, 0.8829, 0.8809, 0.8790, 0.8770, 0.0237, 0.8727],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "638000 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 34, 34, 37, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 39])\n", + "loss= tensor(186.3418, grad_fn=) , actor= tensor(0.5809, grad_fn=) , critic= tensor(1857.6084, grad_fn=) , return= 175474.2078288396\n", + "probs of actions: tensor([0.0049, 0.8838, 0.8874, 0.0231, 0.0144, 0.8934, 0.8951, 0.8955, 0.8955,\n", + " 0.8951, 0.8944, 0.8935, 0.8924, 0.8911, 0.8895, 0.8878, 0.8860, 0.8842,\n", + " 0.8824, 0.8804, 0.8785, 0.8765, 0.8745, 0.8725, 0.0084],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "639000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(192.0656, grad_fn=) , actor= tensor(8.1725, grad_fn=) , critic= tensor(1838.9310, grad_fn=) , return= 175890.8132255879\n", + "probs of actions: tensor([0.8852, 0.0069, 0.8906, 0.8946, 0.8967, 0.8984, 0.8994, 0.8998, 0.8997,\n", + " 0.8994, 0.8988, 0.8979, 0.8968, 0.8956, 0.0213, 0.8922, 0.8908, 0.8891,\n", + " 0.8872, 0.8853, 0.8834, 0.8815, 0.8795, 0.8776, 0.8756],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "640000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 34, 34, 34, 34, 34, 34, 34, 36, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 41, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(191.2043, grad_fn=) , actor= tensor(9.9842, grad_fn=) , critic= tensor(1812.2012, grad_fn=) , return= 175747.81896032442\n", + "probs of actions: tensor([0.8902, 0.0133, 0.8970, 0.8993, 0.9013, 0.9028, 0.9037, 0.9041, 0.9040,\n", + " 0.0009, 0.9029, 0.9022, 0.9012, 0.8999, 0.8984, 0.8968, 0.8951, 0.8934,\n", + " 0.0117, 0.8892, 0.8883, 0.8862, 0.8842, 0.8822, 0.8803],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "641000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 44, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 43, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.0440, grad_fn=) , actor= tensor(13.3100, grad_fn=) , critic= tensor(1837.3396, grad_fn=) , return= 176051.58937026796\n", + "probs of actions: tensor([0.8970, 0.8993, 0.0023, 0.9046, 0.9076, 0.9092, 0.9101, 0.9105, 0.9104,\n", + " 0.9101, 0.0181, 0.9085, 0.9078, 0.9066, 0.9052, 0.0052, 0.9014, 0.9008,\n", + " 0.8989, 0.8971, 0.8952, 0.8934, 0.8916, 0.8898, 0.8879],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "642000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.3127, grad_fn=) , actor= tensor(13.2075, grad_fn=) , critic= tensor(1841.0525, grad_fn=) , return= 175886.0304308731\n", + "probs of actions: tensor([0.8976, 0.0040, 0.9026, 0.9061, 0.9080, 0.9095, 0.9104, 0.9107, 0.0181,\n", + " 0.9100, 0.9097, 0.9089, 0.9079, 0.9067, 0.9053, 0.9037, 0.9021, 0.9004,\n", + " 0.8987, 0.8969, 0.8952, 0.8934, 0.8915, 0.8897, 0.8878],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "643000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 29])\n", + "loss= tensor(164.4505, grad_fn=) , actor= tensor(-16.5014, grad_fn=) , critic= tensor(1809.5195, grad_fn=) , return= 176031.33355816206\n", + "probs of actions: tensor([0.8984, 0.9006, 0.9043, 0.9069, 0.9088, 0.9103, 0.9111, 0.9115, 0.9114,\n", + " 0.9111, 0.9104, 0.9096, 0.9086, 0.9074, 0.9060, 0.9045, 0.9028, 0.9012,\n", + " 0.8995, 0.8977, 0.8960, 0.8942, 0.8924, 0.8905, 0.0162],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "644000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 39, 34])\n", + "loss= tensor(173.3843, grad_fn=) , actor= tensor(-10.0338, grad_fn=) , critic= tensor(1834.1807, grad_fn=) , return= 175636.89603347087\n", + "probs of actions: tensor([0.0053, 0.8883, 0.8928, 0.8956, 0.8976, 0.8992, 0.9002, 0.9005, 0.9005,\n", + " 0.9001, 0.8995, 0.8986, 0.8975, 0.8962, 0.8947, 0.8931, 0.8913, 0.8896,\n", + " 0.8878, 0.8859, 0.8840, 0.8821, 0.8802, 0.0072, 0.8759],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "645000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 31, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34,\n", + " 34, 34, 34, 24, 34, 34, 34])\n", + "loss= tensor(175.9334, grad_fn=) , actor= tensor(-7.9780, grad_fn=) , critic= tensor(1839.1134, grad_fn=) , return= 175516.87861800214\n", + "probs of actions: tensor([0.8791, 0.8817, 0.8858, 0.0050, 0.8911, 0.8925, 0.8935, 0.8939, 0.8938,\n", + " 0.8935, 0.8928, 0.8919, 0.8908, 0.8895, 0.8880, 0.8863, 0.0070, 0.8822,\n", + " 0.8811, 0.8790, 0.8770, 0.0015, 0.8736, 0.8702, 0.8685],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "646000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.2147, grad_fn=) , actor= tensor(6.0038, grad_fn=) , critic= tensor(1832.1091, grad_fn=) , return= 175813.27640891031\n", + "probs of actions: tensor([0.8825, 0.8850, 0.8890, 0.8919, 0.8940, 0.8957, 0.8967, 0.8971, 0.0063,\n", + " 0.8962, 0.8961, 0.8952, 0.8941, 0.8928, 0.8913, 0.8897, 0.8879, 0.8861,\n", + " 0.8843, 0.8824, 0.8805, 0.8786, 0.8766, 0.8746, 0.8726],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "647000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 27,\n", + " 29, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.5836, grad_fn=) , actor= tensor(4.9188, grad_fn=) , critic= tensor(1856.6481, grad_fn=) , return= 175583.5567046199\n", + "probs of actions: tensor([0.8784, 0.0072, 0.8839, 0.8880, 0.8902, 0.8919, 0.8929, 0.0072, 0.8928,\n", + " 0.8931, 0.8924, 0.8914, 0.8904, 0.8891, 0.8875, 0.8859, 0.8841, 0.0009,\n", + " 0.0160, 0.8785, 0.8760, 0.8743, 0.8724, 0.8705, 0.8685],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "648000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 38, 29, 34, 34, 34, 34, 34, 34, 34, 34, 17, 34, 41, 34, 44, 34, 35,\n", + " 34, 46, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.6988, grad_fn=) , actor= tensor(12.2918, grad_fn=) , critic= tensor(1774.0703, grad_fn=) , return= 175386.92077738317\n", + "probs of actions: tensor([8.7516e-01, 5.0695e-03, 1.3198e-02, 8.8533e-01, 8.8704e-01, 8.8872e-01,\n", + " 8.8972e-01, 8.9012e-01, 8.9005e-01, 8.8970e-01, 8.8901e-01, 1.5342e-04,\n", + " 8.8795e-01, 1.3065e-02, 8.8313e-01, 2.7385e-03, 8.7976e-01, 6.1069e-03,\n", + " 8.7699e-01, 3.7220e-03, 8.7187e-01, 8.7161e-01, 8.6919e-01, 8.6693e-01,\n", + " 8.6475e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "649000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 37, 34, 34, 34, 34, 37, 34, 34, 34, 34, 37, 34, 34, 35,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.1990, grad_fn=) , actor= tensor(6.9113, grad_fn=) , critic= tensor(1832.8767, grad_fn=) , return= 175928.50705098468\n", + "probs of actions: tensor([0.8759, 0.8785, 0.8826, 0.8855, 0.0279, 0.8890, 0.8903, 0.8907, 0.8906,\n", + " 0.0271, 0.8892, 0.8886, 0.8874, 0.8861, 0.0276, 0.8825, 0.8811, 0.0060,\n", + " 0.8771, 0.8753, 0.8733, 0.8712, 0.8692, 0.8671, 0.8650],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "650000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 26, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(186.8742, grad_fn=) , actor= tensor(4.9212, grad_fn=) , critic= tensor(1819.5297, grad_fn=) , return= 175465.78342787386\n", + "probs of actions: tensor([0.8820, 0.8845, 0.8885, 0.8913, 0.8934, 0.8950, 0.8959, 0.8963, 0.8962,\n", + " 0.8958, 0.8951, 0.0012, 0.8936, 0.8915, 0.8901, 0.8885, 0.8868, 0.8850,\n", + " 0.8832, 0.8813, 0.8794, 0.8774, 0.8754, 0.8734, 0.8714],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "651000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(194.5936, grad_fn=) , actor= tensor(11.7299, grad_fn=) , critic= tensor(1828.6367, grad_fn=) , return= 175649.111316204\n", + "probs of actions: tensor([0.0144, 0.8909, 0.8958, 0.8985, 0.9005, 0.9021, 0.0110, 0.9037, 0.9032,\n", + " 0.9029, 0.9023, 0.9014, 0.9004, 0.8992, 0.8978, 0.8962, 0.8945, 0.8928,\n", + " 0.8911, 0.8892, 0.8874, 0.8855, 0.8836, 0.8817, 0.8798],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "652000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 24, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.3852, grad_fn=) , actor= tensor(15.9998, grad_fn=) , critic= tensor(1813.8533, grad_fn=) , return= 175449.54745078087\n", + "probs of actions: tensor([0.8828, 0.8854, 0.8894, 0.8922, 0.0011, 0.0255, 0.8966, 0.8973, 0.8973,\n", + " 0.8970, 0.8963, 0.8954, 0.8944, 0.8931, 0.8916, 0.8900, 0.8883, 0.8865,\n", + " 0.8847, 0.8828, 0.8809, 0.8790, 0.8771, 0.8751, 0.8731],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "653000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4409, grad_fn=) , actor= tensor(-0.2981, grad_fn=) , critic= tensor(1827.3903, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.8784, 0.8811, 0.8851, 0.8881, 0.8903, 0.8920, 0.8930, 0.8934, 0.8934,\n", + " 0.8931, 0.8924, 0.8915, 0.8905, 0.8892, 0.8878, 0.8861, 0.8844, 0.8826,\n", + " 0.8808, 0.8789, 0.8770, 0.8750, 0.8731, 0.8711, 0.8691],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "654000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.3961, grad_fn=) , actor= tensor(6.3591, grad_fn=) , critic= tensor(1830.3705, grad_fn=) , return= 175900.92228522067\n", + "probs of actions: tensor([0.0294, 0.8824, 0.8869, 0.8899, 0.8920, 0.8937, 0.8947, 0.8952, 0.8952,\n", + " 0.8949, 0.8943, 0.8934, 0.8924, 0.0060, 0.8889, 0.8884, 0.8865, 0.8847,\n", + " 0.8828, 0.8809, 0.8790, 0.8771, 0.8752, 0.8732, 0.8713],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "655000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 43, 34, 34])\n", + "loss= tensor(167.3605, grad_fn=) , actor= tensor(-14.3121, grad_fn=) , critic= tensor(1816.7255, grad_fn=) , return= 175650.66166941574\n", + "probs of actions: tensor([0.8823, 0.8848, 0.8889, 0.8918, 0.8939, 0.8956, 0.8966, 0.8970, 0.8970,\n", + " 0.8967, 0.8961, 0.8952, 0.8942, 0.8930, 0.8915, 0.8899, 0.8882, 0.8865,\n", + " 0.8847, 0.8828, 0.8810, 0.8791, 0.0064, 0.8745, 0.8739],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "656000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 37, 34, 29])\n", + "loss= tensor(159.3930, grad_fn=) , actor= tensor(-21.5667, grad_fn=) , critic= tensor(1809.5966, grad_fn=) , return= 176149.03479410446\n", + "probs of actions: tensor([0.8788, 0.8814, 0.8855, 0.8884, 0.8906, 0.8922, 0.8932, 0.8936, 0.8936,\n", + " 0.8933, 0.0128, 0.8911, 0.8908, 0.8895, 0.8879, 0.8862, 0.8844, 0.8827,\n", + " 0.8808, 0.8789, 0.8769, 0.8750, 0.0278, 0.8708, 0.0173],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "657000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 38, 35])\n", + "loss= tensor(145.3214, grad_fn=) , actor= tensor(-37.9323, grad_fn=) , critic= tensor(1832.5370, grad_fn=) , return= 175544.33355571827\n", + "probs of actions: tensor([0.8851, 0.8877, 0.8916, 0.8945, 0.8966, 0.8982, 0.8992, 0.8996, 0.8996,\n", + " 0.8993, 0.8987, 0.8978, 0.8968, 0.8956, 0.8942, 0.8926, 0.8909, 0.8892,\n", + " 0.8874, 0.8856, 0.8837, 0.8819, 0.8800, 0.0053, 0.0064],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "658000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 37, 34, 34, 34, 34, 34])\n", + "loss= tensor(177.0919, grad_fn=) , actor= tensor(-5.1511, grad_fn=) , critic= tensor(1822.4301, grad_fn=) , return= 175771.45778667773\n", + "probs of actions: tensor([0.8856, 0.8882, 0.8922, 0.8950, 0.8971, 0.8988, 0.8998, 0.9002, 0.9002,\n", + " 0.9000, 0.8994, 0.8985, 0.8976, 0.8964, 0.8950, 0.8934, 0.8918, 0.8901,\n", + " 0.8883, 0.0271, 0.8845, 0.8830, 0.8811, 0.8791, 0.8772],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "659000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 37, 34, 34, 34, 31, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34,\n", + " 34, 37, 34, 34, 34, 34, 40])\n", + "loss= tensor(170.7013, grad_fn=) , actor= tensor(-13.8792, grad_fn=) , critic= tensor(1845.8048, grad_fn=) , return= 175163.35156387268\n", + "probs of actions: tensor([0.8748, 0.8775, 0.0299, 0.8845, 0.8870, 0.8888, 0.0040, 0.8906, 0.8903,\n", + " 0.8901, 0.8895, 0.8886, 0.8876, 0.0144, 0.8852, 0.8830, 0.8814, 0.8797,\n", + " 0.8778, 0.0294, 0.8738, 0.8723, 0.8702, 0.8682, 0.0026],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "660000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 29, 34, 34, 34, 46, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 40])\n", + "loss= tensor(176.6184, grad_fn=) , actor= tensor(-9.1801, grad_fn=) , critic= tensor(1857.9851, grad_fn=) , return= 175299.31067395207\n", + "probs of actions: tensor([0.8836, 0.0125, 0.8907, 0.8930, 0.8951, 0.0030, 0.8964, 0.8982, 0.8981,\n", + " 0.8978, 0.8972, 0.8963, 0.8953, 0.8940, 0.8926, 0.8909, 0.8893, 0.8875,\n", + " 0.8857, 0.8839, 0.8820, 0.8802, 0.8782, 0.8763, 0.0023],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "661000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(178.5727, grad_fn=) , actor= tensor(-3.7661, grad_fn=) , critic= tensor(1823.3879, grad_fn=) , return= 175775.7707968744\n", + "probs of actions: tensor([0.8874, 0.8899, 0.8938, 0.8966, 0.8986, 0.9002, 0.9011, 0.9015, 0.9014,\n", + " 0.9011, 0.9004, 0.8996, 0.8986, 0.8973, 0.8959, 0.8943, 0.8926, 0.8909,\n", + " 0.0264, 0.8871, 0.8856, 0.8837, 0.8818, 0.8798, 0.8779],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "662000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(186.1550, grad_fn=) , actor= tensor(3.2378, grad_fn=) , critic= tensor(1829.1715, grad_fn=) , return= 175822.2551153545\n", + "probs of actions: tensor([0.0275, 0.8967, 0.9009, 0.9035, 0.9055, 0.9070, 0.9079, 0.9083, 0.9083,\n", + " 0.9080, 0.9074, 0.9066, 0.9057, 0.9045, 0.9032, 0.9017, 0.0252, 0.8982,\n", + " 0.8969, 0.8951, 0.8933, 0.8916, 0.8898, 0.8879, 0.8861],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "663000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 44, 34, 34, 34, 41, 34, 34])\n", + "loss= tensor(166.7719, grad_fn=) , actor= tensor(-13.9617, grad_fn=) , critic= tensor(1807.3357, grad_fn=) , return= 175876.47209678235\n", + "probs of actions: tensor([0.9025, 0.9047, 0.9082, 0.9107, 0.9126, 0.9140, 0.9149, 0.9152, 0.0223,\n", + " 0.9146, 0.9144, 0.9135, 0.9126, 0.9115, 0.9102, 0.9088, 0.9072, 0.9057,\n", + " 0.0023, 0.9017, 0.9013, 0.8993, 0.0110, 0.8952, 0.8943],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "664000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 37, 34,\n", + " 29, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(179.0730, grad_fn=) , actor= tensor(-4.1119, grad_fn=) , critic= tensor(1831.8485, grad_fn=) , return= 175706.372839484\n", + "probs of actions: tensor([0.8978, 0.9001, 0.9037, 0.9063, 0.9082, 0.9097, 0.9106, 0.9109, 0.9108,\n", + " 0.9105, 0.9099, 0.9091, 0.9081, 0.0238, 0.9054, 0.9043, 0.0244, 0.9007,\n", + " 0.0131, 0.8980, 0.8956, 0.8940, 0.8923, 0.8905, 0.8887],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "665000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 19, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 35, 34])\n", + "loss= tensor(175.5242, grad_fn=) , actor= tensor(-4.8969, grad_fn=) , critic= tensor(1804.2112, grad_fn=) , return= 175178.3962216129\n", + "probs of actions: tensor([8.9356e-01, 2.5990e-04, 9.0075e-01, 9.0227e-01, 9.0419e-01, 9.0565e-01,\n", + " 9.0653e-01, 9.0686e-01, 9.0677e-01, 9.0643e-01, 9.0580e-01, 9.0493e-01,\n", + " 9.0394e-01, 9.0273e-01, 9.0134e-01, 8.9979e-01, 8.9813e-01, 8.9647e-01,\n", + " 8.9475e-01, 8.9296e-01, 8.9119e-01, 8.8938e-01, 8.8754e-01, 5.5969e-03,\n", + " 8.8375e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "666000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 42, 37, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(198.0915, grad_fn=) , actor= tensor(14.3521, grad_fn=) , critic= tensor(1837.3944, grad_fn=) , return= 176012.02308733287\n", + "probs of actions: tensor([0.8799, 0.8824, 0.8863, 0.8891, 0.8912, 0.8927, 0.0058, 0.8935, 0.8939,\n", + " 0.8935, 0.8928, 0.0034, 0.0292, 0.8894, 0.8881, 0.8863, 0.8844, 0.8825,\n", + " 0.8806, 0.8787, 0.8767, 0.8748, 0.8728, 0.8708, 0.8688],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "667000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 39, 34, 29, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(186.6140, grad_fn=) , actor= tensor(3.6643, grad_fn=) , critic= tensor(1829.4965, grad_fn=) , return= 175734.74436691633\n", + "probs of actions: tensor([0.8620, 0.8647, 0.8691, 0.8722, 0.8744, 0.8762, 0.8772, 0.8777, 0.8776,\n", + " 0.8772, 0.8765, 0.8755, 0.0344, 0.0067, 0.8710, 0.0168, 0.8682, 0.8654,\n", + " 0.8635, 0.8615, 0.8594, 0.8574, 0.8552, 0.8531, 0.8510],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "668000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 37, 34, 41, 34, 29, 34, 34, 34, 34, 34, 34, 34,\n", + " 29, 34, 34, 34, 34, 37, 39])\n", + "loss= tensor(165.7600, grad_fn=) , actor= tensor(-20.2267, grad_fn=) , critic= tensor(1859.8677, grad_fn=) , return= 175183.83822845417\n", + "probs of actions: tensor([0.8577, 0.8604, 0.8648, 0.8680, 0.8702, 0.8720, 0.0354, 0.8732, 0.0147,\n", + " 0.8722, 0.0164, 0.8716, 0.8698, 0.8684, 0.8667, 0.8649, 0.8629, 0.8609,\n", + " 0.0190, 0.8572, 0.8543, 0.8523, 0.8502, 0.0379, 0.0081],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "669000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 27,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(181.7128, grad_fn=) , actor= tensor(-1.7032, grad_fn=) , critic= tensor(1834.1598, grad_fn=) , return= 175649.6529887254\n", + "probs of actions: tensor([0.8616, 0.8643, 0.8687, 0.8719, 0.8741, 0.8759, 0.8770, 0.8774, 0.8773,\n", + " 0.8769, 0.8762, 0.8752, 0.0069, 0.8718, 0.8713, 0.8693, 0.8673, 0.0012,\n", + " 0.8639, 0.8607, 0.8589, 0.8568, 0.8548, 0.8526, 0.8505],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "670000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 37])\n", + "loss= tensor(170.2950, grad_fn=) , actor= tensor(-13.6609, grad_fn=) , critic= tensor(1839.5586, grad_fn=) , return= 175503.33355816206\n", + "probs of actions: tensor([0.8704, 0.8730, 0.8771, 0.8801, 0.8823, 0.8840, 0.8850, 0.8853, 0.8852,\n", + " 0.8849, 0.8841, 0.8831, 0.8820, 0.8806, 0.8790, 0.8773, 0.8754, 0.8735,\n", + " 0.8715, 0.8695, 0.8675, 0.8654, 0.8633, 0.8612, 0.0334],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "671000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 41, 34, 41, 34, 34, 34, 34])\n", + "loss= tensor(174.5398, grad_fn=) , actor= tensor(-6.3310, grad_fn=) , critic= tensor(1808.7083, grad_fn=) , return= 175976.67299449616\n", + "probs of actions: tensor([0.8618, 0.8645, 0.8688, 0.8719, 0.0336, 0.8756, 0.8769, 0.8773, 0.8772,\n", + " 0.8768, 0.8760, 0.8749, 0.8737, 0.8723, 0.8706, 0.8688, 0.8668, 0.8649,\n", + " 0.0146, 0.8600, 0.0148, 0.8561, 0.8549, 0.8524, 0.8501],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "672000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 37, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(184.9485, grad_fn=) , actor= tensor(2.7708, grad_fn=) , critic= tensor(1821.7771, grad_fn=) , return= 175636.54378637765\n", + "probs of actions: tensor([0.8627, 0.8653, 0.8697, 0.8727, 0.8750, 0.8767, 0.8777, 0.8781, 0.8780,\n", + " 0.8776, 0.8769, 0.0159, 0.8750, 0.8730, 0.8715, 0.0336, 0.8675, 0.8660,\n", + " 0.8639, 0.8617, 0.8596, 0.8575, 0.8553, 0.8532, 0.8510],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "673000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 42, 34, 34, 34, 34, 34,\n", + " 34, 34, 41, 34, 34, 39, 34])\n", + "loss= tensor(167.7963, grad_fn=) , actor= tensor(-14.6254, grad_fn=) , critic= tensor(1824.2164, grad_fn=) , return= 175922.43677247313\n", + "probs of actions: tensor([0.8660, 0.8686, 0.8728, 0.8759, 0.8781, 0.8798, 0.8808, 0.0136, 0.8803,\n", + " 0.8808, 0.8800, 0.8789, 0.0042, 0.8756, 0.8750, 0.8731, 0.8711, 0.8691,\n", + " 0.8671, 0.8650, 0.0142, 0.8602, 0.8592, 0.0080, 0.8542],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "674000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 44, 34, 31,\n", + " 34, 34, 34, 34, 43, 34, 34])\n", + "loss= tensor(176.3511, grad_fn=) , actor= tensor(-4.7256, grad_fn=) , critic= tensor(1810.7671, grad_fn=) , return= 175796.88108556965\n", + "probs of actions: tensor([0.0161, 0.8505, 0.8543, 0.8576, 0.0390, 0.8614, 0.8628, 0.8632, 0.8631,\n", + " 0.8627, 0.8618, 0.8607, 0.8594, 0.0154, 0.8554, 0.0028, 0.8513, 0.0064,\n", + " 0.8484, 0.8455, 0.8433, 0.8410, 0.0083, 0.8356, 0.8349],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "675000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 37, 36, 34, 34, 34, 34, 34, 34, 34, 34, 29, 41, 39,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(192.2970, grad_fn=) , actor= tensor(9.9219, grad_fn=) , critic= tensor(1823.7510, grad_fn=) , return= 175895.05839218333\n", + "probs of actions: tensor([0.8417, 0.8446, 0.8493, 0.8526, 0.8550, 0.0387, 0.0014, 0.8581, 0.8582,\n", + " 0.8577, 0.8569, 0.8557, 0.8544, 0.8528, 0.8509, 0.0190, 0.0164, 0.0088,\n", + " 0.8422, 0.8406, 0.8380, 0.8356, 0.8332, 0.8308, 0.8284],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "676000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41, 37, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.4020, grad_fn=) , actor= tensor(6.0864, grad_fn=) , critic= tensor(1833.1560, grad_fn=) , return= 175904.7871713912\n", + "probs of actions: tensor([0.8332, 0.8362, 0.8410, 0.8444, 0.8469, 0.8488, 0.8500, 0.8504, 0.8503,\n", + " 0.8499, 0.0184, 0.0398, 0.8464, 0.8451, 0.8432, 0.8410, 0.8388, 0.8366,\n", + " 0.8343, 0.8320, 0.8296, 0.8273, 0.8249, 0.8225, 0.8201],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "677000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 37, 34, 31, 34, 34, 33, 34, 34, 34, 29, 34, 34, 34, 34,\n", + " 34, 18, 34, 47, 34, 34, 34])\n", + "loss= tensor(174.5776, grad_fn=) , actor= tensor(-8.1338, grad_fn=) , critic= tensor(1827.1134, grad_fn=) , return= 174957.33745476016\n", + "probs of actions: tensor([8.3954e-01, 8.4238e-01, 8.4708e-01, 8.5044e-01, 3.7940e-02, 8.5434e-01,\n", + " 6.1074e-03, 8.5648e-01, 8.5597e-01, 7.7010e-04, 8.5476e-01, 8.5341e-01,\n", + " 8.5209e-01, 1.8302e-02, 8.4903e-01, 8.4631e-01, 8.4424e-01, 8.4213e-01,\n", + " 8.3992e-01, 2.4593e-04, 8.3652e-01, 5.6051e-04, 8.2861e-01, 8.2891e-01,\n", + " 8.2617e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "678000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 41, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(195.0152, grad_fn=) , actor= tensor(10.7255, grad_fn=) , critic= tensor(1842.8973, grad_fn=) , return= 175950.47266650104\n", + "probs of actions: tensor([0.8373, 0.8401, 0.0205, 0.8472, 0.8505, 0.8523, 0.8534, 0.8537, 0.0184,\n", + " 0.8521, 0.8523, 0.8509, 0.8495, 0.8478, 0.8459, 0.8438, 0.8415, 0.8393,\n", + " 0.8370, 0.8346, 0.8323, 0.8299, 0.8275, 0.8250, 0.8226],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "679000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 42, 34, 34, 29, 41, 34, 34, 34, 34, 34, 34, 25, 34, 34, 34, 34,\n", + " 34, 34, 34, 35, 28, 34, 34])\n", + "loss= tensor(181.1131, grad_fn=) , actor= tensor(-2.8679, grad_fn=) , critic= tensor(1839.8102, grad_fn=) , return= 175495.3584438051\n", + "probs of actions: tensor([8.4955e-01, 8.5222e-01, 4.8914e-03, 8.5882e-01, 8.6212e-01, 1.5318e-02,\n", + " 1.7439e-02, 8.6431e-01, 8.6499e-01, 8.6442e-01, 8.6351e-01, 8.6225e-01,\n", + " 8.6089e-01, 8.4881e-04, 8.5809e-01, 8.5491e-01, 8.5294e-01, 8.5091e-01,\n", + " 8.4874e-01, 8.4648e-01, 8.4419e-01, 6.7555e-03, 4.2659e-03, 8.3774e-01,\n", + " 8.3437e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "680000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 30, 34, 34, 34, 34, 34, 34, 36, 37, 37,\n", + " 34, 34, 32, 34, 34, 34, 34])\n", + "loss= tensor(178.4105, grad_fn=) , actor= tensor(-3.6030, grad_fn=) , critic= tensor(1820.1343, grad_fn=) , return= 175735.12056140546\n", + "probs of actions: tensor([0.8472, 0.8498, 0.8543, 0.8575, 0.8597, 0.8614, 0.8624, 0.8627, 0.0009,\n", + " 0.8623, 0.8608, 0.8596, 0.8582, 0.8566, 0.8547, 0.0014, 0.0357, 0.0360,\n", + " 0.8459, 0.8440, 0.0069, 0.8392, 0.8365, 0.8342, 0.8318],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "681000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 35, 37, 34, 29])\n", + "loss= tensor(151.2414, grad_fn=) , actor= tensor(-29.8364, grad_fn=) , critic= tensor(1810.7777, grad_fn=) , return= 176179.35065070514\n", + "probs of actions: tensor([0.8646, 0.8671, 0.8712, 0.8741, 0.8762, 0.8778, 0.8786, 0.8788, 0.0065,\n", + " 0.8769, 0.8773, 0.8760, 0.8746, 0.8730, 0.8712, 0.8693, 0.8672, 0.8651,\n", + " 0.8629, 0.8607, 0.8585, 0.0060, 0.0333, 0.8517, 0.0194],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "682000 adversary: AdversaryModes.myopic\n", + " actions: tensor([32, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 32, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(188.6351, grad_fn=) , actor= tensor(6.1066, grad_fn=) , critic= tensor(1825.2850, grad_fn=) , return= 175627.02671360804\n", + "probs of actions: tensor([0.0053, 0.8715, 0.8753, 0.8782, 0.8802, 0.8818, 0.8827, 0.8829, 0.8827,\n", + " 0.8821, 0.8813, 0.8801, 0.8789, 0.8774, 0.8757, 0.0052, 0.8719, 0.8696,\n", + " 0.8676, 0.8655, 0.8633, 0.8612, 0.8590, 0.8568, 0.8546],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "683000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.3588, grad_fn=) , actor= tensor(-0.3798, grad_fn=) , critic= tensor(1827.3864, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.8618, 0.8644, 0.8687, 0.8717, 0.8739, 0.8756, 0.8765, 0.8768, 0.8766,\n", + " 0.8761, 0.8753, 0.8741, 0.8729, 0.8714, 0.8696, 0.8677, 0.8657, 0.8636,\n", + " 0.8615, 0.8593, 0.8572, 0.8550, 0.8528, 0.8505, 0.8483],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "684000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 37, 34, 34, 34, 37])\n", + "loss= tensor(163.6272, grad_fn=) , actor= tensor(-19.7681, grad_fn=) , critic= tensor(1833.9524, grad_fn=) , return= 175549.8306090006\n", + "probs of actions: tensor([0.8695, 0.8720, 0.8761, 0.8790, 0.8811, 0.8827, 0.8836, 0.8839, 0.8837,\n", + " 0.8832, 0.8824, 0.8813, 0.8801, 0.8787, 0.8770, 0.8751, 0.8732, 0.8712,\n", + " 0.8691, 0.8670, 0.0321, 0.8626, 0.8609, 0.8586, 0.0331],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "685000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 26, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.1521, grad_fn=) , actor= tensor(14.9922, grad_fn=) , critic= tensor(1821.5996, grad_fn=) , return= 175615.81405361404\n", + "probs of actions: tensor([0.8755, 0.0012, 0.8827, 0.8847, 0.8868, 0.8883, 0.8892, 0.8895, 0.0160,\n", + " 0.8881, 0.8883, 0.8871, 0.8859, 0.8845, 0.8829, 0.8811, 0.8792, 0.8773,\n", + " 0.8753, 0.8733, 0.8713, 0.8692, 0.8671, 0.8651, 0.8630],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "686000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(178.2354, grad_fn=) , actor= tensor(-3.9816, grad_fn=) , critic= tensor(1822.1705, grad_fn=) , return= 175839.16856012904\n", + "probs of actions: tensor([0.8798, 0.8822, 0.8861, 0.8889, 0.8909, 0.8924, 0.8933, 0.8936, 0.8934,\n", + " 0.8930, 0.8922, 0.8912, 0.8900, 0.8886, 0.8871, 0.0289, 0.8832, 0.8817,\n", + " 0.0296, 0.8774, 0.8759, 0.8738, 0.8717, 0.8696, 0.8675],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "687000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 38,\n", + " 29, 34, 29, 34, 34, 34, 34])\n", + "loss= tensor(168.0820, grad_fn=) , actor= tensor(-15.7968, grad_fn=) , critic= tensor(1838.7881, grad_fn=) , return= 175543.84358319905\n", + "probs of actions: tensor([0.8873, 0.8896, 0.8933, 0.8960, 0.8979, 0.8993, 0.9002, 0.9004, 0.9002,\n", + " 0.8997, 0.8990, 0.8980, 0.8968, 0.8955, 0.8940, 0.8923, 0.8905, 0.0051,\n", + " 0.0119, 0.8854, 0.0124, 0.8812, 0.8786, 0.8768, 0.8749],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "688000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(184.0401, grad_fn=) , actor= tensor(1.2603, grad_fn=) , critic= tensor(1827.7979, grad_fn=) , return= 175779.94628991745\n", + "probs of actions: tensor([0.8937, 0.8958, 0.8994, 0.9019, 0.9036, 0.9050, 0.9057, 0.9059, 0.9057,\n", + " 0.9051, 0.9044, 0.9034, 0.9022, 0.0237, 0.8992, 0.8979, 0.8960, 0.8941,\n", + " 0.8923, 0.8904, 0.8885, 0.8865, 0.8846, 0.8826, 0.8807],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "689000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 49, 34, 34, 29, 34, 34, 37, 34, 34, 34, 40, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 29, 34, 34, 34])\n", + "loss= tensor(206.0241, grad_fn=) , actor= tensor(20.6305, grad_fn=) , critic= tensor(1853.9362, grad_fn=) , return= 175765.50405155032\n", + "probs of actions: tensor([8.8505e-01, 2.0405e-04, 8.8894e-01, 8.9369e-01, 9.7728e-03, 8.9739e-01,\n", + " 8.9776e-01, 2.5525e-02, 8.9743e-01, 8.9722e-01, 8.9641e-01, 2.1411e-03,\n", + " 8.9362e-01, 8.9292e-01, 8.9125e-01, 8.8944e-01, 8.8753e-01, 8.8560e-01,\n", + " 8.8365e-01, 8.8166e-01, 8.7966e-01, 1.3273e-02, 8.7597e-01, 8.7321e-01,\n", + " 8.7133e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "690000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 38, 34, 16, 16, 34, 34, 34, 34, 34,\n", + " 34, 31, 34, 34, 34, 34, 34])\n", + "loss= tensor(192.6812, grad_fn=) , actor= tensor(12.7383, grad_fn=) , critic= tensor(1799.4282, grad_fn=) , return= 174366.52021516828\n", + "probs of actions: tensor([1.7976e-02, 8.7895e-01, 8.8400e-01, 8.8674e-01, 8.8868e-01, 8.9015e-01,\n", + " 8.9097e-01, 8.9119e-01, 8.9090e-01, 5.2800e-03, 8.8912e-01, 4.4050e-04,\n", + " 4.4451e-04, 8.8617e-01, 8.8289e-01, 8.8159e-01, 8.7991e-01, 8.7809e-01,\n", + " 8.7616e-01, 5.7261e-03, 8.7232e-01, 8.6982e-01, 8.6781e-01, 8.6574e-01,\n", + " 8.6363e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "691000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 31, 37, 34, 34, 29, 34])\n", + "loss= tensor(164.9218, grad_fn=) , actor= tensor(-18.9157, grad_fn=) , critic= tensor(1838.3754, grad_fn=) , return= 175910.9652262985\n", + "probs of actions: tensor([0.8704, 0.8728, 0.8769, 0.0069, 0.8807, 0.8833, 0.8841, 0.8844, 0.8841,\n", + " 0.8835, 0.8827, 0.8815, 0.8802, 0.8787, 0.8770, 0.8751, 0.8731, 0.8711,\n", + " 0.8690, 0.0058, 0.0312, 0.8622, 0.8606, 0.0157, 0.8565],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "692000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 35, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 38])\n", + "loss= tensor(166.6032, grad_fn=) , actor= tensor(-17.9163, grad_fn=) , critic= tensor(1845.1953, grad_fn=) , return= 175514.97454383943\n", + "probs of actions: tensor([0.8831, 0.8854, 0.8892, 0.8919, 0.8938, 0.8952, 0.8960, 0.8963, 0.8960,\n", + " 0.8955, 0.8947, 0.0250, 0.8922, 0.8911, 0.8895, 0.0047, 0.8857, 0.8840,\n", + " 0.8820, 0.8800, 0.8780, 0.8760, 0.8739, 0.8719, 0.0064],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "693000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 44, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 39])\n", + "loss= tensor(174.5233, grad_fn=) , actor= tensor(-10.9306, grad_fn=) , critic= tensor(1854.5394, grad_fn=) , return= 175620.44250551664\n", + "probs of actions: tensor([0.8890, 0.8912, 0.8949, 0.8976, 0.8994, 0.9009, 0.0020, 0.9009, 0.9018,\n", + " 0.9013, 0.9005, 0.8994, 0.8983, 0.8970, 0.8954, 0.0146, 0.8914, 0.8905,\n", + " 0.8884, 0.8864, 0.8844, 0.8825, 0.8805, 0.8785, 0.0078],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "694000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 37, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 29, 34])\n", + "loss= tensor(175.1942, grad_fn=) , actor= tensor(-8.0868, grad_fn=) , critic= tensor(1832.8099, grad_fn=) , return= 175990.44453827804\n", + "probs of actions: tensor([0.8834, 0.8858, 0.8896, 0.8923, 0.8942, 0.8956, 0.8964, 0.8967, 0.8964,\n", + " 0.8959, 0.0149, 0.8934, 0.0254, 0.8914, 0.8901, 0.8882, 0.8863, 0.8844,\n", + " 0.8824, 0.8804, 0.8784, 0.8764, 0.8744, 0.0134, 0.8706],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "695000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(188.6564, grad_fn=) , actor= tensor(5.5046, grad_fn=) , critic= tensor(1831.5178, grad_fn=) , return= 175778.80204494795\n", + "probs of actions: tensor([0.8819, 0.8842, 0.8881, 0.8908, 0.0258, 0.8939, 0.8950, 0.8952, 0.8950,\n", + " 0.8945, 0.8937, 0.8926, 0.8914, 0.8900, 0.8884, 0.8866, 0.8847, 0.8828,\n", + " 0.8808, 0.8788, 0.8768, 0.8747, 0.8727, 0.8706, 0.8685],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "696000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.2405, grad_fn=) , actor= tensor(7.2919, grad_fn=) , critic= tensor(1819.4858, grad_fn=) , return= 175577.6879441738\n", + "probs of actions: tensor([0.8847, 0.8871, 0.8909, 0.0093, 0.8960, 0.8970, 0.8978, 0.8981, 0.8979,\n", + " 0.8974, 0.8967, 0.8957, 0.8945, 0.8932, 0.8916, 0.8899, 0.8881, 0.8862,\n", + " 0.8843, 0.8824, 0.8804, 0.8785, 0.8765, 0.8745, 0.8724],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "697000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 46, 34, 34, 31])\n", + "loss= tensor(145.6969, grad_fn=) , actor= tensor(-33.8562, grad_fn=) , critic= tensor(1795.5311, grad_fn=) , return= 175929.14601967236\n", + "probs of actions: tensor([0.8814, 0.8838, 0.8877, 0.8905, 0.8924, 0.8939, 0.8948, 0.8951, 0.8948,\n", + " 0.8944, 0.8936, 0.8925, 0.8914, 0.8900, 0.8884, 0.8867, 0.8848, 0.8829,\n", + " 0.8810, 0.8790, 0.8770, 0.0027, 0.8719, 0.8717, 0.0060],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "698000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 46, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(186.3146, grad_fn=) , actor= tensor(1.7319, grad_fn=) , critic= tensor(1845.8271, grad_fn=) , return= 175874.4262822903\n", + "probs of actions: tensor([0.8812, 0.8836, 0.0026, 0.8888, 0.8922, 0.8937, 0.8946, 0.8948, 0.8946,\n", + " 0.8941, 0.8934, 0.0079, 0.8907, 0.8900, 0.8883, 0.8865, 0.8846, 0.8827,\n", + " 0.8808, 0.8788, 0.8768, 0.8748, 0.8728, 0.0293, 0.8684],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "699000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 34, 34, 34, 34, 34,\n", + " 4, 34, 34, 34, 34, 27, 34])\n", + "loss= tensor(155.4906, grad_fn=) , actor= tensor(-30.1591, grad_fn=) , critic= tensor(1856.4978, grad_fn=) , return= 174346.30451713793\n", + "probs of actions: tensor([8.8040e-01, 8.8279e-01, 8.8667e-01, 8.8942e-01, 8.9136e-01, 8.9285e-01,\n", + " 8.9369e-01, 8.9395e-01, 8.9372e-01, 8.9322e-01, 8.9246e-01, 8.9139e-01,\n", + " 4.3664e-03, 8.8876e-01, 8.8729e-01, 8.8551e-01, 8.8361e-01, 8.8171e-01,\n", + " 6.7686e-05, 8.7957e-01, 8.7383e-01, 8.7275e-01, 8.7118e-01, 1.3027e-03,\n", + " 8.6790e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "700000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 41, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34,\n", + " 42, 39, 34, 34, 33, 34, 34])\n", + "loss= tensor(162.9744, grad_fn=) , actor= tensor(-19.1921, grad_fn=) , critic= tensor(1821.6646, grad_fn=) , return= 176160.43665753506\n", + "probs of actions: tensor([8.7111e-01, 8.7365e-01, 1.7338e-02, 8.7979e-01, 3.1005e-02, 8.8394e-01,\n", + " 8.8517e-01, 8.8546e-01, 8.8524e-01, 8.8475e-01, 8.8396e-01, 8.8285e-01,\n", + " 8.8165e-01, 8.8022e-01, 8.7857e-01, 3.1042e-02, 8.7455e-01, 8.7299e-01,\n", + " 4.1566e-03, 9.2768e-03, 8.6677e-01, 8.6517e-01, 8.3527e-04, 8.6055e-01,\n", + " 8.5818e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "701000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 31, 34, 34, 34, 34, 34])\n", + "loss= tensor(175.7746, grad_fn=) , actor= tensor(-7.4490, grad_fn=) , critic= tensor(1832.2363, grad_fn=) , return= 175644.70786480265\n", + "probs of actions: tensor([0.8833, 0.8857, 0.8895, 0.8923, 0.8942, 0.8957, 0.8966, 0.8968, 0.8966,\n", + " 0.8962, 0.8954, 0.8944, 0.8932, 0.8919, 0.8903, 0.8886, 0.8868, 0.8849,\n", + " 0.8830, 0.0054, 0.8793, 0.8769, 0.8750, 0.8730, 0.8710],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "702000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 13, 34, 34, 34, 34, 34, 37,\n", + " 34, 34, 34, 34, 34, 44, 34])\n", + "loss= tensor(164.5643, grad_fn=) , actor= tensor(-15.2813, grad_fn=) , critic= tensor(1798.4568, grad_fn=) , return= 174556.1211401098\n", + "probs of actions: tensor([8.8098e-01, 8.8337e-01, 8.8725e-01, 8.9000e-01, 8.9195e-01, 8.9344e-01,\n", + " 8.9428e-01, 8.9453e-01, 8.9430e-01, 8.9380e-01, 8.9302e-01, 7.4723e-05,\n", + " 8.9197e-01, 8.8862e-01, 8.8736e-01, 8.8578e-01, 8.8398e-01, 2.7819e-02,\n", + " 8.7994e-01, 8.7839e-01, 8.7631e-01, 8.7425e-01, 8.7217e-01, 3.1674e-03,\n", + " 8.6720e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "703000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 38,\n", + " 34, 39, 34, 34, 34, 41, 34])\n", + "loss= tensor(162.8352, grad_fn=) , actor= tensor(-18.2862, grad_fn=) , critic= tensor(1811.2142, grad_fn=) , return= 175569.97096909705\n", + "probs of actions: tensor([0.0113, 0.8776, 0.8809, 0.8837, 0.8857, 0.8873, 0.8881, 0.8884, 0.8882,\n", + " 0.8876, 0.8868, 0.8857, 0.8845, 0.8830, 0.8814, 0.8795, 0.8776, 0.0057,\n", + " 0.8732, 0.0091, 0.8691, 0.8677, 0.8654, 0.0151, 0.8604],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "704000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 38, 34, 34, 34, 37, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 31, 40,\n", + " 34, 34, 31, 34, 34, 34, 34])\n", + "loss= tensor(186.1330, grad_fn=) , actor= tensor(2.1047, grad_fn=) , critic= tensor(1840.2832, grad_fn=) , return= 175933.00023495575\n", + "probs of actions: tensor([0.8848, 0.0050, 0.8905, 0.8936, 0.8955, 0.0265, 0.8976, 0.8981, 0.8979,\n", + " 0.8974, 0.8966, 0.0123, 0.8938, 0.8933, 0.8916, 0.8898, 0.0051, 0.0024,\n", + " 0.8834, 0.8824, 0.0055, 0.8785, 0.8760, 0.8740, 0.8720],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "705000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 44, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 39, 34,\n", + " 34, 34, 34, 41, 34, 34, 34])\n", + "loss= tensor(182.5224, grad_fn=) , actor= tensor(0.1803, grad_fn=) , critic= tensor(1823.4209, grad_fn=) , return= 176110.80495453754\n", + "probs of actions: tensor([0.8830, 0.0025, 0.8878, 0.8918, 0.8937, 0.8952, 0.8960, 0.8963, 0.8960,\n", + " 0.8955, 0.8948, 0.8937, 0.8926, 0.0049, 0.8889, 0.8883, 0.0080, 0.8838,\n", + " 0.8825, 0.8804, 0.8783, 0.0134, 0.8737, 0.8727, 0.8704],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "706000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 36, 34, 43])\n", + "loss= tensor(152.3904, grad_fn=) , actor= tensor(-33.3901, grad_fn=) , critic= tensor(1857.8049, grad_fn=) , return= 174878.99977736163\n", + "probs of actions: tensor([0.8772, 0.8796, 0.8836, 0.8863, 0.8883, 0.8898, 0.8906, 0.0099, 0.8911,\n", + " 0.8900, 0.8893, 0.8882, 0.8870, 0.8856, 0.8840, 0.8822, 0.8803, 0.8784,\n", + " 0.8764, 0.8744, 0.8723, 0.8703, 0.0014, 0.8659, 0.0061],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "707000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.7919, grad_fn=) , actor= tensor(6.2665, grad_fn=) , critic= tensor(1835.2534, grad_fn=) , return= 175838.667038997\n", + "probs of actions: tensor([0.8812, 0.8835, 0.8874, 0.8901, 0.8921, 0.8936, 0.0116, 0.8940, 0.8945,\n", + " 0.8940, 0.8932, 0.8922, 0.8910, 0.8896, 0.8880, 0.8863, 0.8844, 0.8826,\n", + " 0.8806, 0.8786, 0.8766, 0.8746, 0.8726, 0.8706, 0.8685],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "708000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 40, 34,\n", + " 34, 39, 37, 34, 34, 34, 34])\n", + "loss= tensor(166.4417, grad_fn=) , actor= tensor(-14.4443, grad_fn=) , critic= tensor(1808.8601, grad_fn=) , return= 175956.43619576152\n", + "probs of actions: tensor([0.8809, 0.8833, 0.8872, 0.8899, 0.8918, 0.8933, 0.8942, 0.8944, 0.8942,\n", + " 0.8937, 0.8929, 0.8919, 0.8907, 0.8894, 0.8878, 0.8860, 0.0021, 0.8817,\n", + " 0.8807, 0.0091, 0.0327, 0.8745, 0.8727, 0.8705, 0.8684],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "709000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(185.5058, grad_fn=) , actor= tensor(2.7950, grad_fn=) , critic= tensor(1827.1080, grad_fn=) , return= 175901.81378396007\n", + "probs of actions: tensor([0.8979, 0.9000, 0.9035, 0.9060, 0.0251, 0.9089, 0.9099, 0.9101, 0.9099,\n", + " 0.9095, 0.9088, 0.9078, 0.9067, 0.9055, 0.0251, 0.9023, 0.9009, 0.8991,\n", + " 0.0260, 0.8952, 0.8938, 0.8919, 0.8900, 0.8881, 0.8862],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "710000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.1031, grad_fn=) , actor= tensor(6.5893, grad_fn=) , critic= tensor(1835.1373, grad_fn=) , return= 175838.667038997\n", + "probs of actions: tensor([0.9046, 0.9066, 0.9100, 0.9124, 0.9141, 0.9154, 0.0095, 0.9158, 0.9163,\n", + " 0.9159, 0.9152, 0.9143, 0.9133, 0.9121, 0.9107, 0.9092, 0.9076, 0.9059,\n", + " 0.9043, 0.9025, 0.9008, 0.8991, 0.8973, 0.8955, 0.8937],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "711000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 29, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.7059, grad_fn=) , actor= tensor(-0.3183, grad_fn=) , critic= tensor(1830.2421, grad_fn=) , return= 175638.51449256402\n", + "probs of actions: tensor([0.9110, 0.9129, 0.9161, 0.9184, 0.9201, 0.9213, 0.9220, 0.9222, 0.9221,\n", + " 0.9217, 0.9210, 0.9202, 0.9193, 0.0217, 0.9167, 0.9155, 0.0085, 0.9127,\n", + " 0.9105, 0.9089, 0.9074, 0.9057, 0.9040, 0.9023, 0.9006],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "712000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 45, 34, 34, 34, 34, 34, 34, 34, 30, 34, 34, 40,\n", + " 38, 34, 34, 40, 34, 34, 34])\n", + "loss= tensor(169.8306, grad_fn=) , actor= tensor(-11.6295, grad_fn=) , critic= tensor(1814.6013, grad_fn=) , return= 175984.29826864417\n", + "probs of actions: tensor([9.1084e-01, 9.1275e-01, 9.1594e-01, 9.1820e-01, 9.1982e-01, 9.2105e-01,\n", + " 6.4086e-04, 9.2103e-01, 9.2188e-01, 9.2140e-01, 9.2074e-01, 9.1986e-01,\n", + " 9.1888e-01, 9.1774e-01, 4.4258e-04, 9.1522e-01, 9.1327e-01, 1.6079e-03,\n", + " 4.0679e-03, 9.0856e-01, 9.0727e-01, 1.7831e-03, 9.0325e-01, 9.0223e-01,\n", + " 9.0031e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "713000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 46, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 43, 34, 34, 34, 34])\n", + "loss= tensor(181.1167, grad_fn=) , actor= tensor(-1.0594, grad_fn=) , critic= tensor(1821.7607, grad_fn=) , return= 175961.02276546805\n", + "probs of actions: tensor([0.9149, 0.9167, 0.9198, 0.9220, 0.9235, 0.9247, 0.0019, 0.9245, 0.9255,\n", + " 0.9250, 0.9243, 0.9235, 0.9225, 0.9214, 0.9201, 0.9187, 0.9172, 0.9157,\n", + " 0.9141, 0.9125, 0.0040, 0.9086, 0.9081, 0.9062, 0.9044],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "714000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 45, 37, 34, 34, 34, 37, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(193.3822, grad_fn=) , actor= tensor(10.1200, grad_fn=) , critic= tensor(1832.6224, grad_fn=) , return= 175999.2139507259\n", + "probs of actions: tensor([9.0765e-01, 9.0958e-01, 9.1282e-01, 9.1511e-01, 9.1674e-01, 9.1797e-01,\n", + " 9.1865e-01, 9.1883e-01, 9.1861e-01, 9.1815e-01, 6.7679e-04, 2.3602e-02,\n", + " 9.1567e-01, 9.1468e-01, 9.1324e-01, 2.4099e-02, 9.0987e-01, 9.0855e-01,\n", + " 9.0681e-01, 9.0507e-01, 9.0337e-01, 9.0164e-01, 8.9988e-01, 8.9812e-01,\n", + " 8.9635e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "715000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 47, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 26, 34,\n", + " 34, 34, 36, 34, 34, 34, 34])\n", + "loss= tensor(183.5538, grad_fn=) , actor= tensor(-0.7682, grad_fn=) , critic= tensor(1843.2195, grad_fn=) , return= 175636.08232028256\n", + "probs of actions: tensor([9.1364e-01, 9.1549e-01, 2.2847e-04, 9.1954e-01, 9.2234e-01, 9.2354e-01,\n", + " 9.2421e-01, 9.2439e-01, 9.2417e-01, 9.2372e-01, 9.2309e-01, 9.2224e-01,\n", + " 9.2129e-01, 9.2018e-01, 9.1890e-01, 9.1748e-01, 1.4562e-03, 9.1493e-01,\n", + " 9.1243e-01, 9.1099e-01, 1.2354e-03, 9.0774e-01, 9.0633e-01, 9.0460e-01,\n", + " 9.0288e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "716000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 35, 34])\n", + "loss= tensor(163.9033, grad_fn=) , actor= tensor(-18.8567, grad_fn=) , critic= tensor(1827.5997, grad_fn=) , return= 175693.39605755112\n", + "probs of actions: tensor([0.9158, 0.9176, 0.9206, 0.9228, 0.9243, 0.9254, 0.9260, 0.9262, 0.9260,\n", + " 0.9255, 0.9249, 0.9240, 0.9231, 0.9220, 0.9207, 0.9193, 0.9178, 0.9162,\n", + " 0.9146, 0.9130, 0.9114, 0.9098, 0.9081, 0.0041, 0.9047],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "717000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4527, grad_fn=) , actor= tensor(-0.2858, grad_fn=) , critic= tensor(1827.3849, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9131, 0.9149, 0.9180, 0.9202, 0.9218, 0.9229, 0.9236, 0.9237, 0.9235,\n", + " 0.9230, 0.9224, 0.9215, 0.9206, 0.9194, 0.9181, 0.9167, 0.9151, 0.9136,\n", + " 0.9119, 0.9103, 0.9087, 0.9070, 0.9053, 0.9036, 0.9019],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "718000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4745, grad_fn=) , actor= tensor(-0.2673, grad_fn=) , critic= tensor(1827.4175, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9143, 0.9162, 0.9192, 0.9214, 0.9229, 0.9241, 0.9247, 0.9249, 0.9246,\n", + " 0.9242, 0.9235, 0.9226, 0.9217, 0.9205, 0.9193, 0.9178, 0.9163, 0.9147,\n", + " 0.9131, 0.9115, 0.9098, 0.9082, 0.9065, 0.9048, 0.9031],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "719000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 26, 26, 43, 34, 34, 34, 34, 41, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(203.8413, grad_fn=) , actor= tensor(23.1291, grad_fn=) , critic= tensor(1807.1223, grad_fn=) , return= 175476.156521695\n", + "probs of actions: tensor([0.9109, 0.9127, 0.9159, 0.9181, 0.9197, 0.9209, 0.9215, 0.0012, 0.0012,\n", + " 0.0040, 0.9192, 0.9194, 0.9184, 0.9173, 0.0085, 0.9140, 0.9131, 0.9114,\n", + " 0.9097, 0.9080, 0.9063, 0.9046, 0.9028, 0.9011, 0.8993],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "720000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 34, 34, 34, 34, 30,\n", + " 34, 34, 45, 34, 34, 34, 34])\n", + "loss= tensor(167.6944, grad_fn=) , actor= tensor(-13.6450, grad_fn=) , critic= tensor(1813.3938, grad_fn=) , return= 175838.98005939354\n", + "probs of actions: tensor([9.1428e-01, 9.1611e-01, 9.1917e-01, 9.2134e-01, 9.2288e-01, 9.2404e-01,\n", + " 9.2467e-01, 9.2483e-01, 9.2459e-01, 9.2414e-01, 9.2350e-01, 3.6477e-03,\n", + " 9.2105e-01, 9.2081e-01, 9.1942e-01, 9.1794e-01, 9.1637e-01, 4.7464e-04,\n", + " 9.1345e-01, 9.1134e-01, 8.2420e-04, 9.0744e-01, 9.0716e-01, 9.0520e-01,\n", + " 9.0335e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "721000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(179.7384, grad_fn=) , actor= tensor(-2.6954, grad_fn=) , critic= tensor(1824.3390, grad_fn=) , return= 175777.92710599265\n", + "probs of actions: tensor([0.9075, 0.9094, 0.9126, 0.9148, 0.9164, 0.9176, 0.9183, 0.9184, 0.9181,\n", + " 0.9176, 0.9169, 0.9160, 0.9150, 0.9138, 0.9124, 0.9109, 0.9092, 0.0244,\n", + " 0.9056, 0.9043, 0.9025, 0.9007, 0.8989, 0.8971, 0.8953],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "722000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4288, grad_fn=) , actor= tensor(-0.3101, grad_fn=) , critic= tensor(1827.3884, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9008, 0.9028, 0.9062, 0.9086, 0.9102, 0.9115, 0.9122, 0.9124, 0.9121,\n", + " 0.9116, 0.9109, 0.9099, 0.9088, 0.9076, 0.9062, 0.9046, 0.9029, 0.9011,\n", + " 0.8994, 0.8976, 0.8958, 0.8940, 0.8921, 0.8903, 0.8884],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "723000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 32, 34, 34, 34, 34])\n", + "loss= tensor(173.2299, grad_fn=) , actor= tensor(-9.8841, grad_fn=) , critic= tensor(1831.1399, grad_fn=) , return= 175676.1656023947\n", + "probs of actions: tensor([0.8987, 0.9008, 0.9042, 0.9066, 0.9083, 0.9096, 0.9103, 0.9104, 0.9102,\n", + " 0.9096, 0.9089, 0.9079, 0.9068, 0.9056, 0.9041, 0.9025, 0.9008, 0.8990,\n", + " 0.8972, 0.8954, 0.0047, 0.8919, 0.8897, 0.8879, 0.8860],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "724000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(196.4560, grad_fn=) , actor= tensor(13.7099, grad_fn=) , critic= tensor(1827.4608, grad_fn=) , return= 175702.27064688999\n", + "probs of actions: tensor([0.0083, 0.8960, 0.8989, 0.9013, 0.0076, 0.9039, 0.9051, 0.9053, 0.9050,\n", + " 0.9044, 0.9036, 0.9026, 0.9015, 0.9001, 0.8986, 0.8969, 0.8951, 0.8933,\n", + " 0.8914, 0.8895, 0.8876, 0.8857, 0.8838, 0.8818, 0.8798],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "725000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 29,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.6670, grad_fn=) , actor= tensor(5.7830, grad_fn=) , critic= tensor(1838.8395, grad_fn=) , return= 175720.46775822673\n", + "probs of actions: tensor([0.9010, 0.0078, 0.9058, 0.9086, 0.9103, 0.9115, 0.9122, 0.9124, 0.9121,\n", + " 0.9115, 0.9108, 0.9098, 0.9087, 0.0250, 0.9058, 0.9045, 0.9027, 0.0091,\n", + " 0.8995, 0.8970, 0.8953, 0.8936, 0.8917, 0.8899, 0.8880],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "726000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 45, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 24, 34, 34, 34])\n", + "loss= tensor(182.1392, grad_fn=) , actor= tensor(-3.9729, grad_fn=) , critic= tensor(1861.1206, grad_fn=) , return= 175643.22366383421\n", + "probs of actions: tensor([8.9944e-01, 9.0144e-01, 9.0481e-01, 8.6170e-04, 9.0778e-01, 9.1011e-01,\n", + " 9.1080e-01, 9.1096e-01, 9.1067e-01, 9.1011e-01, 9.0937e-01, 9.0837e-01,\n", + " 9.0727e-01, 9.0599e-01, 9.0453e-01, 9.0293e-01, 9.0120e-01, 8.9942e-01,\n", + " 8.9763e-01, 8.9579e-01, 8.9397e-01, 1.1237e-03, 8.9088e-01, 8.8771e-01,\n", + " 8.8613e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "727000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 34, 34, 34, 29, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.6541, grad_fn=) , actor= tensor(8.0345, grad_fn=) , critic= tensor(1826.1962, grad_fn=) , return= 175596.66076714935\n", + "probs of actions: tensor([0.8989, 0.9009, 0.9043, 0.9067, 0.9084, 0.9096, 0.9103, 0.9105, 0.9102,\n", + " 0.0033, 0.9088, 0.9079, 0.9068, 0.0087, 0.9043, 0.9022, 0.9005, 0.8988,\n", + " 0.8970, 0.8951, 0.8933, 0.8915, 0.8896, 0.8877, 0.8858],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "728000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 29, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(187.0224, grad_fn=) , actor= tensor(4.0914, grad_fn=) , critic= tensor(1829.3101, grad_fn=) , return= 175696.12039152495\n", + "probs of actions: tensor([0.8937, 0.8958, 0.8993, 0.9017, 0.9034, 0.9047, 0.9054, 0.9056, 0.9052,\n", + " 0.9047, 0.9039, 0.0119, 0.9011, 0.9005, 0.0091, 0.8975, 0.8951, 0.8933,\n", + " 0.8915, 0.8896, 0.8877, 0.8858, 0.8838, 0.8819, 0.8799],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "729000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(179.8339, grad_fn=) , actor= tensor(-2.5999, grad_fn=) , critic= tensor(1824.3379, grad_fn=) , return= 175777.92710599265\n", + "probs of actions: tensor([0.9013, 0.9033, 0.9066, 0.9090, 0.9106, 0.9119, 0.9125, 0.9127, 0.9124,\n", + " 0.9119, 0.9111, 0.9101, 0.9090, 0.9078, 0.9063, 0.9047, 0.9030, 0.0263,\n", + " 0.8992, 0.8978, 0.8959, 0.8941, 0.8922, 0.8903, 0.8884],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "730000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 30, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(193.8727, grad_fn=) , actor= tensor(11.7126, grad_fn=) , critic= tensor(1821.6012, grad_fn=) , return= 175619.33360203108\n", + "probs of actions: tensor([9.0950e-01, 4.5602e-04, 9.1485e-01, 9.1670e-01, 9.1827e-01, 9.1943e-01,\n", + " 9.2006e-01, 9.2021e-01, 9.1994e-01, 9.1943e-01, 9.1875e-01, 9.1783e-01,\n", + " 9.1680e-01, 9.1562e-01, 9.1426e-01, 9.1277e-01, 9.1116e-01, 9.0951e-01,\n", + " 9.0784e-01, 9.0612e-01, 9.0443e-01, 9.0270e-01, 9.0095e-01, 8.9919e-01,\n", + " 8.9741e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "731000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4553, grad_fn=) , actor= tensor(-0.2837, grad_fn=) , critic= tensor(1827.3901, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9121, 0.9139, 0.9170, 0.9192, 0.9207, 0.9219, 0.9225, 0.9227, 0.9224,\n", + " 0.9219, 0.9213, 0.9204, 0.9194, 0.9182, 0.9169, 0.9155, 0.9139, 0.9123,\n", + " 0.9106, 0.9090, 0.9073, 0.9056, 0.9039, 0.9022, 0.9004],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "732000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 39])\n", + "loss= tensor(169.6830, grad_fn=) , actor= tensor(-15.4588, grad_fn=) , critic= tensor(1851.4181, grad_fn=) , return= 175414.99926861114\n", + "probs of actions: tensor([0.9074, 0.9093, 0.9124, 0.9146, 0.9162, 0.9174, 0.9180, 0.9182, 0.0231,\n", + " 0.9171, 0.9167, 0.9157, 0.9146, 0.9134, 0.9120, 0.9104, 0.9088, 0.9071,\n", + " 0.9054, 0.9036, 0.9019, 0.9001, 0.8983, 0.8965, 0.0073],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "733000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 43, 34, 37, 34, 34,\n", + " 27, 29, 34, 34, 34, 34, 34])\n", + "loss= tensor(172.4552, grad_fn=) , actor= tensor(-11.7355, grad_fn=) , critic= tensor(1841.9072, grad_fn=) , return= 175592.4836496863\n", + "probs of actions: tensor([8.9709e-01, 8.9906e-01, 9.0243e-01, 9.0478e-01, 9.0643e-01, 9.0767e-01,\n", + " 9.0833e-01, 9.0846e-01, 9.0813e-01, 9.0753e-01, 9.0676e-01, 9.0572e-01,\n", + " 9.0458e-01, 4.3859e-03, 9.0108e-01, 2.8771e-02, 8.9837e-01, 8.9680e-01,\n", + " 8.4512e-04, 1.0004e-02, 8.9096e-01, 8.8860e-01, 8.8693e-01, 8.8513e-01,\n", + " 8.8327e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "734000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4269, grad_fn=) , actor= tensor(-0.3122, grad_fn=) , critic= tensor(1827.3911, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9058, 0.9077, 0.9108, 0.9130, 0.9145, 0.9157, 0.9163, 0.9163, 0.9160,\n", + " 0.9154, 0.9147, 0.9137, 0.9126, 0.9114, 0.9099, 0.9084, 0.9067, 0.9050,\n", + " 0.9033, 0.9015, 0.8997, 0.8979, 0.8961, 0.8943, 0.8925],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "735000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 32, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(192.6245, grad_fn=) , actor= tensor(9.1094, grad_fn=) , critic= tensor(1835.1506, grad_fn=) , return= 175739.96454189203\n", + "probs of actions: tensor([0.0114, 0.9106, 0.9146, 0.9167, 0.9182, 0.9193, 0.9199, 0.9199, 0.9196,\n", + " 0.9190, 0.9183, 0.9173, 0.0029, 0.9151, 0.9135, 0.9120, 0.9104, 0.9087,\n", + " 0.9070, 0.9052, 0.9035, 0.9018, 0.9000, 0.8982, 0.8964],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "736000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 39, 34, 34, 35, 34, 34, 34])\n", + "loss= tensor(163.4294, grad_fn=) , actor= tensor(-18.4362, grad_fn=) , critic= tensor(1818.6550, grad_fn=) , return= 175817.91331967045\n", + "probs of actions: tensor([0.9188, 0.9204, 0.9232, 0.9251, 0.9265, 0.9275, 0.9280, 0.9280, 0.9277,\n", + " 0.9271, 0.9264, 0.9255, 0.9245, 0.9233, 0.9220, 0.9206, 0.9191, 0.9175,\n", + " 0.0053, 0.9139, 0.9128, 0.0033, 0.9093, 0.9077, 0.9060],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "737000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 28, 37, 34, 34, 34, 34])\n", + "loss= tensor(174.5679, grad_fn=) , actor= tensor(-8.9917, grad_fn=) , critic= tensor(1835.5964, grad_fn=) , return= 175662.7709508737\n", + "probs of actions: tensor([0.9179, 0.9195, 0.9224, 0.0238, 0.9255, 0.9267, 0.9272, 0.9273, 0.9270,\n", + " 0.9264, 0.9257, 0.9248, 0.9237, 0.9226, 0.9213, 0.9198, 0.9183, 0.9167,\n", + " 0.9151, 0.0026, 0.0254, 0.9096, 0.9085, 0.9068, 0.9051],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "738000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 37, 34, 34])\n", + "loss= tensor(177.4354, grad_fn=) , actor= tensor(-5.2457, grad_fn=) , critic= tensor(1826.8115, grad_fn=) , return= 175774.62445953238\n", + "probs of actions: tensor([0.9167, 0.9184, 0.9212, 0.9232, 0.9246, 0.9256, 0.9261, 0.0230, 0.9257,\n", + " 0.9254, 0.9246, 0.9237, 0.9227, 0.9215, 0.9202, 0.9187, 0.9172, 0.9155,\n", + " 0.9139, 0.9122, 0.9106, 0.9089, 0.0260, 0.9053, 0.9040],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "739000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 29, 34, 34, 34])\n", + "loss= tensor(172.4594, grad_fn=) , actor= tensor(-11.2544, grad_fn=) , critic= tensor(1837.1375, grad_fn=) , return= 175630.88435544944\n", + "probs of actions: tensor([0.9229, 0.9245, 0.9272, 0.9291, 0.9304, 0.9314, 0.9319, 0.9319, 0.9316,\n", + " 0.9311, 0.9304, 0.9296, 0.9286, 0.9275, 0.9263, 0.9249, 0.9235, 0.9219,\n", + " 0.9204, 0.9188, 0.9172, 0.0077, 0.9144, 0.9122, 0.9107],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "740000 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 37, 34, 41])\n", + "loss= tensor(163.8618, grad_fn=) , actor= tensor(-20.1959, grad_fn=) , critic= tensor(1840.5774, grad_fn=) , return= 174922.70339896527\n", + "probs of actions: tensor([7.2937e-04, 9.2259e-01, 9.2440e-01, 9.2633e-01, 9.2768e-01, 9.2865e-01,\n", + " 9.2913e-01, 9.2919e-01, 9.2887e-01, 9.2830e-01, 9.2761e-01, 9.2670e-01,\n", + " 9.2566e-01, 9.2453e-01, 9.2324e-01, 9.2182e-01, 9.2030e-01, 9.1869e-01,\n", + " 9.1710e-01, 9.1547e-01, 9.1385e-01, 9.1222e-01, 2.4881e-02, 9.0872e-01,\n", + " 9.3922e-03], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "741000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.6214, grad_fn=) , actor= tensor(5.9944, grad_fn=) , critic= tensor(1836.2699, grad_fn=) , return= 175791.58351977664\n", + "probs of actions: tensor([0.0086, 0.9272, 0.9306, 0.9325, 0.9337, 0.9346, 0.9351, 0.9352, 0.9348,\n", + " 0.9343, 0.9337, 0.9328, 0.9318, 0.9308, 0.9296, 0.9282, 0.9268, 0.9253,\n", + " 0.9238, 0.9222, 0.9207, 0.9191, 0.9176, 0.9160, 0.9144],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "742000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 38])\n", + "loss= tensor(170.5711, grad_fn=) , actor= tensor(-14.8304, grad_fn=) , critic= tensor(1854.0154, grad_fn=) , return= 175507.00018095973\n", + "probs of actions: tensor([0.0030, 0.9215, 0.9253, 0.9271, 0.9284, 0.9294, 0.9298, 0.9299, 0.9295,\n", + " 0.9289, 0.9282, 0.9273, 0.9263, 0.9251, 0.9238, 0.9224, 0.9209, 0.9192,\n", + " 0.9176, 0.9160, 0.9144, 0.9127, 0.9111, 0.9094, 0.0041],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "743000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 32, 34, 34, 34, 34])\n", + "loss= tensor(181.3003, grad_fn=) , actor= tensor(-2.7405, grad_fn=) , critic= tensor(1840.4083, grad_fn=) , return= 175793.26944424585\n", + "probs of actions: tensor([0.9224, 0.9240, 0.9267, 0.0080, 0.9293, 0.9308, 0.9313, 0.9313, 0.9310,\n", + " 0.9304, 0.9297, 0.9289, 0.9278, 0.9267, 0.9255, 0.9241, 0.9226, 0.9210,\n", + " 0.9195, 0.9179, 0.0029, 0.9148, 0.9130, 0.9114, 0.9098],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "744000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 36, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 41, 34, 34])\n", + "loss= tensor(179.5468, grad_fn=) , actor= tensor(-3.0136, grad_fn=) , critic= tensor(1825.6033, grad_fn=) , return= 175845.48184189005\n", + "probs of actions: tensor([0.9210, 0.9226, 0.9253, 0.9272, 0.9285, 0.9295, 0.9300, 0.9300, 0.0075,\n", + " 0.9286, 0.9286, 0.9277, 0.0010, 0.9254, 0.9243, 0.9229, 0.9213, 0.9198,\n", + " 0.9182, 0.9166, 0.9150, 0.9134, 0.0085, 0.9097, 0.9089],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "745000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34,\n", + " 34, 38, 34, 34, 34, 34, 34])\n", + "loss= tensor(181.9034, grad_fn=) , actor= tensor(-0.5009, grad_fn=) , critic= tensor(1824.0435, grad_fn=) , return= 175944.09024908353\n", + "probs of actions: tensor([0.9304, 0.9319, 0.9344, 0.0202, 0.9371, 0.9382, 0.9387, 0.9387, 0.9385,\n", + " 0.9379, 0.9373, 0.9365, 0.9356, 0.9346, 0.0044, 0.9319, 0.9310, 0.9295,\n", + " 0.9280, 0.0033, 0.9248, 0.9237, 0.9222, 0.9206, 0.9191],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "746000 adversary: AdversaryModes.myopic\n", + " actions: tensor([37, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.2554, grad_fn=) , actor= tensor(13.2001, grad_fn=) , critic= tensor(1840.5527, grad_fn=) , return= 175877.1249012947\n", + "probs of actions: tensor([0.0215, 0.9309, 0.9338, 0.0067, 0.9363, 0.9377, 0.9382, 0.9382, 0.9379,\n", + " 0.9374, 0.9368, 0.9360, 0.9351, 0.9341, 0.9329, 0.9317, 0.9303, 0.9288,\n", + " 0.9274, 0.9259, 0.9244, 0.9230, 0.9215, 0.9199, 0.9184],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "747000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(185.8905, grad_fn=) , actor= tensor(2.9850, grad_fn=) , critic= tensor(1829.0549, grad_fn=) , return= 175780.0398569792\n", + "probs of actions: tensor([0.9334, 0.9348, 0.9373, 0.9390, 0.9402, 0.9411, 0.9415, 0.9416, 0.9413,\n", + " 0.9408, 0.9402, 0.0186, 0.9384, 0.9377, 0.9365, 0.9353, 0.9340, 0.9326,\n", + " 0.9312, 0.9297, 0.9283, 0.9269, 0.9255, 0.9240, 0.9225],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "748000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 42, 34, 37, 34, 34, 34])\n", + "loss= tensor(170.7079, grad_fn=) , actor= tensor(-10.5546, grad_fn=) , critic= tensor(1812.6248, grad_fn=) , return= 175915.50919312364\n", + "probs of actions: tensor([0.9341, 0.9355, 0.0183, 0.9394, 0.9407, 0.9416, 0.9420, 0.9420, 0.9417,\n", + " 0.9413, 0.9406, 0.9398, 0.9389, 0.9379, 0.9368, 0.9356, 0.9342, 0.9328,\n", + " 0.9314, 0.0026, 0.9281, 0.0196, 0.9257, 0.9244, 0.9228],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "749000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4673, grad_fn=) , actor= tensor(-0.2731, grad_fn=) , critic= tensor(1827.4041, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9315, 0.9329, 0.9354, 0.9371, 0.9383, 0.9392, 0.9396, 0.9397, 0.9394,\n", + " 0.9389, 0.9382, 0.9374, 0.9365, 0.9355, 0.9343, 0.9330, 0.9316, 0.9302,\n", + " 0.9287, 0.9273, 0.9258, 0.9243, 0.9228, 0.9213, 0.9198],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "750000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 42, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 42, 34, 34,\n", + " 34, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(180.0594, grad_fn=) , actor= tensor(-3.3928, grad_fn=) , critic= tensor(1834.5226, grad_fn=) , return= 175893.46971447908\n", + "probs of actions: tensor([0.9282, 0.9296, 0.0027, 0.9333, 0.9352, 0.9361, 0.9365, 0.9366, 0.9362,\n", + " 0.9357, 0.9350, 0.9342, 0.9332, 0.9321, 0.9309, 0.0028, 0.9277, 0.9270,\n", + " 0.9253, 0.9237, 0.9221, 0.9206, 0.9190, 0.0228, 0.9157],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "751000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(179.6679, grad_fn=) , actor= tensor(-2.7672, grad_fn=) , critic= tensor(1824.3507, grad_fn=) , return= 175777.92710599265\n", + "probs of actions: tensor([0.9349, 0.9362, 0.9385, 0.9402, 0.9413, 0.9421, 0.9425, 0.9425, 0.9422,\n", + " 0.9417, 0.9410, 0.9402, 0.9393, 0.9383, 0.9371, 0.9359, 0.9345, 0.0189,\n", + " 0.9315, 0.9304, 0.9288, 0.9273, 0.9259, 0.9244, 0.9228],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "752000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 42, 29, 34, 40, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 29, 34, 34])\n", + "loss= tensor(200.1543, grad_fn=) , actor= tensor(15.6084, grad_fn=) , critic= tensor(1845.4590, grad_fn=) , return= 175764.7653358355\n", + "probs of actions: tensor([9.3239e-01, 2.7530e-03, 4.3268e-03, 9.3812e-01, 8.8015e-04, 9.3941e-01,\n", + " 9.4025e-01, 9.4026e-01, 9.3993e-01, 9.3938e-01, 9.3872e-01, 9.3788e-01,\n", + " 9.3693e-01, 9.3589e-01, 9.3472e-01, 9.3343e-01, 9.3204e-01, 9.3057e-01,\n", + " 9.2911e-01, 9.2762e-01, 9.2612e-01, 9.2463e-01, 6.1841e-03, 9.2184e-01,\n", + " 9.1977e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "753000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 41, 34, 34, 36, 34, 34, 34])\n", + "loss= tensor(166.5036, grad_fn=) , actor= tensor(-15.2184, grad_fn=) , critic= tensor(1817.2200, grad_fn=) , return= 175914.55794680846\n", + "probs of actions: tensor([0.9360, 0.9372, 0.9396, 0.9412, 0.9424, 0.9432, 0.9436, 0.0173, 0.9431,\n", + " 0.9428, 0.9422, 0.9414, 0.9405, 0.9395, 0.9384, 0.9371, 0.9358, 0.9344,\n", + " 0.0052, 0.9312, 0.9305, 0.0012, 0.9273, 0.9260, 0.9244],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "754000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(191.0309, grad_fn=) , actor= tensor(9.0862, grad_fn=) , critic= tensor(1819.4464, grad_fn=) , return= 175577.6879441738\n", + "probs of actions: tensor([0.9373, 0.9385, 0.9408, 0.0036, 0.9438, 0.9443, 0.9447, 0.9447, 0.9444,\n", + " 0.9439, 0.9433, 0.9425, 0.9416, 0.9406, 0.9395, 0.9383, 0.9370, 0.9356,\n", + " 0.9342, 0.9328, 0.9314, 0.9300, 0.9285, 0.9271, 0.9256],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "755000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 43, 34, 34, 34, 34, 34, 34, 34, 34, 34, 29, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(196.5513, grad_fn=) , actor= tensor(13.0653, grad_fn=) , critic= tensor(1834.8606, grad_fn=) , return= 175684.48230382663\n", + "probs of actions: tensor([0.9358, 0.0031, 0.9387, 0.9411, 0.9423, 0.9431, 0.9435, 0.9436, 0.9433,\n", + " 0.9428, 0.9421, 0.0041, 0.9407, 0.9393, 0.9383, 0.9371, 0.9358, 0.9344,\n", + " 0.9330, 0.9315, 0.9301, 0.9287, 0.9272, 0.9257, 0.9243],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "756000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.4918, grad_fn=) , actor= tensor(-0.2468, grad_fn=) , critic= tensor(1827.3866, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9406, 0.9418, 0.9440, 0.9456, 0.9467, 0.9474, 0.9478, 0.9478, 0.9475,\n", + " 0.9470, 0.9464, 0.9457, 0.9448, 0.9439, 0.9428, 0.9416, 0.9403, 0.9390,\n", + " 0.9377, 0.9363, 0.9349, 0.9335, 0.9321, 0.9307, 0.9293],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "757000 adversary: AdversaryModes.myopic\n", + " actions: tensor([38, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 28, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 42, 34, 34])\n", + "loss= tensor(177.1417, grad_fn=) , actor= tensor(-4.7154, grad_fn=) , critic= tensor(1818.5707, grad_fn=) , return= 175542.46999963076\n", + "probs of actions: tensor([0.0029, 0.9390, 0.9417, 0.9433, 0.9444, 0.9452, 0.9455, 0.9456, 0.9453,\n", + " 0.9447, 0.9441, 0.9434, 0.0016, 0.9418, 0.9402, 0.9391, 0.9378, 0.9365,\n", + " 0.9351, 0.9337, 0.9323, 0.9309, 0.0031, 0.9276, 0.9270],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "758000 adversary: AdversaryModes.myopic\n", + " actions: tensor([42, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(191.1050, grad_fn=) , actor= tensor(7.3504, grad_fn=) , critic= tensor(1837.5453, grad_fn=) , return= 175795.00018095973\n", + "probs of actions: tensor([0.0032, 0.9327, 0.9360, 0.9377, 0.9389, 0.9397, 0.9401, 0.9402, 0.9399,\n", + " 0.9393, 0.9387, 0.9378, 0.9369, 0.9359, 0.9347, 0.9334, 0.9320, 0.9306,\n", + " 0.9291, 0.9276, 0.9261, 0.9246, 0.9231, 0.9216, 0.9201],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "759000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.1601, grad_fn=) , actor= tensor(-0.4606, grad_fn=) , critic= tensor(1826.2069, grad_fn=) , return= 175779.54386719308\n", + "probs of actions: tensor([0.9309, 0.9323, 0.9348, 0.9365, 0.9377, 0.9385, 0.9389, 0.9389, 0.9386,\n", + " 0.9381, 0.9374, 0.9366, 0.9356, 0.9346, 0.9334, 0.0194, 0.9305, 0.9293,\n", + " 0.9277, 0.9262, 0.9247, 0.9232, 0.9216, 0.9201, 0.9185],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "760000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 37, 34, 34, 34, 34])\n", + "loss= tensor(174.8715, grad_fn=) , actor= tensor(-7.3076, grad_fn=) , critic= tensor(1821.7909, grad_fn=) , return= 175762.8306090006\n", + "probs of actions: tensor([0.9365, 0.9378, 0.9401, 0.9417, 0.9429, 0.9436, 0.9440, 0.9441, 0.9438,\n", + " 0.9432, 0.9426, 0.9418, 0.9409, 0.9399, 0.9388, 0.9376, 0.9363, 0.9349,\n", + " 0.9335, 0.9321, 0.0196, 0.9291, 0.9279, 0.9264, 0.9249],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "761000 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 39, 34, 38, 34])\n", + "loss= tensor(157.5846, grad_fn=) , actor= tensor(-23.7009, grad_fn=) , critic= tensor(1812.8550, grad_fn=) , return= 175544.7593460952\n", + "probs of actions: tensor([0.0038, 0.9378, 0.9397, 0.9413, 0.9425, 0.9433, 0.9437, 0.9437, 0.9434,\n", + " 0.9429, 0.9423, 0.9415, 0.9406, 0.9396, 0.9385, 0.9373, 0.9360, 0.9346,\n", + " 0.9332, 0.9318, 0.9303, 0.0064, 0.9272, 0.0033, 0.9245],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "762000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.3388, grad_fn=) , actor= tensor(6.9083, grad_fn=) , critic= tensor(1834.3042, grad_fn=) , return= 175839.03828024844\n", + "probs of actions: tensor([0.9327, 0.9340, 0.9364, 0.9381, 0.9393, 0.9402, 0.9406, 0.0053, 0.9398,\n", + " 0.9399, 0.9392, 0.9383, 0.9374, 0.9363, 0.9351, 0.9339, 0.9325, 0.9310,\n", + " 0.9296, 0.9281, 0.9266, 0.9251, 0.9236, 0.9221, 0.9205],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "763000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 32])\n", + "loss= tensor(158.2315, grad_fn=) , actor= tensor(-23.7565, grad_fn=) , critic= tensor(1819.8802, grad_fn=) , return= 175848.33355816206\n", + "probs of actions: tensor([0.9365, 0.9377, 0.9400, 0.9416, 0.9427, 0.9435, 0.9439, 0.9439, 0.9435,\n", + " 0.9430, 0.9423, 0.9415, 0.9406, 0.9396, 0.9385, 0.9372, 0.9359, 0.9344,\n", + " 0.9330, 0.9316, 0.9301, 0.9287, 0.9272, 0.9257, 0.0029],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "764000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 38, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.3387, grad_fn=) , actor= tensor(7.2868, grad_fn=) , critic= tensor(1830.5193, grad_fn=) , return= 175860.74229406728\n", + "probs of actions: tensor([0.9407, 0.9418, 0.9440, 0.9455, 0.9466, 0.9473, 0.0142, 0.9475, 0.9473,\n", + " 0.9468, 0.9462, 0.9454, 0.9445, 0.9435, 0.0024, 0.9410, 0.9400, 0.9386,\n", + " 0.9372, 0.9357, 0.9343, 0.9329, 0.9315, 0.9301, 0.9286],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "765000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 32, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(183.6463, grad_fn=) , actor= tensor(0.2393, grad_fn=) , critic= tensor(1834.0701, grad_fn=) , return= 175721.04182170736\n", + "probs of actions: tensor([0.9376, 0.0158, 0.9409, 0.9427, 0.9438, 0.9445, 0.9449, 0.9449, 0.9446,\n", + " 0.9440, 0.9433, 0.9425, 0.9416, 0.9406, 0.9395, 0.9382, 0.9369, 0.9354,\n", + " 0.0025, 0.9327, 0.9310, 0.9296, 0.9282, 0.9267, 0.9252],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "766000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.9731, grad_fn=) , actor= tensor(6.5980, grad_fn=) , critic= tensor(1833.7510, grad_fn=) , return= 175779.25019741058\n", + "probs of actions: tensor([0.0056, 0.9426, 0.9453, 0.9468, 0.9479, 0.9487, 0.9490, 0.9491, 0.9488,\n", + " 0.9483, 0.9477, 0.9470, 0.9461, 0.9452, 0.9441, 0.9430, 0.9417, 0.9404,\n", + " 0.9391, 0.9377, 0.9364, 0.9351, 0.9337, 0.9323, 0.9309],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "767000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 40, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(195.4338, grad_fn=) , actor= tensor(11.8761, grad_fn=) , critic= tensor(1835.5779, grad_fn=) , return= 175817.083426555\n", + "probs of actions: tensor([9.4511e-01, 9.4621e-01, 6.7783e-04, 9.4941e-01, 9.5082e-01, 9.5154e-01,\n", + " 9.5189e-01, 9.5191e-01, 9.5164e-01, 9.5117e-01, 9.5059e-01, 9.4988e-01,\n", + " 9.4906e-01, 9.4816e-01, 9.4715e-01, 9.4604e-01, 9.4484e-01, 9.4358e-01,\n", + " 9.4229e-01, 9.4099e-01, 9.3969e-01, 9.3839e-01, 9.3707e-01, 9.3574e-01,\n", + " 9.3440e-01], grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "768000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 30, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(185.9560, grad_fn=) , actor= tensor(3.3756, grad_fn=) , critic= tensor(1825.8037, grad_fn=) , return= 175605.84991526525\n", + "probs of actions: tensor([9.4781e-01, 9.4886e-01, 9.5091e-01, 9.5232e-01, 9.5331e-01, 9.5400e-01,\n", + " 9.5434e-01, 9.5436e-01, 9.5410e-01, 9.5365e-01, 9.5310e-01, 9.5242e-01,\n", + " 9.5163e-01, 2.2779e-04, 9.4996e-01, 9.4862e-01, 9.4752e-01, 9.4633e-01,\n", + " 9.4510e-01, 9.4386e-01, 9.4262e-01, 9.4137e-01, 9.4010e-01, 9.3882e-01,\n", + " 9.3752e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "769000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(192.2112, grad_fn=) , actor= tensor(8.7872, grad_fn=) , critic= tensor(1834.2391, grad_fn=) , return= 175809.14583881697\n", + "probs of actions: tensor([0.9469, 0.9480, 0.9501, 0.0047, 0.9522, 0.9532, 0.9536, 0.9536, 0.9534,\n", + " 0.9529, 0.9524, 0.9517, 0.9509, 0.9501, 0.9491, 0.9480, 0.9469, 0.9456,\n", + " 0.9444, 0.9431, 0.9419, 0.9406, 0.9393, 0.9381, 0.9368],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "770000 adversary: AdversaryModes.myopic\n", + " actions: tensor([39, 34, 34, 36, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(202.6023, grad_fn=) , actor= tensor(18.9392, grad_fn=) , critic= tensor(1836.6305, grad_fn=) , return= 175822.08344300586\n", + "probs of actions: tensor([4.4673e-03, 9.5188e-01, 9.5427e-01, 8.2607e-04, 9.5647e-01, 9.5726e-01,\n", + " 9.5759e-01, 9.5763e-01, 9.5741e-01, 9.5700e-01, 9.5649e-01, 9.5588e-01,\n", + " 9.5515e-01, 9.5435e-01, 9.5344e-01, 9.5245e-01, 9.5138e-01, 9.5024e-01,\n", + " 9.4907e-01, 9.4790e-01, 9.4673e-01, 9.4555e-01, 9.4436e-01, 9.4315e-01,\n", + " 9.4193e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "771000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 44, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 37, 34])\n", + "loss= tensor(169.1419, grad_fn=) , actor= tensor(-13.3127, grad_fn=) , critic= tensor(1824.5461, grad_fn=) , return= 175789.33409770232\n", + "probs of actions: tensor([0.9510, 0.9520, 0.9540, 0.9554, 0.9563, 0.9570, 0.9573, 0.9574, 0.9572,\n", + " 0.9567, 0.9562, 0.9556, 0.9549, 0.9541, 0.0010, 0.9517, 0.9513, 0.9501,\n", + " 0.9488, 0.9476, 0.9464, 0.9452, 0.9440, 0.0140, 0.9414],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "772000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 44])\n", + "loss= tensor(159.6733, grad_fn=) , actor= tensor(-27.5918, grad_fn=) , critic= tensor(1872.6511, grad_fn=) , return= 174936.33355816206\n", + "probs of actions: tensor([0.9543, 0.9552, 0.9571, 0.9584, 0.9593, 0.9599, 0.9602, 0.9603, 0.9600,\n", + " 0.9596, 0.9592, 0.9586, 0.9579, 0.9571, 0.9562, 0.9553, 0.9542, 0.9531,\n", + " 0.9520, 0.9509, 0.9498, 0.9486, 0.9475, 0.9463, 0.0013],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "773000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 40, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(195.9134, grad_fn=) , actor= tensor(12.3677, grad_fn=) , critic= tensor(1835.4568, grad_fn=) , return= 175822.20829494795\n", + "probs of actions: tensor([9.5482e-01, 9.5577e-01, 9.5762e-01, 5.6639e-04, 9.5947e-01, 9.6044e-01,\n", + " 9.6076e-01, 9.6078e-01, 9.6056e-01, 9.6017e-01, 9.5967e-01, 9.5908e-01,\n", + " 9.5837e-01, 9.5760e-01, 9.5674e-01, 9.5578e-01, 9.5476e-01, 9.5367e-01,\n", + " 9.5255e-01, 9.5143e-01, 9.5031e-01, 9.4918e-01, 9.4803e-01, 9.4687e-01,\n", + " 9.4570e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "774000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5364, grad_fn=) , actor= tensor(-0.2042, grad_fn=) , critic= tensor(1827.4064, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9555, 0.9564, 0.9582, 0.9595, 0.9604, 0.9610, 0.9613, 0.9613, 0.9610,\n", + " 0.9606, 0.9601, 0.9595, 0.9588, 0.9580, 0.9572, 0.9562, 0.9552, 0.9541,\n", + " 0.9530, 0.9518, 0.9507, 0.9496, 0.9484, 0.9473, 0.9461],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "775000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5523, grad_fn=) , actor= tensor(-0.1916, grad_fn=) , critic= tensor(1827.4390, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9589, 0.9598, 0.9615, 0.9627, 0.9635, 0.9641, 0.9644, 0.9644, 0.9642,\n", + " 0.9638, 0.9633, 0.9628, 0.9621, 0.9614, 0.9606, 0.9597, 0.9587, 0.9577,\n", + " 0.9567, 0.9556, 0.9546, 0.9535, 0.9525, 0.9514, 0.9503],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "776000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 37, 37, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(198.2212, grad_fn=) , actor= tensor(14.7759, grad_fn=) , critic= tensor(1834.4531, grad_fn=) , return= 175905.66362664994\n", + "probs of actions: tensor([0.9603, 0.9611, 0.9628, 0.0089, 0.9646, 0.9653, 0.9656, 0.9656, 0.9654,\n", + " 0.9650, 0.9646, 0.0088, 0.0089, 0.9626, 0.9620, 0.9611, 0.9601, 0.9591,\n", + " 0.9580, 0.9570, 0.9560, 0.9550, 0.9539, 0.9528, 0.9518],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "777000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 37, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(177.5940, grad_fn=) , actor= tensor(-4.7398, grad_fn=) , critic= tensor(1823.3381, grad_fn=) , return= 175775.7707968744\n", + "probs of actions: tensor([0.9606, 0.9614, 0.9630, 0.9641, 0.9649, 0.9655, 0.9657, 0.9657, 0.9655,\n", + " 0.9651, 0.9647, 0.9641, 0.9635, 0.9627, 0.9619, 0.9611, 0.9601, 0.9591,\n", + " 0.0100, 0.9569, 0.9561, 0.9550, 0.9539, 0.9528, 0.9518],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "778000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.7692, grad_fn=) , actor= tensor(7.6073, grad_fn=) , critic= tensor(1831.6196, grad_fn=) , return= 175777.520926555\n", + "probs of actions: tensor([0.9597, 0.9605, 0.9622, 0.0095, 0.9639, 0.9646, 0.9649, 0.9649, 0.9646,\n", + " 0.9642, 0.9637, 0.9632, 0.9625, 0.9617, 0.9609, 0.9600, 0.9591, 0.9580,\n", + " 0.9570, 0.9559, 0.9548, 0.9538, 0.9527, 0.9516, 0.9505],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "779000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 37,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(188.5387, grad_fn=) , actor= tensor(5.9758, grad_fn=) , critic= tensor(1825.6289, grad_fn=) , return= 175800.90356166623\n", + "probs of actions: tensor([0.9550, 0.9558, 0.9576, 0.9588, 0.9597, 0.9603, 0.0022, 0.9604, 0.9602,\n", + " 0.9597, 0.9592, 0.9585, 0.9578, 0.9569, 0.9560, 0.9550, 0.9540, 0.0114,\n", + " 0.9515, 0.9506, 0.9494, 0.9482, 0.9470, 0.9458, 0.9446],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "780000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 31, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(176.4126, grad_fn=) , actor= tensor(-6.7064, grad_fn=) , critic= tensor(1831.1903, grad_fn=) , return= 175640.3959532388\n", + "probs of actions: tensor([0.9554, 0.9563, 0.9580, 0.9592, 0.9601, 0.9606, 0.9609, 0.9608, 0.9606,\n", + " 0.9601, 0.9595, 0.9589, 0.9581, 0.9573, 0.9564, 0.9554, 0.9543, 0.9532,\n", + " 0.0015, 0.9510, 0.9496, 0.9485, 0.9473, 0.9461, 0.9449],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "781000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(187.2574, grad_fn=) , actor= tensor(4.2821, grad_fn=) , critic= tensor(1829.7532, grad_fn=) , return= 175813.34405617815\n", + "probs of actions: tensor([0.9579, 0.9587, 0.9604, 0.9616, 0.9623, 0.9629, 0.9631, 0.9631, 0.9628,\n", + " 0.9624, 0.9618, 0.0041, 0.9603, 0.9598, 0.9589, 0.9579, 0.9569, 0.9558,\n", + " 0.9546, 0.9535, 0.9524, 0.9512, 0.9501, 0.9490, 0.9478],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "782000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5429, grad_fn=) , actor= tensor(-0.1965, grad_fn=) , critic= tensor(1827.3937, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9584, 0.9592, 0.9609, 0.9621, 0.9628, 0.9634, 0.9636, 0.9636, 0.9633,\n", + " 0.9628, 0.9623, 0.9617, 0.9610, 0.9602, 0.9593, 0.9584, 0.9573, 0.9563,\n", + " 0.9551, 0.9540, 0.9529, 0.9518, 0.9507, 0.9495, 0.9484],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "783000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5453, grad_fn=) , actor= tensor(-0.1932, grad_fn=) , critic= tensor(1827.3848, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9601, 0.9609, 0.9625, 0.9636, 0.9643, 0.9649, 0.9651, 0.9651, 0.9648,\n", + " 0.9644, 0.9639, 0.9633, 0.9626, 0.9618, 0.9610, 0.9601, 0.9591, 0.9581,\n", + " 0.9570, 0.9559, 0.9549, 0.9538, 0.9527, 0.9516, 0.9505],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "784000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5490, grad_fn=) , actor= tensor(-0.1893, grad_fn=) , critic= tensor(1827.3833, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9604, 0.9612, 0.9628, 0.9639, 0.9647, 0.9652, 0.9654, 0.9654, 0.9652,\n", + " 0.9647, 0.9642, 0.9637, 0.9630, 0.9622, 0.9614, 0.9605, 0.9595, 0.9585,\n", + " 0.9574, 0.9564, 0.9553, 0.9542, 0.9532, 0.9521, 0.9510],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "785000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 37, 34, 34, 34, 34])\n", + "loss= tensor(173.8598, grad_fn=) , actor= tensor(-8.3194, grad_fn=) , critic= tensor(1821.7919, grad_fn=) , return= 175762.8306090006\n", + "probs of actions: tensor([0.9609, 0.9617, 0.9634, 0.9644, 0.9652, 0.9657, 0.9660, 0.9660, 0.9658,\n", + " 0.9654, 0.9649, 0.9643, 0.9637, 0.9629, 0.9621, 0.9613, 0.9603, 0.9593,\n", + " 0.9583, 0.9573, 0.0111, 0.9551, 0.9542, 0.9531, 0.9520],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "786000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 44, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.3522, grad_fn=) , actor= tensor(7.1696, grad_fn=) , critic= tensor(1831.8262, grad_fn=) , return= 175864.54400735002\n", + "probs of actions: tensor([9.6464e-01, 9.6536e-01, 9.6684e-01, 9.6785e-01, 9.6855e-01, 9.6902e-01,\n", + " 9.6924e-01, 9.6922e-01, 9.6900e-01, 9.6862e-01, 5.5732e-04, 9.6720e-01,\n", + " 9.6716e-01, 9.6640e-01, 9.6563e-01, 9.6479e-01, 9.6389e-01, 9.6295e-01,\n", + " 9.6197e-01, 9.6099e-01, 9.6002e-01, 9.5904e-01, 9.5805e-01, 9.5705e-01,\n", + " 9.5604e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "787000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 37, 34, 34, 34, 34, 34, 34, 41, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(197.7517, grad_fn=) , actor= tensor(14.0791, grad_fn=) , critic= tensor(1836.7261, grad_fn=) , return= 175897.95609163868\n", + "probs of actions: tensor([0.9629, 0.9636, 0.0101, 0.9660, 0.9669, 0.9674, 0.9676, 0.9676, 0.9673,\n", + " 0.0030, 0.9661, 0.9660, 0.9653, 0.9646, 0.9638, 0.9629, 0.9620, 0.9610,\n", + " 0.9600, 0.9590, 0.9580, 0.9570, 0.9560, 0.9549, 0.9539],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "788000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.3971, grad_fn=) , actor= tensor(6.3144, grad_fn=) , critic= tensor(1830.8271, grad_fn=) , return= 175779.92129619914\n", + "probs of actions: tensor([0.9640, 0.9647, 0.9661, 0.9672, 0.9679, 0.9683, 0.9685, 0.0093, 0.9682,\n", + " 0.9679, 0.9674, 0.9669, 0.9663, 0.9655, 0.9648, 0.9639, 0.9630, 0.9621,\n", + " 0.9611, 0.9601, 0.9591, 0.9581, 0.9571, 0.9561, 0.9551],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "789000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 38, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(193.4268, grad_fn=) , actor= tensor(10.1737, grad_fn=) , critic= tensor(1832.5317, grad_fn=) , return= 175796.81202292445\n", + "probs of actions: tensor([0.9609, 0.9617, 0.9633, 0.9643, 0.9651, 0.0014, 0.9656, 0.9658, 0.9655,\n", + " 0.9651, 0.9646, 0.9640, 0.9633, 0.9625, 0.9617, 0.9608, 0.9598, 0.9588,\n", + " 0.9577, 0.9566, 0.9556, 0.9545, 0.9534, 0.9523, 0.9512],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "790000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(188.5253, grad_fn=) , actor= tensor(5.4621, grad_fn=) , critic= tensor(1830.6321, grad_fn=) , return= 175813.35544943047\n", + "probs of actions: tensor([0.9661, 0.9668, 0.9682, 0.9692, 0.9699, 0.9703, 0.9705, 0.9705, 0.9703,\n", + " 0.9699, 0.0032, 0.9687, 0.9684, 0.9677, 0.9670, 0.9662, 0.9653, 0.9644,\n", + " 0.9634, 0.9625, 0.9615, 0.9606, 0.9596, 0.9586, 0.9576],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "791000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 37])\n", + "loss= tensor(165.0832, grad_fn=) , actor= tensor(-18.8779, grad_fn=) , critic= tensor(1839.6117, grad_fn=) , return= 175503.33355816206\n", + "probs of actions: tensor([0.9662, 0.9669, 0.9683, 0.9693, 0.9700, 0.9704, 0.9706, 0.9706, 0.9704,\n", + " 0.9700, 0.9696, 0.9691, 0.9685, 0.9678, 0.9671, 0.9663, 0.9654, 0.9645,\n", + " 0.9635, 0.9626, 0.9616, 0.9607, 0.9597, 0.9587, 0.0101],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "792000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 39, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(190.3897, grad_fn=) , actor= tensor(7.1788, grad_fn=) , critic= tensor(1832.1096, grad_fn=) , return= 175813.27640891031\n", + "probs of actions: tensor([0.9680, 0.9686, 0.9700, 0.9709, 0.9716, 0.9720, 0.9722, 0.9722, 0.0031,\n", + " 0.9714, 0.9713, 0.9708, 0.9702, 0.9695, 0.9688, 0.9681, 0.9672, 0.9664,\n", + " 0.9655, 0.9645, 0.9636, 0.9627, 0.9618, 0.9609, 0.9599],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "793000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 42, 34, 34, 34, 34, 34])\n", + "loss= tensor(172.1091, grad_fn=) , actor= tensor(-9.2828, grad_fn=) , critic= tensor(1813.9188, grad_fn=) , return= 175826.6615789955\n", + "probs of actions: tensor([0.9686, 0.9693, 0.9706, 0.9715, 0.9721, 0.9726, 0.9727, 0.9727, 0.9725,\n", + " 0.9721, 0.9717, 0.9712, 0.9706, 0.9700, 0.9693, 0.9685, 0.9677, 0.9669,\n", + " 0.9660, 0.0014, 0.9638, 0.9635, 0.9624, 0.9615, 0.9605],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "794000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5813, grad_fn=) , actor= tensor(-0.1588, grad_fn=) , critic= tensor(1827.4009, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9685, 0.9691, 0.9705, 0.9714, 0.9720, 0.9724, 0.9726, 0.9726, 0.9723,\n", + " 0.9720, 0.9715, 0.9710, 0.9704, 0.9698, 0.9691, 0.9683, 0.9675, 0.9666,\n", + " 0.9657, 0.9648, 0.9639, 0.9629, 0.9620, 0.9611, 0.9601],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "795000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 26, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(189.1568, grad_fn=) , actor= tensor(7.3695, grad_fn=) , critic= tensor(1817.8734, grad_fn=) , return= 175465.765198767\n", + "probs of actions: tensor([9.6763e-01, 9.6828e-01, 9.6966e-01, 9.7059e-01, 9.7125e-01, 9.7168e-01,\n", + " 9.7187e-01, 9.7184e-01, 9.7162e-01, 9.7125e-01, 4.4811e-04, 9.7056e-01,\n", + " 9.6959e-01, 9.6898e-01, 9.6830e-01, 9.6753e-01, 9.6670e-01, 9.6581e-01,\n", + " 9.6488e-01, 9.6394e-01, 9.6302e-01, 9.6208e-01, 9.6114e-01, 9.6018e-01,\n", + " 9.5921e-01], grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "796000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 37, 42, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(195.7049, grad_fn=) , actor= tensor(12.2592, grad_fn=) , critic= tensor(1834.4575, grad_fn=) , return= 175915.2701222619\n", + "probs of actions: tensor([0.9671, 0.9678, 0.9691, 0.9701, 0.9707, 0.9711, 0.9713, 0.9713, 0.9710,\n", + " 0.0075, 0.0011, 0.9693, 0.9691, 0.9684, 0.9676, 0.9668, 0.9659, 0.9650,\n", + " 0.9640, 0.9630, 0.9621, 0.9611, 0.9602, 0.9592, 0.9582],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "797000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 32, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(176.3025, grad_fn=) , actor= tensor(-6.6915, grad_fn=) , critic= tensor(1829.9407, grad_fn=) , return= 175667.54186223666\n", + "probs of actions: tensor([0.9664, 0.9671, 0.9685, 0.9694, 0.9701, 0.9705, 0.9707, 0.9707, 0.9704,\n", + " 0.9700, 0.9695, 0.9690, 0.9684, 0.9677, 0.9670, 0.9661, 0.9653, 0.9643,\n", + " 0.0014, 0.9625, 0.9614, 0.9604, 0.9595, 0.9585, 0.9575],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "798000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5591, grad_fn=) , actor= tensor(-0.1793, grad_fn=) , critic= tensor(1827.3837, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9651, 0.9658, 0.9672, 0.9682, 0.9689, 0.9693, 0.9695, 0.9695, 0.9692,\n", + " 0.9688, 0.9683, 0.9677, 0.9671, 0.9664, 0.9656, 0.9648, 0.9639, 0.9629,\n", + " 0.9619, 0.9609, 0.9599, 0.9589, 0.9579, 0.9569, 0.9558],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "799000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5574, grad_fn=) , actor= tensor(-0.1829, grad_fn=) , critic= tensor(1827.4030, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9631, 0.9638, 0.9653, 0.9663, 0.9670, 0.9675, 0.9677, 0.9676, 0.9674,\n", + " 0.9670, 0.9664, 0.9659, 0.9652, 0.9644, 0.9636, 0.9628, 0.9618, 0.9608,\n", + " 0.9598, 0.9587, 0.9577, 0.9566, 0.9556, 0.9545, 0.9534],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "800000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5667, grad_fn=) , actor= tensor(-0.1718, grad_fn=) , critic= tensor(1827.3848, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9666, 0.9673, 0.9687, 0.9696, 0.9703, 0.9707, 0.9709, 0.9709, 0.9706,\n", + " 0.9703, 0.9698, 0.9693, 0.9687, 0.9680, 0.9673, 0.9665, 0.9656, 0.9647,\n", + " 0.9637, 0.9628, 0.9618, 0.9608, 0.9599, 0.9589, 0.9579],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "801000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 31, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(176.3580, grad_fn=) , actor= tensor(-6.7606, grad_fn=) , critic= tensor(1831.1860, grad_fn=) , return= 175640.3959532388\n", + "probs of actions: tensor([0.9664, 0.9671, 0.9685, 0.9695, 0.9701, 0.9706, 0.9708, 0.9707, 0.9705,\n", + " 0.9701, 0.9697, 0.9691, 0.9685, 0.9679, 0.9671, 0.9663, 0.9655, 0.9645,\n", + " 0.0013, 0.9627, 0.9616, 0.9607, 0.9597, 0.9588, 0.9578],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "802000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 42, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(174.8715, grad_fn=) , actor= tensor(-6.7356, grad_fn=) , critic= tensor(1816.0713, grad_fn=) , return= 175838.1653809262\n", + "probs of actions: tensor([0.9661, 0.9667, 0.9681, 0.9691, 0.9698, 0.9702, 0.9704, 0.9704, 0.9701,\n", + " 0.9697, 0.9693, 0.9687, 0.9681, 0.9674, 0.9667, 0.9659, 0.9650, 0.9641,\n", + " 0.0013, 0.9618, 0.9614, 0.9603, 0.9593, 0.9582, 0.9572],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "803000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5625, grad_fn=) , actor= tensor(-0.1763, grad_fn=) , critic= tensor(1827.3873, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9661, 0.9667, 0.9681, 0.9691, 0.9697, 0.9702, 0.9704, 0.9703, 0.9701,\n", + " 0.9697, 0.9692, 0.9687, 0.9681, 0.9674, 0.9666, 0.9658, 0.9649, 0.9640,\n", + " 0.9630, 0.9620, 0.9611, 0.9601, 0.9591, 0.9581, 0.9571],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "804000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5715, grad_fn=) , actor= tensor(-0.1684, grad_fn=) , critic= tensor(1827.3998, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9674, 0.9680, 0.9694, 0.9703, 0.9709, 0.9714, 0.9715, 0.9715, 0.9712,\n", + " 0.9708, 0.9703, 0.9698, 0.9692, 0.9685, 0.9678, 0.9670, 0.9661, 0.9652,\n", + " 0.9642, 0.9633, 0.9623, 0.9613, 0.9604, 0.9594, 0.9584],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "805000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5618, grad_fn=) , actor= tensor(-0.1786, grad_fn=) , critic= tensor(1827.4034, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9682, 0.9688, 0.9701, 0.9710, 0.9716, 0.9720, 0.9722, 0.9721, 0.9719,\n", + " 0.9715, 0.9710, 0.9704, 0.9698, 0.9691, 0.9684, 0.9676, 0.9667, 0.9658,\n", + " 0.9649, 0.9639, 0.9629, 0.9620, 0.9610, 0.9600, 0.9590],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "806000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5717, grad_fn=) , actor= tensor(-0.1680, grad_fn=) , critic= tensor(1827.3971, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9705, 0.9711, 0.9723, 0.9731, 0.9737, 0.9741, 0.9742, 0.9741, 0.9739,\n", + " 0.9735, 0.9730, 0.9725, 0.9719, 0.9713, 0.9706, 0.9698, 0.9690, 0.9682,\n", + " 0.9673, 0.9663, 0.9654, 0.9645, 0.9636, 0.9627, 0.9617],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "807000 adversary: AdversaryModes.myopic\n", + " actions: tensor([41, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 35, 34, 34, 34, 34])\n", + "loss= tensor(180.2090, grad_fn=) , actor= tensor(-3.2313, grad_fn=) , critic= tensor(1834.4026, grad_fn=) , return= 175808.9165222061\n", + "probs of actions: tensor([0.0028, 0.9690, 0.9708, 0.9716, 0.9722, 0.9726, 0.9727, 0.9727, 0.9724,\n", + " 0.9720, 0.9716, 0.9710, 0.9704, 0.9697, 0.9690, 0.9682, 0.9674, 0.9665,\n", + " 0.9656, 0.9646, 0.0024, 0.9627, 0.9618, 0.9609, 0.9599],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "808000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 34, 34, 34])\n", + "loss= tensor(182.5710, grad_fn=) , actor= tensor(-0.1676, grad_fn=) , critic= tensor(1827.3860, grad_fn=) , return= 175716.33355816206\n", + "probs of actions: tensor([0.9697, 0.9703, 0.9716, 0.9724, 0.9730, 0.9734, 0.9735, 0.9734, 0.9732,\n", + " 0.9728, 0.9723, 0.9718, 0.9712, 0.9706, 0.9699, 0.9691, 0.9683, 0.9674,\n", + " 0.9665, 0.9656, 0.9647, 0.9637, 0.9628, 0.9619, 0.9609],\n", + " grad_fn=)\n", + "shouldBreak: False\n", + "--------------------------------------------------\n", + "809000 adversary: AdversaryModes.myopic\n", + " actions: tensor([34, 32, 34, 42, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n", + " 34, 34, 34, 34, 35, 34, 34])\n", + "loss= tensor(188.3972, grad_fn=) , actor= tensor(5.0255, grad_fn=) , critic= tensor(1833.7164, grad_fn=) , return= 175797.41135485223\n", + "probs of actions: tensor([0.9692, 0.0013, 0.9712, 0.0012, 0.9722, 0.9729, 0.9730, 0.9729, 0.9727,\n", + " 0.9723, 0.9718, 0.9713, 0.9707, 0.9700, 0.9693, 0.9685, 0.9677, 0.9668,\n", + " 0.9659, 0.9649, 0.9640, 0.9630, 0.0026, 0.9611, 0.9602],\n", + " grad_fn=)\n", + "shouldBreak: False\n" + ] + } + ], + "source": [ + "algorithm.solver(print_step=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# neuralNet.load(name=name)\n", + "\"hi\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/LearningAgent_Simulations.ipynb b/learningAgents/naive_policy_gradient/LearningAgent_Simulations.ipynb new file mode 100644 index 0000000..dd7c9a3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/LearningAgent_Simulations.ipynb @@ -0,0 +1,989 @@ +{ + "cells": [ + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 1, +======= + "execution_count": 43, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 2, +======= + "execution_count": 44, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.0000, 0.5000, 0.5000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0000])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=0\n", + "adversaryProbs[1]=1/2\n", + "adversaryProbs[2]=1/2\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25,\n", + " initState = [200,200], adversaryProbs=adversaryProbs)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 3, +======= + "execution_count": 45, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([200., 200.]), 0, False)" + ] + }, +<<<<<<< Updated upstream + "execution_count": 3, +======= + "execution_count": 45, +>>>>>>> Stashed changes + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 4, +======= + "execution_count": 46, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "95" + ] + }, +<<<<<<< Updated upstream + "execution_count": 4, +======= + "execution_count": 46, +>>>>>>> Stashed changes + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 5, +======= + "execution_count": 47, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Hyperparameters\n", +<<<<<<< Updated upstream + "def NeuralNetwork():\n", + " lr = .0009\n", + " num_actions = 20\n", +======= + "# def NeuralNetwork():\n", + "# lr = .000001\n", + "# num_actions = 50\n", + "\n", + "# nn_ = 100\n", + "\n", + "# policy = nn.Sequential(\n", + "# nn.Linear(2, nn_), \n", + "# nn.ReLU(),\n", + "# nn.Linear(nn_,nn_),\n", + "# nn.ReLU(),\n", + "# nn.Linear(nn_,num_actions), \n", + "# nn.Softmax(dim=0))\n", + "# optim = torch.optim.Adam(policy.parameters(), lr=lr)\n", + "\n", + "# return policy, optim\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Sequential(\n", + " (0): Linear(in_features=2, out_features=100, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=100, out_features=100, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=100, out_features=50, bias=True)\n", + " (5): Softmax(dim=0)\n", + ")" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "lr = .000001\n", + "num_actions = 50\n", +>>>>>>> Stashed changes + "\n", + "nn_ = 100\n", + "\n", +<<<<<<< Updated upstream + " policy = nn.Sequential(\n", + " nn.Linear(2, nn_), \n", + " nn.ReLU(),\n", + " nn.Linear(nn_,nn_),\n", + " nn.ReLU(),\n", + " nn.Linear(nn_,num_actions), \n", + " nn.Softmax(dim=0))\n", + " optim = torch.optim.Adam(policy.parameters(), lr=lr)\n", +======= + "policy = nn.Sequential(\n", + " nn.Linear(2, nn_), \n", + " nn.ReLU(),\n", + " nn.Linear(nn_,nn_),\n", + " nn.ReLU(),\n", + " nn.Linear(nn_,num_actions), \n", + " nn.Softmax(dim=0))\n", + "optim = torch.optim.Adam(policy.parameters(), lr=lr)\n", +>>>>>>> Stashed changes + "\n", + "policy\n" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm = ReinforceAlgorithm(game, NeuralNetwork, numberIterations=1, numberEpisodes=20000, discountFactor =1)" +======= + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork()\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=10_000, discountFactor =0.9)" +>>>>>>> Stashed changes + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, +======= + "execution_count": 49, +>>>>>>> Stashed changes + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": {}, + "outputs": [], +======= + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "name=f\"nn, ep={algorithm.numberEpisodes}\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet.load(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "143329.38640393192" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], +>>>>>>> Stashed changes + "source": [ + "algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, +======= + "execution_count": 53, +>>>>>>> Stashed changes + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": {}, + "outputs": [], +======= + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.000000200.000000
1202.250000197.750000
2199.437500200.562500
3197.328125202.671875
4191.246094208.753906
5191.184570208.815430
6186.638428213.361572
7180.728821219.271179
8183.296616216.703384
9180.722462219.277538
10178.791846221.208154
11177.343885222.656115
12173.757914226.242086
13173.568435226.431565
14177.926326222.073674
15181.194745218.805255
16183.646059216.353941
17185.484544214.515456
18172.863408227.136592
19163.397556236.602444
20170.298167229.701833
21168.473625231.526375
22169.605219230.394781
23174.953914225.046086
24174.465436225.534564
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.000000 200.000000\n", + "1 202.250000 197.750000\n", + "2 199.437500 200.562500\n", + "3 197.328125 202.671875\n", + "4 191.246094 208.753906\n", + "5 191.184570 208.815430\n", + "6 186.638428 213.361572\n", + "7 180.728821 219.271179\n", + "8 183.296616 216.703384\n", + "9 180.722462 219.277538\n", + "10 178.791846 221.208154\n", + "11 177.343885 222.656115\n", + "12 173.757914 226.242086\n", + "13 173.568435 226.431565\n", + "14 177.926326 222.073674\n", + "15 181.194745 218.805255\n", + "16 183.646059 216.353941\n", + "17 185.484544 214.515456\n", + "18 172.863408 227.136592\n", + "19 163.397556 236.602444\n", + "20 170.298167 229.701833\n", + "21 168.473625 231.526375\n", + "22 169.605219 230.394781\n", + "23 174.953914 225.046086\n", + "24 174.465436 225.534564" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAD8CAYAAACW/ATfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA5FElEQVR4nO3dd3hUVfrA8e+bTgk9lJBAQu81oHTEAmLBiqAiRUUU67oWdHf1t66ua8FeQEFFuoKCqCAICCgtofdeQiB0Ekr6+f1xBo0IZBJmcpOZ9/M8eZicuffOexl458y5575HjDEopZTybQFOB6CUUsr7NNkrpZQf0GSvlFJ+QJO9Ukr5AU32SinlBzTZK6WUH8gz2YtItIjME5GNIrJeRB475/m/i4gRkUq52oaJyDYR2Swi3b0RuFJKKfcFubFNFvCkMWaFiIQDCSIy2xizQUSigauBPWc3FpFGQB+gMRAJzBGResaYbC/Er5RSyg159uyNMfuNMStcj1OBjUB119NvAU8Due/M6gVMNMakG2N2AtuAth6NWimlVL6407P/nYjEAC2BpSJyI7DPGLNaRHJvVh1Ykuv3RP74cDivSpUqmZiYmPyEopRSfi8hIeGwMSbCnW3dTvYiUhqYAjyOHdp5HrjmfJuep+0vNRlEZDAwGKBGjRrEx8e7G4pSSilARHa7u61bs3FEJBib6McZY6YCtYFYYLWI7AKigBUiUhXbk4/OtXsUkHTuMY0xI40xccaYuIgItz6YlFJKFZA7s3EEGAVsNMYMBzDGrDXGVDbGxBhjYrAJvpUx5gAwHegjIqEiEgvUBZZ57QyUUkrlyZ1hnA5AP2CtiKxytT1njPnhfBsbY9aLyGRgA3a4Z6jOxFFKKWflmeyNMYs4/zh87m1izvn9ZeDlSwksMzOTxMRE0tLSLuUwXhcWFkZUVBTBwcFOh6KUUheUr9k4hSkxMZHw8HBiYmI4Z7ZPkWGM4ciRIyQmJhIbG+t0OEopdUFFtlxCWloaFStWLLKJHkBEqFixYpH/9qGUUkU22QNFOtGfVRxiVEqpIp3si4KZM2dSv3596tSpw6uvvup0OEr5lsw0WDUBMk47HYnP02R/EdnZ2QwdOpQff/yRDRs2MGHCBDZs2OB0WEr5jiUfwLdDYPa/nI7E52myv4hly5ZRp04datWqRUhICH369GHatGlOh6WUb0g/Cb+9D8ElYfknsH2e0xH5NE32F7Fv3z6io/+4GTgqKop9+/Y5GJFSPmT5J3DmKNw5GSrWhWkPQ9oJp6PyWUV26mVu//fdejYkpXj0mI0iy/DCDY0vuo0xfynpoxdklfKE9JPw23tQ+0qI7QQ3fwyjroaZw+CmD52Ozidpz/4ioqKi2Lt37++/JyYmEhkZ6WBESvmI+FFw+gh0fdb+HhUHHf8Gq8bBpvPenK8uUbHo2efVA/eWNm3asHXrVnbu3En16tWZOHEi48ePdyQWpXxGxin49V2odQVE51rqosszsGUmfPcYRF8GpSo6F6MP0p79RQQFBfH+++/TvXt3GjZsSO/evWnc2JkPHqV8RvxoOH34j179WUEhdjjnzDH4/m9wnmFUVXDFomfvpJ49e9KzZ0+nw1DKN2Schl/fgdguUOPyvz5ftan9EJj7EqybAk1vK/wYfZT27JVShSfhMzh16K+9+tw6PA7V4+D7JyH1QKGF5us02SulCkfmGdurj+kENdtfeLvAIDuck5UG0x/V4RwP0WSvlCocCZ/DyeSL9+rPqlQXrnoRts6ClV96OzK/oMleKeV9mWmw6G2o2RFiOrq3T9sH7PYzh8Ext5daVRegyV4p5X0rvoCTB6DrM+7vExAAN31gH08bCjk53onNT2iyV0p5V2YaLHoLarS34/X5UT4Gur8Cuxba8gr5lZUO67+BCX1h8j2wdATsXwM5/rdSap5TL0UkGhgDVAVygJHGmHdE5CWgl6vtIDDAGJPk2mcYcC+QDTxqjJnlpfi9atCgQcyYMYPKlSuzbt06p8NRqnha+SWk7rcXXQtSbqTVPbDxO5j9gi2vUKlO3vsc3AgrvoQ1E+2duuGREBAEG1yFDEPL2qmfNdtBzQ5QrYWd5+/D3JlnnwU8aYxZISLhQIKIzAZeN8b8E0BEHgX+BQwRkUZAH6AxEAnMEZF6xXHR8QEDBvDwww9zzz33OB2KUsVTVrrt1UdfbufWF4QI3PgefHi5LYc8cKadsXOu9JOwfiqsGAOJyyEgGOpfC636Q+0rICAQju+FPYth96+w+zd7ARggqIQt2VCzg50pFNUGQkoW/LyLIHcWHN8P7Hc9ThWRjUB1Y0zuwu6lgLPzo3oBE40x6cBOEdkGtAUWezTyQtC5c2d27drldBhKFV8rv4SUfdDr/YL16s8qUw16vgFT74Pf3oVOf7PtxtjEvmIMrJsKmaegUn245j/QrA+UjvjzccpF259mve3vJw+5kv9v9gNgwWtgcuy3gOpxcOO7EFG/4HEXIfm6g1ZEYoCWwFLX7y8D9wAngCtcm1UHluTaLdHVppTyJ1npsPAtiGpr6+Bcqqa3wabvYN4rUL01HFhrP0wObYLgUtDkZmh5j6234+4HS+kIaHSj/QFbYnnvMpv8V34JY2+F++ZAeNVLj99hbid7ESkNTAEeN8akABhjngeed43RPwy8AJzvb/kvd0WIyGBgMECNGjUu/uI/PmvfWE+q2hSu1WUGlfKaVeMgJRFufOfSevVnicB1w20iHuNKzlFt4IZ3ocktEBp+6a8RVhbqXm1/GvWCz3rCuNth4A+eOb6D3JqNIyLB2EQ/zhgz9TybjAdudT1OBKJzPRcFJJ27gzFmpDEmzhgTFxERce7TSqniLCsDFg63ybj2lZ47bqlK0HuMLYf84GLb627d3zuJOLIF9P4CktfDVwMgO9Pzr1GI3JmNI8AoYKMxZniu9rrGmK2uX28ENrkeTwfGi8hw7AXausCyS4pSe+BKFS+rx8OJvXD9257p1edWs/3Fyy14Ut2r4fq34LtHbSXOG971/PkUEnd69h2AfkA3EVnl+ukJvCoi60RkDXAN8BiAMWY9MBnYAMwEhhbHmTgAffv2pV27dmzevJmoqChGjRrldEhKFX3ZmbDwTTuuXseDvXqntO4PnZ+yF4EXvOF0NAXmzmycRZx/HP6Cy8kYY14GXr6EuIqECRMmOB2CUsXP6glwfA/0fLPY9oL/4orn7bTNef+BslHQoq/TEeWb1rNXSnlOdqbt/Ua2tEMgvuLsXP/U/TD9YTs7p7YHZhgVIi2XoJTynDWT4Phu6PKs7/TqzwoKgTu+tPP4J/WDA8XrrnpN9kopz8jJsWP11VpAve5OR+MdYWXhrq/s7J9xt8OJfU5H5LYinexNMVi0oDjEqApRTnaxn6JXYHt+g6M7oN1Q3+vV51a2uk346ak24aedcDoitxTZMfuwsDCOHDlCxYoVkSL6D8cYw5EjRwgLC3M6FOUN2Zmw/FM4tgsyT9v1UzPP2Me//5xxtbseZ6fbuzlv/viPuzL9xaoJEBIODa53OhLvq9oE7hhjk/2kfnDX10W+kFqRTfZRUVEkJiZy6NAhp0O5qLCwMKKiopwOQ3naiX3w9UDYu9RWSAwuYX9CSrkel4QSFVxtJe3vwSVsot86C77qb+dkt+rn9JkUjoxTsOFbaHyzzxUQu6Da3exF228ftPPwb/qoSH+jKbLJPjg4mNjYWKfDUP5o288w9X5b2+W2z+yt+PnR/mGYdLedtZF2HNo/4pUwi5SN30HGSWhxp9ORFK4Wd8KJRJj3MpSNhm7Pn387Y+y/hdQDkJJkZ/Wk7Ld/VmkEbe7zeqhFNtkrVehysuGX1+CX/0Hlhva2/Ep183+ckFLQdyJMHQw//QPOHINu/yzSvb5Ltmq8XWikRjunIyl8nZ+y9xUseA0wUKL8n5P52cdZZ/66b4nyIIVz6VSTvVIApw7DlHthx3xo3tcW3LqU4YigULhtNMwoa2eonDlmS/QGBHos5CLj+F7YucAuJO7LH2gXImJLKqTuhwWv27agMDsXPzzS3nNQvyeEV7OlmsNz/QQX3vU+TfZK7VkCXw20Kxrd8K5dGckTSSsgEG54B0pWsAt4nDkON48o8hfy8m3NRMBA8z5OR+KcwGC4c7KdjVSyoqvHXrQ++DTZK/9lDCx+3y53V66GraBYrZlnX0MErnrR/uef/S9IT4HeX/rORUxj7Cycmh3tMI4/Cwgs2LBfISnS8+yV8pozx+1F1J/+YZeue+AXzyf63Do8Zr81bJ8LX95kh3V8QeJyOLq9WNaK8Tea7JX/2b8GRnaFLTPhmpfhjrH2zkhva93fzu7ZtwI+vx5Sk73/mt62apyddtqol9ORqDxoslf+wxhI+Bw+vcpOqxzwvZ0mWZhjq41vgrsmw9GdMLq7vWGruMo8A+u+gYY3FvtVnPyBJnvl+1KS7J2wY26E7x6zC18MWQg1Lncmntrd4J5pdihndA84uNGZOC7V5h8g/YQO4RQTeoFW+R5j4OAG2PQDbP4eklba9gq14Kr/szc5OT0FMroNDPwRvrwZPrvW3m4fFedsTPm1agKUiYKYzk5HotygyV75huwsW4hr0w+2x3l8t22vHgdX/gvqXwcR9YvWdLgqjeDeWTDmJpvwu/0D2j3s/AeRO1L2w/afoeMTEKADBMWBJntVfKWn2tIGm3+ALbPs7eiBoVCrq01C9a+1N7YUZeVj4L6fYcZjdmrmllm2xkr5mk5HdnFrJ4PJgeZ+Vh6hGHNnwfFoYAxQFcgBRhpj3hGR14EbgAxgOzDQGHPctc8w4F4gG3jUGDPLO+Erv2MM7FkMy0fBxumQnWHnsNe/1t6lWLsbhJZ2Osr8KVXRzr1fPQF+eBo+6gA9X7c3KRWlbyJnnZ1bH9UWKtVxOhrlJnd69lnAk8aYFSISDiSIyGxgNjDMGJMlIv8DhgHPiEgjoA/QGIgE5ohIveK66LgqItJS7CpI8aPteHxoWWg9wE75i74cAov5l1QRW1SrZgf4Zgh8O8R+Y7n+bfthUJQkrYRDG22JAFVsuLPg+H5gv+txqohsBKobY37KtdkS4DbX417ARGNMOrBTRLYBbYHFHo1c+YcDa20vfs1kyDwF1ZrbsrJNbrUFx3xN+ZowYIa9s/fnl2yJ5V4fFK31XFdPsMNljfNZDVQ5Kl/dIRGJAVoCS895ahAwyfW4Ojb5n5XoalPKPZlpsGEaxI+yyS4ozCb3uHuhequiObThSQGB9o7b2t1s5cxxt9lzv+Yl5z/gsjJg7dfQ4DooUc7ZWFS+uJ3sRaQ0MAV43BiTkqv9eexQz7izTefZ/S9r94nIYGAwQI0aNfIRsvJZR3dA/GewciycOQoVakP3V2wVypIVnI6u8FVtCvfPg7kvweIPbEXOW0Y6O0Vz6yz73vhb3Xof4NacKREJxib6ccaYqbna+wPXA3eZPxZjTQSic+0eBSSde0xjzEhjTJwxJi4iIqKg8StvS0yAaUPhwDrvvUbSKru827utbFKL6QD9voWH4+16pv6Y6M8KDoPuL0P/6fau31HXwLz/OrfO7arxULoK1LrCmddXBebObBwBRgEbjTHDc7X3AJ4BuhhjTufaZTowXkSGYy/Q1gWWeTRqVThSkmBCHzh1EFaOs725K563Cy57wvE9MPc/9sJriQrQ5RlbP6ZMpGeO70tiO8ODv8KPz8Avr8LWn+y1i6pNCi+GU4ft617+UPG/IO6H3HnHOgD9gLUissrV9hzwLhAKzHYtCL7EGDPEGLNeRCYDG7DDO0N1Jk4xlJVuF1LOOAUDZ9o7UZeOgHVT4PIH7Tz2ghYPO3PMLuixdIRdpafjE5d2PH9RohzcMgLq94AZT8DHHaHpbdB1GFSs7f3XX/sV5GTpEE4xJX+MvjgnLi7OxMfHOx2Gyu27x2zRsN5j/qhoeGy3XWvz95740/bCobuLcWSlw7JP7Go+aSdc3xSeg7K6YHu+nT4Kv70LSz629xq0vNu+H978u/y4I0igLQetigQRSTDGuHURR+9zVn+V8Ln96fjEn0vXlq9pLxAO/sVePJz5LHzQxvb2L9ZpyMmBNV/B+3Hw0/P2AuOQRXDTh5roC6pkBbsoymOr7WLVq8bbax4zn7PDLZ52YJ2dBqu9+mJLk736s8R4+OEpO+2v2z/Pv01kC1u18e4pEFIavh4En3SDXYv+uu3OBfDJFTD1PjtM0+9bu19hjjX7svAq0PM1eHQFNLsdln4E7zS310LOHPfc66yeAAHB0OS2vLdVRZIO46g/pCbbRT0Cg2HwfPdmweRk22Gduf+BlH1Qr4ftcRoDc16wF/TKRtsPjqa3a9Esbzu0Bea/Auu/gbBydr7+ZQ9c2vz87EwY3gii20KfcXlvrwpNfoZxNNkrKzsTvrjR3gp/32w7TJMfmWdg6cewcDhknLRtIeHQ+Ulo+4CdQqgKz/7VMPdlOy++VGXo/JSd6RQUmv9jbZ4JE+6APuPtzVSqyNBkr/Lvh6dh2Qi45VM7HFBQp47YW/1FbLlef54jXxTsWQo//xt2L7LfsFoPgBZ3QZlq7h9j8j12iO5vm9y/GK8KhSZ7lT+rJtjCW5cPhR6vOB2N8jRjYMc8+61r10I7o6Zed2h1D9S5+uJz5k8fhTfr21lX175aeDErt+Qn2eudEf4uaRXMeBxiOsHV/3Y6GuUNIvaCe+1ucGS7LUexapytqlm6KrS8y07drFDrr/uum2KndurSg8We9uz92akjMLKL7fk98AuUquR0RKqwZGfai+crxtg/TQ7EdrG9/QbX/3GN5ZNutjDdg7/6fgG6Ykh79ipv2Vnw9QA4eRAGzdRE728Cg+3F1gbX2bIYK8fByjEw5V67GEyzPrZG0b4EuOY/muh9gCZ7f/Xzi3YOfK8Pbdlg5b/KREKXp6DTk7DzF9vbjx9l5+xLIDTt7XSEygM02fujtV/Db+/ZOy9b3uV0NKqoCAiA2lfYn1NH7P0TwSXsjVuq2NNk728OrIPpj9il/Lr/1+loVFFVqiK0e8jpKJQH6e2M/iT1AEy6C0LL2AJnOmdaKb+hPXt/cSIRvrgBTh6ydW30q7lSfkWTvT84tssm+jPHod83EN3G6YiUUoVMk72vO7LdJvqMU7ZHrzNvlPJLmux92cFNMOZGW5lywIz8FzdTSvkMvUDrqw6shc972scDvtdEr5SfyzPZi0i0iMwTkY0isl5EHnO13+76PUdE4s7ZZ5iIbBORzSLS3VvBqwvYtwI+vx6CwmDgj1C5gdMRKaUc5s4wThbwpDFmhYiEAwkiMhtYB9wCjMi9sYg0AvoAjYFIYI6I1NNFxwvJ3mUw9la7OHX/76B8jNMRKaWKgDx79saY/caYFa7HqcBGoLoxZqMxZvN5dukFTDTGpBtjdgLbgLaeDFpdwK5FMOYmKBVhe/Sa6JVSLvkasxeRGKAlsPQim1UH9ub6PdHVprxp+1wYe5tdwHvgD7qQt1LqT9xO9iJSGpgCPG6MSbnYpudp+0sdZREZLCLxIhJ/6NAhd8NQ57N5JozvAxVr24ux4VWdjkgpVcS4lexFJBib6McZY6bmsXkiEJ3r9ygg6dyNjDEjjTFxxpi4iIgId+NV59owHSbdDZUb2jH60vp3qZT6qzwv0IqIAKOAjcaY4W4cczowXkSGYy/Q1gWWXVKU/iDzDOz4BbLSwGTbufE52bkeZ9kFJn5/nG2XjPvtPajeGu7+GsLKOn0WSqkiyp3ZOB2AfsBaEVnlansOCAXeAyKA70VklTGmuzFmvYhMBjZgZ/IM1Zk4ecjJhol3wfaf879vrSvgji8hNNzzcSmlfEaeyd4Ys4jzj8MDfHOBfV4GXr6EuPzLgtdtor/631DnKrtgRECQrS/+++NA1+PAPz8OCtNVhJRSedJyCU7bOgfmvwrN+0L7RzVxK6W8QsslOOn4Hph6H1RuBNcN10SvlPIaTfZOyUqHyf3teP0dX0JISacjUkr5MB3GccrMYZC0Au4Ya+fHK6WUF2nP3gmrJ0H8KDtG3/AGp6NRSvkBTfaFLXk9fPcY1OwAV77gdDRKKT+hyb4wpaXApH4QVgZuGw2BOoqmlCocmm0KizEw7SG7Hmz/77R+jVKqUGmyLyyLP4CN38HVL0FMB6ejUUr5GR3GKQy7f4PZ/7IXY9s/4nQ0Sik/pMne21KT4asBdiGRXh/ojVNKKUfoMI43ZWfB14Pshdl+32hVSqWUYzTZe9Pcf8PuRXDzCKjS2OlolFJ+TIdxvGXjd/DrOxA3CJr3cToapZSf0569p50+CgmfwcK3ILIl9HjV6YiUUsq/kv2JM5l8uXgXicfOMKRLbWIqlfLcwY/ugCUfwcqxkHnaLirS630ICvXcayilVAH5RbI/fDKdUYt28uXi3ZxMzyI0KICpK/bxQJdaPNS1DiVCAgt+8D1LYfF7sHGGXWSk6e3QbihUbeK5E1BKqUvk08k+6fgZRi7YwcTle0jPyqFn02o81LU2lUqH8soPG3lv7jamrtjHv25oxDWNqiDuTovMzoJN39kbpRKXQ1g56PgEtB0MZap59ZyUUqogxBhz8Q1EooExQFUgBxhpjHlHRCoAk4AYYBfQ2xhzzLXPMOBeIBt41Bgz62KvERcXZ+Lj4y/tTHLZdfgUH83fztSViRgDN7WszoNda1M7ovSftluy4wgvTFvP5uRUutaP4MUbGl98aCc91Q7TLPkIju+2c+cvHwot74IQDw4JKaWUG0QkwRgT59a2biT7akA1Y8wKEQkHEoCbgAHAUWPMqyLyLFDeGPOMiDQCJgBtgUhgDlDvYouOeyrZbzqQwgfztvP9miSCAgPo0yaawZ1rEVX+wguDZGbnMGbxbt6avYWMrBwGd67F0CvOGdpJ2Q9LP4L4zyH9BERfBu0ehgbX2XVglVLKAflJ9u4sOL4f2O96nCoiG4HqQC+gq2uzL4D5wDOu9onGmHRgp4hswyb+xfk7Dfet3HOMD+ZtY87Gg5QKCeT+zrW4t2MslcPD8tw3ODCAezvGckOzavz3x028P28b36zcxz+vb0T3+uWQJR/AgjcgK82WO2j3CES38dapKKWUV+RrzF5EYoCWwFKgiuuDAGPMfhGp7NqsOrAk126JrjaP27FnL6fG9eO91CtJCGnL41fVZUD7GMqVDMn3sSqXCeOtO1rQt20N/jVtHePHj6ZFybFUzdpnk/zV/4YKtbxwFkop5X1uJ3sRKQ1MAR43xqRc5GLm+Z74y1iRiAwGBgPUqFHD3TD+JPz0XkqkJzI65A2yKzcmsOqTEHZpS/y1LX+SH6qMIOD4DHZlVmNQ9jAalruJoaVroKvEKqWKK7fuoBWRYGyiH2eMmepqTnaN558d1z/oak8EonPtHgUknXtMY8xIY0ycMSYuIiKiQMFHNGhP5ec3wE0fEZidYevQfNDWXkTNzszfwbLSYcHr8H5bAnbMhSv/RcnHl1KuWQ8+mLedDq/OZfhPmzmUml6gWJVSyknuXKAV7Jj8UWPM47naXweO5LpAW8EY87SINAbG88cF2p+Bul6/QJuTbUsULHwDDqyFstF2jddW/SC4xMX33Tobfnza3hjV8Ebo/gqU++PzasWeY3w0fztzNiYTHBDATS0jua9TLepVCb+0mJVS6hJ4ejZOR2AhsBY79RLgOey4/WSgBrAHuN0Yc9S1z/PAICALO+zz48Vew6NTL42BbXPsRdW9S6BUZXuTU9wguxxgbsd2w8xhsPl7qFgHrn0N6lx5wUPvOHSS0b/u5OuERNIyc+hSL4L7O9WiQ52K7s/RV0opD/Fosi8Mnp5nD9ikv/tXWPgmbJ9rywtfNsT+BJeE3961z0kAdH7KfiC4Wdrg6KkMxi3ZzReLd3P4ZDoNq5Xhvo6x3NA8kpAgrS2nlCocmuzPtS8BFg6HTTMguBSUrAgn9kCjXnbIpmxUgQ6blpnN9FVJfLpoB1uST1KlTCj928dwV9ualC0Z7OGTUEqpP9NkfyEHN8Kit+zwTddnoHY3jxzWGMMvWw7x6cKdLNp2mJIhgfSOi+bJa+oRHqZJXynlHZrsHbQhKYVPF+1g2qokrqgfwch+cQQE6Hi+Usrz8pPsdYDZwxpFlmF47xY837MhczYe5OMF250OSSmlNNl7y8AOMVzXrBpvzNrMb9sPOx2OUsrPabL3EhHhf7c2I7ZSKR6dsJIDJ9KcDkkp5cc02XtR6dAgPr67Naczsnl4/Aoys3Py3kkppbxAk72X1a0Szqu3NiN+9zFe/XGT0+EopfyUJvtCcGPzSAa0j2HUop18v2a/0+EopfyQJvtC8lzPhrSsUY6nv17NtoMnnQ5HKeVnNNkXkpCgAD68qxWhwYE8ODaBU+lZToeklPIjmuwLUbWyJXi3T0u2HTrJsKlrKQo3tCml/IMm+0LWsW4lnry6HtNXJ/Hlkt1Oh6OU8hOa7B3wUNc6dGtQmZdmbGDlnmNOh6OU8gOa7B0QECAM792cKmXCeGjcCo6c1NWvlFLepcneIeVKhvDRXa05ciqDxyetIjtHx++VUt6jyd5BTaPK8n83Nmbh1sO8M2eL0+EopXyYJnuH9WkTzW2to3h37jZ+3phMZnYOOdrLV0p5WFBeG4jIaOB64KAxpomrrTnwMVAa2AXcZYxJcT03DLgXyAYeNcbM8k7ovkFEeKlXE9YnpXDvF/G52iFQhIAAIShA/vQ4wPV7YIBwdaMq/PP6RgRqzXyl1EXkmeyBz4H3gTG52j4F/m6M+UVEBgFPAf8UkUZAH6AxEAnMEZF6xphsz4btW0qEBPLFwDZ8s3IfGVk5ZBtDdo7rxxhycgxZOfbP3M8dO53J57/t4sipDIb3bk5woH5RU0qdX57J3hizQERizmmuDyxwPZ4NzAL+CfQCJhpj0oGdIrINaAss9ljEPqpymTAe6FI73/t9/Mt2Xv1xExlZ2bzXt5UueK6UOq+CZoZ1wI2ux7cD0a7H1YG9ubZLdLUpLxnSpTYv3NCIWeuTGTI2gbRM/RKllPqrgib7QcBQEUkAwoEMV/v5Bo7Pe7VRRAaLSLyIxB86dKiAYSiAgR1ieeXmpszbfJD7x8RzJkMTvlLqzwqU7I0xm4wx1xhjWgMTgLMLrSbyRy8fIApIusAxRhpj4owxcREREQUJQ+Vy52U1eP225vy67TD9P1vGSS20ppTKpUDJXkQqu/4MAP6BnZkDMB3oIyKhIhIL1AWWeSJQlbfbWkfxdp+WJOw+xj2jlpKSlul0SEqpIiLPZC8iE7AXWOuLSKKI3Av0FZEtwCZsz/0zAGPMemAysAGYCQzVmTiF68bmkXxwZyvW7jvBXZ8s5fjpjLx3Ukr5PCkKZXbj4uJMfHx83hsqt83dlMyQsSuoVakUY++7jEqlQ50OSSnlYSKSYIyJc2dbnafno7o1qMKo/nHsOnKKPiOXcDAlzemQlFIO0mTvwzrVjeDzgW3Zf/wMvUcsJun4GadDUko5RJO9j7u8VkXG3HsZR05m0HvEYvYePe10SEopB2iy9wOta5Zn3P2XkZqWRe8Ri9lzRBO+Uv5Gk72faBZVjomDL+d0Rjb3j4nXBc+V8jOa7P1Iw2pleK9vS7YeTOXpKWt0wXOl/Igmez/TuV4ET3VvwPdr9vPJwh1Oh6OKqOwcw/zNB/l122GnQ1Ee4k6JY+VjhnSpxdp9x3n1x000qlaWjnUrOR2SKiISj53mq/hEvorfS9KJNEKDAoj/x1WEhwU7HZq6RNqz90Miwuu3NadO5dI8MmGFztDxcxlZOfywdj/3jF5Gp9fm8e7crdSpEs5T3euT7npOFX/as/dTpUKDGNEvjhvfX8SQsQlMebA9YcGBToelCtG2gyeZHL+XKQmJHDmVQWTZMB7tVpfb46KIKl8SYwxTViTydUIid7Sp4XS46hJpsvdjsZVK8U6fFtz7RTzPTV3Lm72bI6LLG/qyMxnZfL92P5OW72H5rmMEBQhXNazCHW2j6Vw34k/LW4oIt7aK4vVZm9l95BQ1K5ZyMHJ1qTTZ+7luDarw+JX1eGvOFppFlWVAh1inQ1JesOfIaUYu3M60lUmkpmdRq1Iphl3bgFtaRRERfuG6Sbe0qs4bP21myop9/O3qeoUYsfI0TfaKR7rVYe2+E7z0/UYaVivDZbUqFvhYWdk5TF9tlzC4sXkkQbourqMOnEjjvblbmbR8L4EBwnVNq9GnbQ3axJR361tctbIl6FinElNXJPL4lXUJ0IXtiy2teqkASEnL5Kb3fyUlLZPvHulItbIl8rW/MYbZG5L538xNbD90CoA6lUvzbI8GXNmwsg4PFbKjpzL4aP42xizeTY4x9G1bg4evqEPlMmH5Pta3K/fx+KRVTLj/ctrVLnhHQHmeVr1U+VYmLJiR97TmTEY2Q8auID3L/WUIVuw5Ru8Rixn8ZQIGGNGvNR/f3ZqcHMN9Y+LpM3IJq/Ye91rs6g8paZkMn72FTv+by6hFO7mheSRzn+zKv3s1KVCiB+jeuCqlQ4OYsiLRw9GqwqQ9e/UnM9cdYMjYBPq0iebVW5tddNudh0/x+qxN/LD2AJVKh/K3q+vROy7q96GbzOwcJi7fyztztnD4ZAbXN6vGU93r64U+LziTkc0Xi3fx8S/bOX46k55Nq/K3q+tRp3K4R47/zNdrmLEmieX/uIqSITr6W1Tkp2ev75r6kx5NqvLwFXV4f942mkWV487L/jrl7vDJdN77eSvjlu4hJCiAJ66qx32dYikV+ud/TsGBAfS7vCY3t6zOyF+288nCncxaf4C7L6/Jo93qUr5USGGdls/KyMph0vI9vDt3G4dS0+laP4K/X1OfJtXLevR1bm0dxaT4vcxcd4BbWkV59NiqcGjPXv1Fdo5h0OfL+W37YSYObkfrmuUB23sctWgHH/+ygzOZ2fRtG82jV9alcrh7wwPJKWm8PWcLk5bvpVRoEA91rcPADjE6v78AsnMM36zcx9tztpB47AxtYsrzVPcGtI2t4JXXM8bQ5fX5RJUvwfj7L/fKa6j8y0/PPs9kLyKjgeuBg8aYJq62FthFxsOALOAhY8wy13PDgHuBbOBRY8ysvILQZF/0nDidyQ3vLyItM5tpD3dgwZZDDJ+9heSUdLo3rsLTPRpQO6J0gY69JTmV//24iZ83HSSybBhPXlOfm1pW/9Mcb3Vh6/ad4MnJq9mcnEqT6mX4+zX16VIvwusXwd+es4V3ft7Kome6Ub1c/i7gK+/wdLLvDJwExuRK9j8BbxljfhSRnsDTxpiuItIImAC0BSKBOUC9vBYd12RfNG06kMLNH/xGtjFkZOXQqkY5nuvZkLgYz/QeF28/wn9/3MiaxBM0rFaGB7vWpkfjqoQE6byB88nKzmHEgh28NXsLFUuH8MINjbm2SdVCm+m09+hpOr02j79fU4+Hu9UtlNdUF+fRMXtjzAIRiTm3GSjjelwWSHI97gVMNMakAztFZBs28S92JxhVtDSoWoa37mjBJwt3cH+nWLo39mxiaVe7It8+1IEZa/fz5k+beXTCSiqVDuGONtH0bVuDqPIlPfZaxd3uI6f42+TVJOw+xnXNqvHyTU0oV7Jwr3lEVyjJZbEVmLJiH0OvqKPTaYuZgl6gfRyYJSJvYKdvtne1VweW5Nou0dWmiqkeTarSo0lVrx0/IEC4sXkk1zetxoKthxi7ZDcfzd/OR/O3061BZe66vCZd6kb47c08xhgmLd/Lv2dsIDBAeKdPC25sHulYor21dRRPf72GFXuO0bqmd64PKO8oaLJ/EHjCGDNFRHoDo4CrgPP9CzzvOJGIDAYGA9SooUWW/F1AgNC1fmW61q/MvuNnmLB0DxOX72XOxuVEVyjBnW1r0jsuioqlL3xrv685fDKdZ6esZc7GZNrXrsgbtzcn0uGx8p5Nq/HCtPV8nbBPk30x49ZsHNcwzoxcY/YngHLGGCO2i3HCGFPGdXEWY8x/XdvNAl40xlx0GEfH7NX5ZGTlMGv9AcYu2c3SnUcJCQygZ9Oq3H15TVrXdO92/+Jq9oZknp2yhtT0LJ7p0YCB7WOKzLebv01axeyNySx//iqdSeWwwphnnwR0AeYD3YCtrvbpwHgRGY69QFsXWFbA11B+LiQogBuaR3JD80i2JKcybslupq7Yx7erkmhQNZw7L6tBj8ZVC3xnaFF0Mj2L/8zYwMTle2lUrQwT+rSgXhXP3BjlKbe2jmLqyn3M3pDMDc0jnQ5Hucmd2TgTgK5AJSAZeAHYDLyD/bBIw069THBt/zwwCDsl83FjzI95BaE9e+WuU+lZTF+dxNglu1mflAJAi+hyXN2oCtc0qkKdyqWLbY8/YfdRnpi0mr3HTjOkS22euKpekZyZlJNj6Pi/udStEs4Xg9o6HY5f8+jUy8KgyV7llzGGLcknmb3hALM3JLM68QQAMRVLcnWjKlzVsApxMRWKxdz9jKwc3vl5Cx/N305kuRK8dUcL2nhoequ3vDFrMx/O38biYVdSxYe+WRU3muyV3zlwIo05G5OZvSGZxduPkJGdQ/mSwXRrUIWrG1Whc71KRbKmy4kzmdz/RTzLdh2ld1wU/7y+UbFY73XHoZN0e/MXhl3bgAe61HY6HL+lyV75tdS0TBZsOczsDQeYu+kgKWlZhAYF0LFOJfq0rcHVjao4HSIAh1LT6T96GVsPpvLG7c3p1aJ4zVK+5cNfSU3L4qcnOhfbobPiTguhKb8WHhbMdc2qcV2zamRm57B851F+2mB7/fePieeedjV5/rqGhAY5N5Mk8dhp7v50Kckp6Xzavw1d6kU4FktB3dY6mue+WcvafSdoFlXO6XBUHore1R+lPCg4MID2dSrx4o2Nmf9UV+7vFMuYxbvp/fFi9h497UhMW5NTue2jxRw9lcHY+y4rloke4Lpm1QgJCmBKgta5Lw402Su/ERwYwPPXNeLju1ux49Aprn9vEXM3JRdqDKv3Hqf3iMVkG8OkB/6oKFoclS0RzDWNqjBtdVK+FrtRztBkr/xOjybV+O6RjlQvV4JBn8fz2sxNZGXneP11f9t2mDs/WULpsCC+HtKOhtXK5L1TEXdr6yiOn85k3qaDToei8qDJXvmlmEqlmPpQe/q2jebD+du5e9RSDqamee31Zq0/wIDPlhNVviRfD2nvM6t1dapTicrhoXydsM/pUFQeNNkrvxUWHMh/b2nGm7c3Z9Xe41z37iKW7Dji8deZHL+XB8cm0Lh6GSY9cLlPzUsPCgzg5pbVmb/5IEdOpjsdjuNycpyf3XghOhtH+b1bW0fRuHoZHhq7gjs/WcLfu9dnSOfaHqlF8+nCHfzn+410qluJEf1aF8m5/pfq1tZRjFiwg2mrkhjUMdbpcBxhjOHfMzbwxW+7KF8yhCplwqhaNowqZUKpUibM/u76s0qZUCqUCin06aq+9y9PqQJoULUM0x/pyLNT1vDazM0k7DrGm72bF7hmvDGGN3/awvvzttGzaVXeuqOFo1M9valelXCaRZXl64REv032H87fzme/7uK6ptUoUyKYgylpHEhJY03icQ6fzPjL9iGBAVR2fRB0a1CZoVfU8XqMmuyVcikdGsR7fVvSNrYCL83YwHXvLuLDu1rRPLpcvo6TnWP417R1jFu6hz5tonn55qbFomzDpbi1VRQvTF/Pxv0pPnHhOT++XbmP12dtpleLSN7q3eIv3wgzsnI4dDKdAyfSfv8QOJCSRvKJNJJT0knLLJyZTHoHrVLnsWrvcYaOW8Gh1HQaRZahRHAgJUJcP8GBlHT9GXb2ccgfj39cd4Dv1+xnSJfaPNOjvl/cXXrsVAZtX5lD/3Yx/OP6Rk6HU2h+236Y/qOX0bpmeb4Y1LbQv73pHbRKXaIW0eWY8UhHXv9pM3uPniYtM5vklEzOZGaTlpHN6cxszmRkk551/imbz/RowINd/admTPlSIXRrUJlvVyXxzLUNCA70/bkfmw+k8sCXCcRULMWIfnFFfphOk71SF1C+VAiv3Nz0otvk5BjOZGbbnwz7Z1hQIDUq+t/6ube1jmbW+mQWbDnElQ2LRv0hb0lOSWPgZ8soERzI54PaUrZE0S9ep8leqUsQECCUCg2iVKj+V+paP4JKpUP5/LddPp3sT6ZnMeCz5Zw4k8nkIe2o7vBSke7y/e9aSqlCERwYwP2dYlm49TAr9hxzOhyvyMzO4cGxCWxJTuXDu1vTOLKs0yG5TZO9Uspj+rWrSYVSIbwzZ2veGxczxhiem7qWhVsP89+bmxa7Anaa7JVSHlMyJIj7O9Xily2HWLX3uNPheNQ7P2/lq4REHr2yLr3bRDsdTr7lmexFZLSIHBSRdbnaJonIKtfPLhFZleu5YSKyTUQ2i0h3L8WtlCqi7mlXk/Ilg3lnzhanQ/GYr+L38vacrdzWOoonrqrrdDgF4k7P/nOgR+4GY8wdxpgWxpgWwBRgKoCINAL6AI1d+3woIkV7PpJSyqNKhQZxX6dazNt8iNU+0LtfsOUQw6aupVPdSvz3lqbF9r6JPJO9MWYBcPR8z4k9697ABFdTL2CiMSbdGLMT2Abo8vNK+Zn+7WMoVzKYd3/2/Nj9rsOnmJKQSGpapsePfa4NSSk8NG4FdSqX5sO7WhXr+wcudb5YJyDZGHP2Ha0OLMn1fKKrTSnlR0qHBnFfx1je+GkLaxNP0DTKM7NWzmRkM+jz5ew4fIoS3wbSs2k1+rSNJq5meY/3uJOOn2Hg58sIDwvi84Fti8VC8BdzqR9TffmjVw9wvr/t89ZjEJHBIhIvIvGHDh26xDCUUkVN//YxlC0RzDse7N2/PmszOw6f4qVejbmpZSQz1+3n9o8Xc+XwXxjxy3YOpV5amWVjDHuPnmZKQiL9Ry/jdHo2nw1sQ9Wyxb8sdYF79iISBNwCtM7VnAjkvkwdBSSdb39jzEhgJNjaOAWNQylVNIWHBXNvx1iGz97Cun0naFL90nr3i7cfYfSvO7mnXU36tYsB4B/XNeL7tfuZvHwv//1xE6/P2syVDStzR5toOteNICiPYRdjDNsOnmTpzqMs33WUZTuPsv+EXcSmQqkQRvRrTYOqvlHYza1CaCISA8wwxjTJ1dYDGGaM6ZKrrTEwHjtOHwn8DNQ1xly0rJsWQlPKN6WkZdLx1blcXqsiI+9xq17XeZ1Mz6L7WwsIDhR+eKzTedcF2HYwlcnxiUxJSOTIqQyqlgnjttZR9I6L/r18RVZ2Dhv3p7J05xGW7TxK/O5jHD1lSxBXDg+lbWwFLoutQJvYCtSrHO6RNQ28yaOF0ERkAtAVqCQiicALxphR2Fk3uYdwMMasF5HJwAYgCxiaV6JXSvmuMmHBDOoYy9tztrIhKYVGkQXrJb/8/Qb2nzjDV0PaXXABmDqVw3muZ0P+fk195m5KZuLyvXw4fxvvz9tG+9oVCQoMIGHXUU5l2JRUs2JJujWo/HuCr1GhZLGdaeMOLXGslPKqE2cy6fi/uXSoXYmP+7XOe4dzzNt8kIGfLeeBLrUYdm3DfO27/8QZvo5P5JuV+wgKFC6LrUib2Aq0jangE+PwWuJYKVVklC0RzMAOsbz789Z8L25y/HQGz3y9hnpVSvPEVfXy/drVypbgkSvr8siVxfNGKE8qvpNGlVLFxr0dYgkPDeK9ufmbmfPC9PUcPZXB8N4tCAvW+zMvhSZ7pZTXlS0ZzIAOMfyw9gCbD6S6tc8Pa/czbVUSj3Sre8kzeZQme6VUIbm3YyylQ4N4143e/aHUdP7x7TqaVi/LQ1f4z4pf3qTJXilVKMqVDKF/+5r8sHY/W5Mv3Ls3xvDcN2s5mZ7Fm72bF+sSBUWJ/i0qpQrNfR1rUTI4kHfnbrvgNlNX7GP2hmT+fk096lUJL8TofJsme6VUoSlfKoR72scwY00S2w7+tXefdPwML363njYx5bm3Yy0HIvRdmuyVUoXq/k61KBEcyHvn9O6NMTwzZQ1Z2YY3bm9OYBG/e7W40WSvlCpUFUqF0K9dTb5bncT2Qyd/bx+3dA8Ltx7muesaUrNiKQcj9E2a7JVShW5wp1qEBgXyvqt3v/vIKV75YSOd6lbi7stqOBydb9Jkr5QqdBVLh9KvXU2mrdrHtoMn+ftXqwkMEP53azOfrk/jJE32SilH3N+pFiFBAdz96VKW7zrGizc0JrJcCafD8lma7JVSjogID+Xuy2pyICWNqxtV4ZZWuqidN2khNKWUYx7uVoeQoAAGdYzV4Rsv02SvlHJMuZIhPN2jgdNh+AUdxlFKKT+gyV4ppfyAJnullPIDeSZ7ERktIgdFZN057Y+IyGYRWS8ir+VqHyYi21zPdfdG0EoppfLHnQu0nwPvA2PONojIFUAvoJkxJl1EKrvaG2EXIm8MRAJzRKSeLjqulFLOyrNnb4xZABw9p/lB4FVjTLprm4Ou9l7ARGNMujFmJ7ANaOvBeJVSShVAQcfs6wGdRGSpiPwiIm1c7dWBvbm2S3S1KaWUclBB59kHAeWBy4E2wGQRqQWc764Ic74DiMhgYDBAjRpa+EgppbypoMk+EZhqjDHAMhHJASq52qNzbRcFJJ3vAMaYkcBIABE5JCK7CxgLrtc+fAn7F2d67v7Ln8/fn88d/jj/mu7uUNBk/y3QDZgvIvWAENcLTwfGi8hw7AXausCyvA5mjIkoYBwAiEi8MSbuUo5RXOm5++e5g3+fvz+fOxTs/PNM9iIyAegKVBKRROAFYDQw2jUdMwPo7+rlrxeRycAGIAsYqjNxlFLKeXkme2NM3ws8dfcFtn8ZePlSglJKKeVZvnIH7UinA3CQnrv/8ufz9+dzhwKcv9jRF6WUUr7MV3r2SimlLqJYJ3sR6eGqwbNNRJ51Op7CJiK7RGStiKwSkXin4/Gm89VoEpEKIjJbRLa6/izvZIzedIHzf1FE9rne/1Ui0tPJGL1FRKJFZJ6IbHTV4nrM1e7z7/9Fzj3f732xHcYRkUBgC3A1dn7/cqCvMWaDo4EVIhHZBcQZY3x+vrGIdAZOAmOMMU1cba8BR40xr7o+7MsbY55xMk5vucD5vwicNMa84WRs3iYi1YBqxpgVIhIOJAA3AQPw8ff/Iufem3y+98W5Z98W2GaM2WGMyQAmYmvzKB90gRpNvYAvXI+/wP4n8EkXOH+/YIzZb4xZ4XqcCmzElmHx+ff/Iueeb8U52WsdHluK4icRSXCVn/A3VYwx+8H+pwAqOxyPEx4WkTWuYR6fG8Y4l4jEAC2BpfjZ+3/OuUM+3/vinOzdrsPjwzoYY1oB1wJDXV/1lf/4CKgNtAD2A286Go2XiUhpYArwuDEmxel4CtN5zj3f731xTvZu1+HxVcaYJNefB4Fv8L9y0smuMc2zY5sH89jepxhjko0x2caYHOATfPj9F5FgbLIbZ4yZ6mr2i/f/fOdekPe+OCf75UBdEYkVkRDsoinTHY6p0IhIKdcFG0SkFHANsO7ie/mc6UB/1+P+wDQHYyl0ZxOdy8346PsvIgKMAjYaY4bnesrn3/8LnXtB3vtiOxsHwDXd6G0gEBjtKtXgF1wlpb9x/RoEjPfl889dowlIxtZo+haYDNQA9gC3G2N88iLmBc6/K/ZrvAF2AQ+cHcP2JSLSEVgIrAVyXM3PYceuffr9v8i59yWf732xTvZKKaXcU5yHcZRSSrlJk71SSvkBTfZKKeUHNNkrpZQf0GSvlFJ+QJO9Ukr5AU32SinlBzTZK6WUH/h/zHECYv9cK44AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], +>>>>>>> Stashed changes + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": {}, + "outputs": [], +======= + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 83042.463918\n", + "1 76910.914717\n", + "dtype: float64" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], +>>>>>>> Stashed changes + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "profits" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], +======= + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
03668.2500002520.000000
14433.3906252466.000000
24231.1103522533.500000
34522.9956672584.125000
43664.5034222730.093750
54101.3747272731.570312
63976.5304862840.677734
72986.2052742982.508301
83587.7087782920.881226
93426.8118822982.660919
103308.3134553028.995689
113395.6626473063.746767
123008.1025933149.810075
132556.0500183154.357556
142814.7941023049.768167
153015.0836572971.326126
163168.8060382912.494594
174126.0695072868.370946
183355.0823253171.278209
191989.1099793398.458657
202984.1186603232.843993
212706.5922803276.632995
222328.9838323249.474746
233078.2814683121.106059
242608.5321435970.232895
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 3668.250000 2520.000000\n", + "1 4433.390625 2466.000000\n", + "2 4231.110352 2533.500000\n", + "3 4522.995667 2584.125000\n", + "4 3664.503422 2730.093750\n", + "5 4101.374727 2731.570312\n", + "6 3976.530486 2840.677734\n", + "7 2986.205274 2982.508301\n", + "8 3587.708778 2920.881226\n", + "9 3426.811882 2982.660919\n", + "10 3308.313455 3028.995689\n", + "11 3395.662647 3063.746767\n", + "12 3008.102593 3149.810075\n", + "13 2556.050018 3154.357556\n", + "14 2814.794102 3049.768167\n", + "15 3015.083657 2971.326126\n", + "16 3168.806038 2912.494594\n", + "17 4126.069507 2868.370946\n", + "18 3355.082325 3171.278209\n", + "19 1989.109979 3398.458657\n", + "20 2984.118660 3232.843993\n", + "21 2706.592280 3276.632995\n", + "22 2328.983832 3249.474746\n", + "23 3078.281468 3121.106059\n", + "24 2608.532143 5970.232895" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], +>>>>>>> Stashed changes + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": {}, + "outputs": [], +======= + "execution_count": 57, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], +>>>>>>> Stashed changes + "source": [ + "prices.plot()" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], +======= + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], +>>>>>>> Stashed changes + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", +<<<<<<< Updated upstream +======= + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", +>>>>>>> Stashed changes + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/LearningAgent_Simulations1.ipynb b/learningAgents/naive_policy_gradient/LearningAgent_Simulations1.ipynb new file mode 100644 index 0000000..7ab94f7 --- /dev/null +++ b/learningAgents/naive_policy_gradient/LearningAgent_Simulations1.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 2, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(lr = 0.00001, num_input=3+ 0, num_actions=20, nn_dim=100)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1000000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([0.0500, 0.0514, 0.0527, 0.0427, 0.0495, 0.0502, 0.0495, 0.0562, 0.0559,\n", + " 0.0524, 0.0539, 0.0482, 0.0453, 0.0483, 0.0479, 0.0452, 0.0471, 0.0577,\n", + " 0.0526, 0.0433], grad_fn=)\n", + "0\n", + "tensor([7, 2])\n", + "tensor(10122.1504)\n", + "tensor([0.0492, 0.0504, 0.0517, 0.0417, 0.0485, 0.0496, 0.0483, 0.0556, 0.0562,\n", + " 0.0520, 0.0544, 0.0479, 0.0455, 0.0493, 0.0482, 0.0463, 0.0483, 0.0594,\n", + " 0.0529, 0.0447], grad_fn=)\n", + "10000\n", + "tensor([9, 8])\n", + "tensor(10103.8750)\n", + "tensor([0.0482, 0.0491, 0.0500, 0.0407, 0.0476, 0.0490, 0.0473, 0.0556, 0.0562,\n", + " 0.0514, 0.0549, 0.0479, 0.0456, 0.0499, 0.0483, 0.0472, 0.0497, 0.0612,\n", + " 0.0541, 0.0462], grad_fn=)\n", + "20000\n", + "tensor([19, 14])\n", + "tensor(10050.4492)\n", + "tensor([0.0470, 0.0474, 0.0486, 0.0397, 0.0462, 0.0484, 0.0459, 0.0551, 0.0559,\n", + " 0.0507, 0.0560, 0.0472, 0.0453, 0.0515, 0.0482, 0.0482, 0.0511, 0.0645,\n", + " 0.0549, 0.0482], grad_fn=)\n", + "30000\n", + "tensor([15, 6])\n", + "tensor(10190.9492)\n", + "tensor([0.0452, 0.0457, 0.0466, 0.0383, 0.0450, 0.0481, 0.0447, 0.0547, 0.0553,\n", + " 0.0504, 0.0565, 0.0465, 0.0454, 0.0527, 0.0485, 0.0495, 0.0527, 0.0679,\n", + " 0.0567, 0.0497], grad_fn=)\n", + "40000\n", + "tensor([ 7, 10])\n", + "tensor(10035.7500)\n", + "tensor([0.0432, 0.0433, 0.0442, 0.0367, 0.0432, 0.0477, 0.0426, 0.0537, 0.0544,\n", + " 0.0494, 0.0569, 0.0460, 0.0451, 0.0554, 0.0492, 0.0506, 0.0548, 0.0730,\n", + " 0.0583, 0.0523], grad_fn=)\n", + "50000\n", + "tensor([7, 3])\n", + "tensor(10117.6504)\n", + "tensor([0.0408, 0.0408, 0.0416, 0.0344, 0.0416, 0.0465, 0.0407, 0.0534, 0.0543,\n", + " 0.0490, 0.0584, 0.0452, 0.0451, 0.0565, 0.0496, 0.0521, 0.0567, 0.0786,\n", + " 0.0605, 0.0544], grad_fn=)\n", + "60000\n", + "tensor([8, 5])\n", + "tensor(10122.0566)\n", + "tensor([0.0388, 0.0383, 0.0385, 0.0325, 0.0397, 0.0455, 0.0390, 0.0524, 0.0541,\n", + " 0.0480, 0.0594, 0.0438, 0.0454, 0.0585, 0.0503, 0.0533, 0.0583, 0.0848,\n", + " 0.0629, 0.0566], grad_fn=)\n", + "70000\n", + "tensor([ 3, 15])\n", + "tensor(9829.1504)\n", + "tensor([0.0357, 0.0352, 0.0352, 0.0301, 0.0373, 0.0442, 0.0370, 0.0512, 0.0535,\n", + " 0.0461, 0.0613, 0.0426, 0.0457, 0.0604, 0.0509, 0.0554, 0.0608, 0.0922,\n", + " 0.0664, 0.0589], grad_fn=)\n", + "80000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([0.0323, 0.0319, 0.0316, 0.0267, 0.0351, 0.0429, 0.0346, 0.0493, 0.0519,\n", + " 0.0436, 0.0626, 0.0415, 0.0453, 0.0637, 0.0503, 0.0584, 0.0632, 0.1015,\n", + " 0.0710, 0.0626], grad_fn=)\n", + "90000\n", + "tensor([10, 15])\n", + "tensor(9974.0059)\n", + "tensor([0.0281, 0.0273, 0.0278, 0.0230, 0.0313, 0.0403, 0.0311, 0.0470, 0.0499,\n", + " 0.0413, 0.0647, 0.0396, 0.0445, 0.0677, 0.0499, 0.0598, 0.0650, 0.1174,\n", + " 0.0772, 0.0670], grad_fn=)\n", + "100000\n", + "tensor([6, 9])\n", + "tensor(10032.1562)\n", + "tensor([0.0247, 0.0232, 0.0240, 0.0190, 0.0272, 0.0375, 0.0280, 0.0455, 0.0475,\n", + " 0.0385, 0.0656, 0.0374, 0.0428, 0.0719, 0.0482, 0.0632, 0.0684, 0.1324,\n", + " 0.0835, 0.0716], grad_fn=)\n", + "110000\n", + "tensor([16, 6])\n", + "tensor(10194.6562)\n", + "tensor([0.0203, 0.0194, 0.0197, 0.0152, 0.0228, 0.0338, 0.0236, 0.0416, 0.0444,\n", + " 0.0349, 0.0663, 0.0343, 0.0406, 0.0757, 0.0473, 0.0639, 0.0704, 0.1589,\n", + " 0.0929, 0.0740], grad_fn=)\n", + "120000\n", + "tensor([ 9, 16])\n", + "tensor(9931.0742)\n", + "tensor([0.0164, 0.0156, 0.0151, 0.0114, 0.0178, 0.0286, 0.0201, 0.0380, 0.0398,\n", + " 0.0309, 0.0676, 0.0299, 0.0353, 0.0816, 0.0461, 0.0640, 0.0716, 0.1975,\n", + " 0.0975, 0.0753], grad_fn=)\n", + "130000\n", + "tensor([4, 3])\n", + "tensor(10049.9062)\n", + "tensor([0.0119, 0.0114, 0.0109, 0.0078, 0.0124, 0.0222, 0.0153, 0.0306, 0.0335,\n", + " 0.0247, 0.0656, 0.0244, 0.0279, 0.0837, 0.0408, 0.0584, 0.0719, 0.2690,\n", + " 0.1037, 0.0737], grad_fn=)\n", + "140000\n", + "tensor([5, 6])\n", + "tensor(10050.0742)\n", + "tensor([0.0077, 0.0072, 0.0071, 0.0047, 0.0079, 0.0151, 0.0105, 0.0224, 0.0236,\n", + " 0.0170, 0.0590, 0.0170, 0.0188, 0.0790, 0.0307, 0.0458, 0.0599, 0.4075,\n", + " 0.1006, 0.0585], grad_fn=)\n", + "150000\n", + "tensor([18, 4])\n", + "tensor(10214.4062)\n", + "tensor([0.0036, 0.0032, 0.0032, 0.0019, 0.0035, 0.0068, 0.0048, 0.0109, 0.0114,\n", + " 0.0079, 0.0322, 0.0080, 0.0077, 0.0428, 0.0139, 0.0194, 0.0273, 0.7137,\n", + " 0.0553, 0.0224], grad_fn=)\n", + "160000\n", + "tensor([18, 3])\n", + "tensor(10220.7061)\n", + "tensor([1.2016e-04, 6.7760e-05, 6.8724e-05, 4.5160e-05, 1.1260e-04, 2.4883e-04,\n", + " 1.8714e-04, 3.2035e-04, 3.4207e-04, 2.6472e-04, 1.3278e-03, 2.7892e-04,\n", + " 2.2229e-04, 1.2184e-03, 4.3372e-04, 6.1755e-04, 7.0849e-04, 9.9199e-01,\n", + " 1.0137e-03, 4.1281e-04], grad_fn=)\n", + "170000\n", + "tensor([17, 16])\n", + "tensor(9998.4746)\n", + "tensor([7.3161e-06, 3.3418e-06, 1.3458e-06, 1.0383e-06, 6.6012e-06, 6.7073e-06,\n", + " 5.0284e-06, 6.6204e-06, 1.6871e-05, 6.2059e-06, 7.4046e-05, 2.1812e-05,\n", + " 4.3526e-06, 7.0715e-05, 9.7558e-06, 1.7527e-05, 2.6516e-05, 9.9966e-01,\n", + " 2.3437e-05, 2.6277e-05], grad_fn=)\n", + "180000\n", + "tensor([17, 12])\n", + "tensor(10099.2754)\n", + "tensor([4.7556e-07, 6.0576e-07, 4.0647e-08, 3.2123e-08, 2.2701e-07, 1.9590e-07,\n", + " 1.5596e-07, 1.9676e-07, 5.3644e-07, 1.8544e-07, 9.2226e-06, 1.0444e-06,\n", + " 1.2441e-07, 8.0862e-06, 1.7555e-06, 5.1171e-07, 7.7528e-07, 9.9997e-01,\n", + " 6.6985e-07, 2.9487e-06], grad_fn=)\n", + "190000\n", + "tensor([17, 2])\n", + "tensor(10225.2754)\n", + "tensor([2.9117e-09, 2.3650e-08, 2.2078e-10, 1.6970e-10, 1.3029e-09, 1.0983e-09,\n", + " 8.9826e-10, 1.1300e-09, 3.2000e-09, 1.0768e-09, 9.4570e-08, 6.5741e-09,\n", + " 6.8909e-10, 6.0431e-08, 1.7064e-08, 3.1589e-09, 4.9236e-09, 1.0000e+00,\n", + " 4.2564e-09, 3.7829e-08], grad_fn=)\n", + "200000\n", + "tensor([17, 9])\n", + "tensor(10155.9746)\n", + "tensor([6.1548e-11, 1.0688e-09, 6.2743e-12, 4.4868e-12, 2.7062e-11, 2.4469e-11,\n", + " 2.2262e-11, 2.6839e-11, 6.6913e-11, 2.5880e-11, 2.3903e-09, 1.4644e-10,\n", + " 1.4595e-11, 1.4930e-09, 3.7293e-10, 6.9689e-11, 1.0849e-10, 1.0000e+00,\n", + " 9.3410e-11, 8.3466e-10], grad_fn=)\n", + "210000\n", + "tensor([17, 9])\n", + "tensor(10155.9746)\n", + "tensor([6.7546e-09, 9.2815e-08, 9.1232e-10, 6.2354e-10, 3.0091e-09, 3.0452e-09,\n", + " 3.1485e-09, 3.3975e-09, 6.8159e-09, 3.2364e-09, 1.7190e-07, 1.3218e-08,\n", + " 1.7014e-09, 1.0798e-07, 3.0316e-08, 7.1669e-09, 1.0132e-08, 1.0000e+00,\n", + " 9.0278e-09, 6.3925e-08], grad_fn=)\n", + "220000\n", + "tensor([17, 7])\n", + "tensor(10184.7754)\n", + "tensor([7.3256e-06, 1.2225e-04, 1.4502e-06, 9.5328e-07, 3.3984e-06, 3.8450e-06,\n", + " 4.7382e-06, 4.4111e-06, 6.9364e-06, 4.1655e-06, 1.1452e-04, 1.2922e-05,\n", + " 2.0365e-06, 7.8048e-05, 2.7832e-05, 7.2898e-06, 9.3446e-06, 9.9951e-01,\n", + " 8.5967e-06, 7.3956e-05], grad_fn=)\n", + "230000\n", + "tensor([17, 4])\n", + "tensor(10214.4746)\n", + "tensor([2.6513e-04, 2.0650e-02, 1.4945e-04, 8.3990e-05, 1.1432e-04, 1.2808e-04,\n", + " 2.2067e-04, 1.7547e-04, 2.7021e-04, 1.7455e-04, 4.7025e-03, 4.9836e-04,\n", + " 7.1128e-05, 3.3689e-03, 1.5979e-03, 1.8930e-04, 2.9590e-04, 9.6130e-01,\n", + " 2.4464e-04, 5.5027e-03], grad_fn=)\n", + "240000\n", + "tensor([17, 19])\n", + "tensor(9903.9746)\n", + "tensor([4.0532e-02, 6.7163e-03, 4.0547e-02, 3.1279e-02, 3.7314e-02, 3.4552e-02,\n", + " 4.3813e-02, 4.4816e-02, 4.8258e-02, 4.7160e-02, 9.5659e-02, 5.6296e-02,\n", + " 3.1391e-02, 9.3827e-02, 8.4806e-02, 4.5533e-02, 5.7012e-02, 1.0774e-05,\n", + " 6.0768e-02, 9.9709e-02], grad_fn=)\n", + "250000\n", + "tensor([10, 9])\n", + "tensor(10103.6055)\n", + "tensor([0.0561, 0.0280, 0.0494, 0.0477, 0.0497, 0.0471, 0.0617, 0.0516, 0.0629,\n", + " 0.0479, 0.0707, 0.0610, 0.0360, 0.0694, 0.0608, 0.0410, 0.0465, 0.0001,\n", + " 0.0491, 0.0632], grad_fn=)\n", + "260000\n", + "tensor([18, 18])\n", + "tensor(9937.2061)\n", + "tensor([0.0655, 0.0374, 0.0533, 0.0543, 0.0580, 0.0543, 0.0689, 0.0535, 0.0665,\n", + " 0.0487, 0.0610, 0.0577, 0.0361, 0.0600, 0.0511, 0.0383, 0.0416, 0.0007,\n", + " 0.0436, 0.0494], grad_fn=)\n", + "270000\n", + "tensor([ 2, 11])\n", + "tensor(9894.5059)\n", + "tensor([0.0693, 0.0431, 0.0549, 0.0570, 0.0577, 0.0559, 0.0717, 0.0519, 0.0694,\n", + " 0.0475, 0.0597, 0.0552, 0.0385, 0.0570, 0.0471, 0.0369, 0.0390, 0.0015,\n", + " 0.0409, 0.0457], grad_fn=)\n", + "280000\n", + "tensor([ 0, 16])\n", + "tensor(9710.8555)\n", + "tensor([0.0699, 0.0471, 0.0543, 0.0572, 0.0574, 0.0551, 0.0739, 0.0547, 0.0693,\n", + " 0.0469, 0.0556, 0.0592, 0.0382, 0.0549, 0.0450, 0.0361, 0.0388, 0.0022,\n", + " 0.0397, 0.0443], grad_fn=)\n", + "290000\n", + "tensor([4, 6])\n", + "tensor(10025.6055)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([0.0714, 0.0489, 0.0523, 0.0585, 0.0560, 0.0522, 0.0749, 0.0529, 0.0693,\n", + " 0.0463, 0.0573, 0.0568, 0.0393, 0.0545, 0.0452, 0.0371, 0.0386, 0.0027,\n", + " 0.0396, 0.0461], grad_fn=)\n", + "300000\n", + "tensor([ 4, 11])\n", + "tensor(9949.1055)\n", + "tensor([0.0726, 0.0525, 0.0526, 0.0593, 0.0576, 0.0534, 0.0761, 0.0519, 0.0701,\n", + " 0.0473, 0.0562, 0.0529, 0.0376, 0.0522, 0.0460, 0.0377, 0.0377, 0.0030,\n", + " 0.0390, 0.0445], grad_fn=)\n", + "310000\n", + "tensor([5, 5])\n", + "tensor(10059.9746)\n", + "tensor([0.0713, 0.0544, 0.0532, 0.0578, 0.0585, 0.0522, 0.0798, 0.0529, 0.0712,\n", + " 0.0478, 0.0547, 0.0537, 0.0362, 0.0516, 0.0434, 0.0353, 0.0361, 0.0034,\n", + " 0.0406, 0.0459], grad_fn=)\n", + "320000\n", + "tensor([1, 7])\n", + "tensor(9929.1748)\n", + "tensor([0.0706, 0.0582, 0.0536, 0.0591, 0.0594, 0.0517, 0.0761, 0.0510, 0.0729,\n", + " 0.0474, 0.0561, 0.0532, 0.0350, 0.0508, 0.0431, 0.0358, 0.0357, 0.0042,\n", + " 0.0405, 0.0457], grad_fn=)\n", + "330000\n", + "tensor([0, 2])\n", + "tensor(9937.6562)\n", + "tensor([0.0707, 0.0607, 0.0539, 0.0576, 0.0577, 0.0509, 0.0742, 0.0503, 0.0719,\n", + " 0.0479, 0.0567, 0.0522, 0.0352, 0.0524, 0.0435, 0.0353, 0.0360, 0.0049,\n", + " 0.0391, 0.0488], grad_fn=)\n", + "340000\n", + "tensor([5, 7])\n", + "tensor(10038.3750)\n", + "tensor([0.0666, 0.0687, 0.0495, 0.0538, 0.0532, 0.0466, 0.0731, 0.0482, 0.0675,\n", + " 0.0472, 0.0570, 0.0531, 0.0348, 0.0551, 0.0453, 0.0370, 0.0385, 0.0077,\n", + " 0.0430, 0.0541], grad_fn=)\n", + "350000\n", + "tensor([10, 19])\n", + "tensor(9851.6055)\n", + "tensor([0.0620, 0.0644, 0.0456, 0.0534, 0.0522, 0.0452, 0.0714, 0.0473, 0.0694,\n", + " 0.0479, 0.0565, 0.0533, 0.0366, 0.0577, 0.0471, 0.0394, 0.0407, 0.0084,\n", + " 0.0439, 0.0576], grad_fn=)\n", + "360000\n", + "tensor([7, 0])\n", + "tensor(10125.7500)\n", + "tensor([0.0561, 0.0622, 0.0429, 0.0514, 0.0498, 0.0433, 0.0678, 0.0463, 0.0673,\n", + " 0.0483, 0.0568, 0.0539, 0.0374, 0.0594, 0.0507, 0.0402, 0.0437, 0.0103,\n", + " 0.0472, 0.0651], grad_fn=)\n", + "370000\n", + "tensor([1, 8])\n", + "tensor(9915.6748)\n", + "tensor([0.0503, 0.0599, 0.0390, 0.0480, 0.0463, 0.0401, 0.0611, 0.0417, 0.0626,\n", + " 0.0471, 0.0583, 0.0561, 0.0402, 0.0627, 0.0524, 0.0423, 0.0466, 0.0138,\n", + " 0.0535, 0.0782], grad_fn=)\n", + "380000\n", + "tensor([ 0, 16])\n", + "tensor(9710.8555)\n", + "tensor([0.0407, 0.0594, 0.0333, 0.0421, 0.0400, 0.0351, 0.0545, 0.0380, 0.0565,\n", + " 0.0451, 0.0590, 0.0560, 0.0399, 0.0695, 0.0550, 0.0453, 0.0518, 0.0208,\n", + " 0.0601, 0.0978], grad_fn=)\n", + "390000\n", + "tensor([ 1, 19])\n", + "tensor(9648.3750)\n", + "tensor([0.0350, 0.0494, 0.0301, 0.0372, 0.0358, 0.0307, 0.0492, 0.0350, 0.0510,\n", + " 0.0436, 0.0569, 0.0579, 0.0415, 0.0746, 0.0581, 0.0501, 0.0568, 0.0230,\n", + " 0.0690, 0.1152], grad_fn=)\n", + "400000\n", + "tensor([16, 6])\n", + "tensor(10194.6562)\n", + "tensor([0.0269, 0.0414, 0.0236, 0.0313, 0.0281, 0.0251, 0.0400, 0.0298, 0.0446,\n", + " 0.0411, 0.0572, 0.0563, 0.0422, 0.0786, 0.0615, 0.0544, 0.0633, 0.0316,\n", + " 0.0799, 0.1430], grad_fn=)\n", + "410000\n", + "tensor([10, 17])\n", + "tensor(9916.4062)\n", + "tensor([0.0173, 0.0337, 0.0169, 0.0233, 0.0212, 0.0189, 0.0308, 0.0236, 0.0376,\n", + " 0.0365, 0.0526, 0.0542, 0.0411, 0.0801, 0.0642, 0.0555, 0.0694, 0.0496,\n", + " 0.0913, 0.1824], grad_fn=)\n", + "420000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([0.0121, 0.0240, 0.0121, 0.0175, 0.0158, 0.0144, 0.0239, 0.0192, 0.0314,\n", + " 0.0322, 0.0482, 0.0496, 0.0397, 0.0800, 0.0643, 0.0580, 0.0748, 0.0590,\n", + " 0.1012, 0.2227], grad_fn=)\n", + "430000\n", + "tensor([13, 15])\n", + "tensor(10007.7754)\n", + "tensor([0.0089, 0.0175, 0.0094, 0.0139, 0.0128, 0.0115, 0.0192, 0.0158, 0.0260,\n", + " 0.0284, 0.0427, 0.0457, 0.0374, 0.0787, 0.0623, 0.0583, 0.0785, 0.0625,\n", + " 0.1109, 0.2596], grad_fn=)\n", + "440000\n", + "tensor([19, 3])\n", + "tensor(10218.7500)\n", + "tensor([0.0062, 0.0130, 0.0069, 0.0106, 0.0099, 0.0090, 0.0150, 0.0126, 0.0214,\n", + " 0.0242, 0.0375, 0.0406, 0.0346, 0.0739, 0.0595, 0.0562, 0.0792, 0.0693,\n", + " 0.1176, 0.3029], grad_fn=)\n", + "450000\n", + "tensor([14, 14])\n", + "tensor(10041.3555)\n", + "tensor([0.0047, 0.0103, 0.0055, 0.0087, 0.0080, 0.0074, 0.0129, 0.0109, 0.0179,\n", + " 0.0211, 0.0334, 0.0364, 0.0315, 0.0683, 0.0547, 0.0544, 0.0781, 0.0720,\n", + " 0.1203, 0.3436], grad_fn=)\n", + "460000\n", + "tensor([19, 6])\n", + "tensor(10194.4492)\n", + "tensor([0.0035, 0.0084, 0.0042, 0.0068, 0.0063, 0.0058, 0.0104, 0.0087, 0.0147,\n", + " 0.0179, 0.0289, 0.0314, 0.0282, 0.0619, 0.0490, 0.0501, 0.0747, 0.0800,\n", + " 0.1199, 0.3892], grad_fn=)\n", + "470000\n", + "tensor([ 9, 13])\n", + "tensor(10009.3750)\n", + "tensor([0.0028, 0.0067, 0.0035, 0.0058, 0.0054, 0.0048, 0.0087, 0.0074, 0.0126,\n", + " 0.0157, 0.0253, 0.0279, 0.0258, 0.0564, 0.0443, 0.0481, 0.0724, 0.0757,\n", + " 0.1192, 0.4315], grad_fn=)\n", + "480000\n", + "tensor([19, 2])\n", + "tensor(10223.2500)\n", + "tensor([0.0020, 0.0054, 0.0025, 0.0042, 0.0039, 0.0035, 0.0066, 0.0057, 0.0095,\n", + " 0.0125, 0.0208, 0.0222, 0.0213, 0.0486, 0.0378, 0.0414, 0.0643, 0.0917,\n", + " 0.1133, 0.4828], grad_fn=)\n", + "490000\n", + "tensor([16, 17])\n", + "tensor(9966.9561)\n", + "tensor([0.0016, 0.0041, 0.0021, 0.0036, 0.0034, 0.0029, 0.0056, 0.0050, 0.0081,\n", + " 0.0109, 0.0181, 0.0198, 0.0190, 0.0430, 0.0339, 0.0389, 0.0625, 0.0774,\n", + " 0.1116, 0.5285], grad_fn=)\n", + "500000\n", + "tensor([18, 2])\n", + "tensor(10225.2061)\n", + "tensor([0.0013, 0.0034, 0.0018, 0.0029, 0.0027, 0.0024, 0.0046, 0.0041, 0.0069,\n", + " 0.0093, 0.0154, 0.0171, 0.0165, 0.0376, 0.0297, 0.0352, 0.0576, 0.0744,\n", + " 0.1057, 0.5715], grad_fn=)\n", + "510000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([0.0010, 0.0025, 0.0015, 0.0025, 0.0023, 0.0020, 0.0039, 0.0035, 0.0060,\n", + " 0.0082, 0.0130, 0.0152, 0.0146, 0.0318, 0.0259, 0.0323, 0.0537, 0.0584,\n", + " 0.1023, 0.6192], grad_fn=)\n", + "520000\n", + "tensor([16, 1])\n", + "tensor(10226.1562)\n", + "tensor([0.0008, 0.0021, 0.0011, 0.0018, 0.0017, 0.0015, 0.0029, 0.0027, 0.0046,\n", + " 0.0063, 0.0106, 0.0119, 0.0117, 0.0262, 0.0213, 0.0271, 0.0455, 0.0637,\n", + " 0.0904, 0.6662], grad_fn=)\n", + "530000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([5.7653e-04, 1.6396e-03, 8.4476e-04, 1.4320e-03, 1.3786e-03, 1.1762e-03,\n", + " 2.3456e-03, 2.1587e-03, 3.7138e-03, 5.1893e-03, 8.6442e-03, 9.9617e-03,\n", + " 9.5869e-03, 2.1709e-02, 1.7576e-02, 2.3029e-02, 3.9864e-02, 5.9855e-02,\n", + " 8.1616e-02, 7.0770e-01], grad_fn=)\n", + "540000\n", + "tensor([19, 4])\n", + "tensor(10212.4492)\n", + "tensor([4.5213e-04, 1.3470e-03, 6.6305e-04, 1.1364e-03, 1.0977e-03, 9.3426e-04,\n", + " 1.8917e-03, 1.7591e-03, 3.0036e-03, 4.2375e-03, 7.1514e-03, 8.2098e-03,\n", + " 7.9226e-03, 1.7821e-02, 1.4567e-02, 1.9720e-02, 3.4402e-02, 5.6593e-02,\n", + " 7.2783e-02, 7.4431e-01], grad_fn=)\n", + "550000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([3.7462e-04, 1.0084e-03, 5.6600e-04, 9.7290e-04, 9.4605e-04, 7.9670e-04,\n", + " 1.6732e-03, 1.5153e-03, 2.6163e-03, 3.7018e-03, 5.9087e-03, 7.0993e-03,\n", + " 6.9445e-03, 1.5055e-02, 1.2512e-02, 1.7623e-02, 3.1520e-02, 4.0453e-02,\n", + " 6.8497e-02, 7.8022e-01], grad_fn=)\n", + "560000\n", + "tensor([19, 19])\n", + "tensor(9901.9492)\n", + "tensor([2.7252e-04, 8.5926e-04, 3.9863e-04, 6.9828e-04, 6.7938e-04, 5.7140e-04,\n", + " 1.2155e-03, 1.1399e-03, 1.9487e-03, 2.7604e-03, 4.6454e-03, 5.4272e-03,\n", + " 5.2160e-03, 1.1891e-02, 9.8367e-03, 1.3837e-02, 2.5135e-02, 4.8128e-02,\n", + " 5.6893e-02, 8.0845e-01], grad_fn=)\n", + "570000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([2.1938e-04, 6.9303e-04, 3.2310e-04, 5.7264e-04, 5.5775e-04, 4.6551e-04,\n", + " 9.9168e-04, 9.5532e-04, 1.5974e-03, 2.2590e-03, 3.8897e-03, 4.4560e-03,\n", + " 4.3203e-03, 9.6592e-03, 8.1129e-03, 1.1847e-02, 2.1835e-02, 4.1134e-02,\n", + " 5.0693e-02, 8.3542e-01], grad_fn=)\n", + "580000\n", + "tensor([19, 15])\n", + "tensor(10024.3496)\n", + "tensor([1.9806e-04, 5.8794e-04, 2.8704e-04, 5.0682e-04, 5.0130e-04, 4.0734e-04,\n", + " 8.8412e-04, 8.6245e-04, 1.4228e-03, 2.0271e-03, 3.4057e-03, 3.9608e-03,\n", + " 3.8496e-03, 8.4847e-03, 7.2296e-03, 1.0698e-02, 2.0069e-02, 3.3331e-02,\n", + " 4.6542e-02, 8.5475e-01], grad_fn=)\n", + "590000\n", + "tensor([19, 12])\n", + "tensor(10097.2500)\n", + "tensor([1.7310e-04, 4.7314e-04, 2.4870e-04, 4.4431e-04, 4.4299e-04, 3.5320e-04,\n", + " 7.8712e-04, 7.6340e-04, 1.2506e-03, 1.7801e-03, 2.8877e-03, 3.5252e-03,\n", + " 3.3734e-03, 7.2509e-03, 6.2427e-03, 9.6827e-03, 1.8192e-02, 2.4824e-02,\n", + " 4.3230e-02, 8.7407e-01], grad_fn=)\n", + "600000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([1.2485e-04, 3.9097e-04, 1.8893e-04, 3.3085e-04, 3.3566e-04, 2.6184e-04,\n", + " 5.9266e-04, 5.7710e-04, 9.5615e-04, 1.3526e-03, 2.3008e-03, 2.7234e-03,\n", + " 2.6172e-03, 5.7696e-03, 4.9638e-03, 7.7507e-03, 1.4770e-02, 2.6151e-02,\n", + " 3.6257e-02, 8.9159e-01], grad_fn=)\n", + "610000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([1.0360e-04, 3.4204e-04, 1.5763e-04, 2.7616e-04, 2.8217e-04, 2.1613e-04,\n", + " 5.0012e-04, 4.8704e-04, 8.0747e-04, 1.1520e-03, 1.9591e-03, 2.3178e-03,\n", + " 2.2193e-03, 4.9217e-03, 4.2993e-03, 6.6987e-03, 1.2819e-02, 2.4914e-02,\n", + " 3.2004e-02, 9.0352e-01], grad_fn=)\n", + "620000\n", + "tensor([19, 2])\n", + "tensor(10223.2500)\n", + "tensor([1.0290e-04, 2.8122e-04, 1.6556e-04, 2.6931e-04, 2.7834e-04, 2.0650e-04,\n", + " 4.8059e-04, 4.6708e-04, 7.6641e-04, 1.0956e-03, 1.7609e-03, 2.1703e-03,\n", + " 2.1319e-03, 4.4715e-03, 3.9537e-03, 6.3963e-03, 1.2427e-02, 1.6645e-02,\n", + " 3.0900e-02, 9.1503e-01], grad_fn=)\n", + "630000\n", + "tensor([19, 16])\n", + "tensor(9996.4492)\n", + "tensor([1.1188e-04, 2.3761e-04, 1.8476e-04, 2.7129e-04, 2.7768e-04, 2.1226e-04,\n", + " 4.7496e-04, 4.5543e-04, 7.4137e-04, 1.0550e-03, 1.6142e-03, 2.0792e-03,\n", + " 2.0769e-03, 4.1010e-03, 3.6651e-03, 6.1515e-03, 1.2023e-02, 1.0983e-02,\n", + " 3.0359e-02, 9.2292e-01], grad_fn=)\n", + "640000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([8.8639e-05, 1.8894e-04, 1.4469e-04, 2.2309e-04, 2.2973e-04, 1.7811e-04,\n", + " 3.9137e-04, 3.8113e-04, 6.1913e-04, 8.7430e-04, 1.3606e-03, 1.7301e-03,\n", + " 1.7385e-03, 3.3894e-03, 3.0958e-03, 5.2955e-03, 1.0354e-02, 9.2434e-03,\n", + " 2.6769e-02, 9.3371e-01], grad_fn=)\n", + "650000\n", + "tensor([16, 2])\n", + "tensor(10223.4561)\n", + "tensor([8.5641e-05, 1.4762e-04, 1.4251e-04, 2.1577e-04, 2.2586e-04, 1.7123e-04,\n", + " 3.7761e-04, 3.7380e-04, 5.7930e-04, 8.2135e-04, 1.2142e-03, 1.5982e-03,\n", + " 1.6573e-03, 2.9928e-03, 2.7727e-03, 5.1693e-03, 9.8487e-03, 5.9262e-03,\n", + " 2.6151e-02, 9.3953e-01], grad_fn=)\n", + "660000\n", + "tensor([19, 2])\n", + "tensor(10223.2500)\n", + "tensor([7.5191e-05, 1.2516e-04, 1.3147e-04, 1.9908e-04, 2.1384e-04, 1.5620e-04,\n", + " 3.5507e-04, 3.6134e-04, 5.3255e-04, 7.7667e-04, 1.0853e-03, 1.4610e-03,\n", + " 1.5534e-03, 2.7000e-03, 2.5013e-03, 4.8269e-03, 9.1897e-03, 4.4197e-03,\n", + " 2.4588e-02, 9.4475e-01], grad_fn=)\n", + "670000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([5.5945e-05, 9.7188e-05, 1.0999e-04, 1.6755e-04, 1.8598e-04, 1.2934e-04,\n", + " 3.0855e-04, 3.1534e-04, 4.6448e-04, 6.6813e-04, 9.0982e-04, 1.2388e-03,\n", + " 1.3348e-03, 2.2284e-03, 2.1090e-03, 4.2190e-03, 8.0729e-03, 3.3966e-03,\n", + " 2.1880e-02, 9.5211e-01], grad_fn=)\n", + "680000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([4.8276e-05, 8.1383e-05, 1.0550e-04, 1.5298e-04, 1.7787e-04, 1.2163e-04,\n", + " 2.9458e-04, 3.0005e-04, 4.4186e-04, 6.1762e-04, 8.2085e-04, 1.1326e-03,\n", + " 1.2392e-03, 2.0162e-03, 1.9045e-03, 3.8602e-03, 7.4216e-03, 2.6010e-03,\n", + " 1.9879e-02, 9.5678e-01], grad_fn=)\n", + "690000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([3.6706e-05, 6.7077e-05, 8.5174e-05, 1.2628e-04, 1.4705e-04, 9.7384e-05,\n", + " 2.4197e-04, 2.4771e-04, 3.6682e-04, 5.1604e-04, 6.8295e-04, 9.4789e-04,\n", + " 1.0274e-03, 1.6503e-03, 1.5772e-03, 3.0364e-03, 5.5363e-03, 2.1916e-03,\n", + " 1.6236e-02, 9.6518e-01], grad_fn=)\n", + "700000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([2.4622e-05, 4.8673e-05, 6.3754e-05, 9.1094e-05, 1.1500e-04, 7.4054e-05,\n", + " 1.9072e-04, 1.9610e-04, 2.9177e-04, 4.1321e-04, 5.4005e-04, 7.3039e-04,\n", + " 7.7433e-04, 1.2132e-03, 1.1621e-03, 2.3212e-03, 4.2928e-03, 1.5876e-03,\n", + " 1.2525e-02, 9.7334e-01], grad_fn=)\n", + "710000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([1.1414e-05, 3.2046e-05, 4.0357e-05, 6.0906e-05, 6.7262e-05, 4.5403e-05,\n", + " 1.2914e-04, 1.3484e-04, 2.0680e-04, 2.5275e-04, 3.7573e-04, 4.7896e-04,\n", + " 4.6999e-04, 8.4200e-04, 8.3241e-04, 1.6111e-03, 2.8246e-03, 1.3039e-03,\n", + " 9.1245e-03, 9.8116e-01], grad_fn=)\n", + "720000\n", + "tensor([19, 1])\n", + "tensor(10225.9492)\n", + "tensor([3.1951e-06, 2.2703e-05, 2.3505e-05, 3.8057e-05, 3.3100e-05, 2.2734e-05,\n", + " 8.8183e-05, 8.6496e-05, 1.4308e-04, 1.6999e-04, 2.6170e-04, 3.0498e-04,\n", + " 2.3353e-04, 5.9496e-04, 5.8044e-04, 9.9268e-04, 1.9117e-03, 1.1252e-03,\n", + " 6.5408e-03, 9.8682e-01], grad_fn=)\n", + "730000\n", + "tensor([19, 4])\n", + "tensor(10212.4492)\n", + "tensor([1.5534e-06, 1.8051e-05, 1.1317e-05, 3.1833e-05, 1.1621e-05, 1.8438e-05,\n", + " 7.0371e-05, 5.3656e-05, 1.0231e-04, 1.4034e-04, 1.8778e-04, 2.0889e-04,\n", + " 1.5913e-04, 4.1504e-04, 4.3857e-04, 7.9260e-04, 1.5722e-03, 8.4387e-04,\n", + " 5.5011e-03, 9.8942e-01], grad_fn=)\n", + "740000\n", + "tensor([19, 4])\n", + "tensor(10212.4492)\n", + "tensor([2.7981e-07, 1.1644e-05, 2.2088e-06, 1.4147e-05, 1.8683e-06, 9.5618e-06,\n", + " 3.3063e-05, 2.9888e-05, 5.2525e-05, 8.4343e-05, 7.4211e-05, 8.6632e-05,\n", + " 8.8317e-05, 2.5064e-04, 2.7313e-04, 4.7424e-04, 9.7179e-04, 7.4474e-04,\n", + " 3.5751e-03, 9.9322e-01], grad_fn=)\n", + "750000\n", + "tensor([19, 4])\n", + "tensor(10212.4492)\n", + "tensor([5.5185e-08, 3.8782e-06, 2.9124e-07, 4.1319e-06, 2.6084e-07, 2.6218e-06,\n", + " 1.9678e-05, 1.7155e-05, 1.9828e-05, 4.0570e-05, 4.4571e-05, 4.2375e-05,\n", + " 3.5498e-05, 1.6293e-04, 1.2761e-04, 2.7197e-04, 6.0525e-04, 6.9734e-04,\n", + " 2.3027e-03, 9.9560e-01], grad_fn=)\n", + "760000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([1.6561e-08, 7.7337e-07, 5.9302e-08, 8.9249e-07, 5.8845e-08, 4.1654e-07,\n", + " 1.2596e-05, 1.0762e-05, 6.9547e-06, 1.4242e-05, 2.5247e-05, 2.3657e-05,\n", + " 1.1739e-05, 1.0033e-04, 4.8222e-05, 1.7650e-04, 3.6951e-04, 4.2799e-04,\n", + " 1.5170e-03, 9.9725e-01], grad_fn=)\n", + "770000\n", + "tensor([19, 3])\n", + "tensor(10218.7500)\n", + "tensor([3.1548e-09, 5.5613e-08, 8.6209e-09, 5.8330e-08, 9.4679e-09, 2.9738e-08,\n", + " 4.4617e-06, 3.5975e-06, 1.0465e-06, 5.2046e-06, 8.3290e-06, 8.8110e-06,\n", + " 1.2262e-06, 2.8838e-05, 1.9068e-05, 5.8333e-05, 1.6602e-04, 3.0110e-04,\n", + " 6.7250e-04, 9.9872e-01], grad_fn=)\n", + "780000\n", + "tensor([19, 12])\n", + "tensor(10097.2500)\n", + "tensor([6.0370e-10, 4.8042e-09, 1.3470e-09, 4.9661e-09, 1.5329e-09, 2.7113e-09,\n", + " 6.4746e-07, 5.1335e-07, 6.2657e-08, 1.4653e-06, 1.2358e-06, 1.3767e-06,\n", + " 6.5058e-08, 4.5811e-06, 5.7842e-06, 1.7257e-05, 3.5082e-05, 1.2238e-04,\n", + " 2.3092e-04, 9.9958e-01], grad_fn=)\n", + "790000\n", + "tensor([19, 6])\n", + "tensor(10194.4492)\n", + "tensor([3.2729e-11, 4.2833e-10, 8.2659e-11, 2.4051e-10, 7.9415e-11, 1.1305e-10,\n", + " 1.6549e-08, 1.1827e-08, 1.9816e-09, 7.0374e-08, 5.9938e-08, 4.4222e-08,\n", + " 1.5772e-09, 1.6657e-07, 3.3407e-07, 6.3737e-07, 1.3387e-06, 1.0091e-04,\n", + " 1.0744e-05, 9.9989e-01], grad_fn=)\n", + "800000\n", + "tensor([19, 8])\n", + "tensor(10169.2500)\n", + "tensor([4.7287e-12, 5.1084e-11, 1.1646e-11, 3.4731e-11, 1.1420e-11, 1.5549e-11,\n", + " 8.4888e-10, 7.7709e-10, 2.5774e-10, 7.5730e-09, 1.6036e-09, 1.3174e-09,\n", + " 2.0122e-10, 5.5196e-09, 1.7574e-08, 3.2647e-08, 5.9992e-08, 2.5587e-05,\n", + " 6.3365e-07, 9.9997e-01], grad_fn=)\n", + "810000\n", + "tensor([19, 14])\n", + "tensor(10050.4492)\n", + "tensor([4.0478e-13, 3.6076e-12, 9.3849e-13, 4.1937e-12, 1.1760e-12, 1.3514e-12,\n", + " 6.1637e-11, 6.2539e-11, 3.1980e-11, 4.3231e-10, 8.2848e-11, 5.8965e-11,\n", + " 2.2096e-11, 2.3235e-10, 6.0776e-10, 1.3069e-09, 2.2845e-09, 1.7585e-06,\n", + " 3.5473e-08, 1.0000e+00], grad_fn=)\n", + "820000\n", + "tensor([19, 0])\n", + "tensor(10226.8496)\n", + "tensor([1.2900e-13, 1.1671e-12, 2.4670e-13, 1.2238e-12, 3.7215e-13, 3.5107e-13,\n", + " 1.8524e-11, 1.8259e-11, 9.4565e-12, 1.0167e-10, 2.1527e-11, 1.5933e-11,\n", + " 5.8290e-12, 5.8640e-11, 1.5831e-10, 3.0832e-10, 5.8368e-10, 4.9473e-07,\n", + " 6.6414e-09, 1.0000e+00], grad_fn=)\n", + "830000\n", + "tensor([19, 8])\n", + "tensor(10169.2500)\n", + "tensor([5.9003e-11, 3.4033e-10, 1.0686e-10, 4.9540e-10, 1.9856e-10, 1.6084e-10,\n", + " 5.4946e-09, 6.0723e-09, 4.0996e-09, 2.3543e-08, 6.1794e-09, 4.5015e-09,\n", + " 3.0588e-09, 1.7113e-08, 3.9123e-08, 7.5610e-08, 1.4559e-07, 6.7849e-05,\n", + " 1.1090e-06, 9.9993e-01], grad_fn=)\n", + "840000\n", + "tensor([19, 8])\n", + "tensor(10169.2500)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([1.5584e-07, 4.7639e-07, 2.7054e-07, 1.1492e-06, 6.5995e-07, 4.4139e-07,\n", + " 8.6586e-06, 1.1273e-05, 1.0714e-05, 2.8920e-05, 9.5413e-06, 6.8927e-06,\n", + " 1.0472e-05, 2.7870e-05, 5.2311e-05, 1.0295e-04, 1.9757e-04, 4.5366e-02,\n", + " 1.3656e-03, 9.5280e-01], grad_fn=)\n", + "850000\n", + "tensor([19, 3])\n", + "tensor(10218.7500)\n", + "tensor([9.7540e-06, 1.5541e-05, 1.5875e-05, 6.2228e-05, 4.9025e-05, 2.8837e-05,\n", + " 3.1092e-04, 4.7927e-04, 6.2829e-04, 8.6195e-04, 3.6330e-04, 2.6130e-04,\n", + " 8.1169e-04, 1.1114e-03, 1.7094e-03, 3.4079e-03, 6.2823e-03, 8.8705e-01,\n", + " 8.3597e-02, 1.2943e-02], grad_fn=)\n", + "860000\n", + "tensor([17, 0])\n", + "tensor(10228.8750)\n", + "tensor([4.0827e-03, 2.8477e-03, 6.7528e-03, 8.9480e-03, 1.5809e-02, 8.9220e-03,\n", + " 1.2271e-02, 2.5053e-02, 4.2815e-02, 2.3646e-02, 2.0960e-02, 2.0509e-02,\n", + " 1.1516e-01, 5.2420e-02, 6.0542e-02, 7.5311e-02, 1.2475e-01, 1.7476e-01,\n", + " 2.0444e-01, 2.7906e-08], grad_fn=)\n", + "870000\n", + "tensor([18, 1])\n", + "tensor(10227.9062)\n", + "tensor([5.9983e-03, 6.0219e-03, 1.1531e-02, 1.3986e-02, 2.1609e-02, 1.2936e-02,\n", + " 2.1186e-02, 3.3898e-02, 4.3522e-02, 3.4450e-02, 2.3592e-02, 2.3159e-02,\n", + " 7.1129e-02, 4.5303e-02, 6.0648e-02, 7.4365e-02, 1.0392e-01, 1.9086e-01,\n", + " 2.0188e-01, 6.2415e-06], grad_fn=)\n", + "880000\n", + "tensor([13, 10])\n", + "tensor(10120.2754)\n", + "tensor([7.2260e-03, 7.2311e-03, 1.4252e-02, 1.7769e-02, 2.5951e-02, 1.6078e-02,\n", + " 2.8900e-02, 4.1699e-02, 4.6696e-02, 4.1078e-02, 2.5484e-02, 2.5095e-02,\n", + " 6.3496e-02, 4.3441e-02, 5.8361e-02, 7.3896e-02, 9.7317e-02, 1.7697e-01,\n", + " 1.8903e-01, 2.2281e-05], grad_fn=)\n", + "890000\n", + "tensor([18, 1])\n", + "tensor(10227.9062)\n", + "tensor([6.1627e-03, 5.7052e-03, 1.2496e-02, 1.7203e-02, 2.4586e-02, 1.5931e-02,\n", + " 3.0866e-02, 4.2275e-02, 4.5123e-02, 4.3156e-02, 2.5793e-02, 2.5608e-02,\n", + " 5.6562e-02, 4.3902e-02, 5.8657e-02, 7.4179e-02, 9.5717e-02, 1.8750e-01,\n", + " 1.8851e-01, 6.3416e-05], grad_fn=)\n", + "900000\n", + "tensor([18, 2])\n", + "tensor(10225.2061)\n", + "tensor([3.8489e-03, 3.3622e-03, 8.2591e-03, 1.3352e-02, 1.7055e-02, 1.1639e-02,\n", + " 2.3690e-02, 3.0189e-02, 3.1381e-02, 3.5300e-02, 2.2049e-02, 2.1617e-02,\n", + " 4.6022e-02, 3.9704e-02, 5.2516e-02, 7.7199e-02, 9.7976e-02, 2.5096e-01,\n", + " 2.1371e-01, 1.6582e-04], grad_fn=)\n", + "910000\n", + "tensor([17, 3])\n", + "tensor(10220.7754)\n", + "tensor([0.0028, 0.0028, 0.0065, 0.0114, 0.0133, 0.0093, 0.0184, 0.0232, 0.0234,\n", + " 0.0268, 0.0172, 0.0162, 0.0347, 0.0313, 0.0421, 0.0703, 0.0903, 0.3201,\n", + " 0.2397, 0.0004], grad_fn=)\n", + "920000\n", + "tensor([12, 10])\n", + "tensor(10110.9062)\n", + "tensor([0.0048, 0.0047, 0.0099, 0.0167, 0.0178, 0.0124, 0.0231, 0.0271, 0.0267,\n", + " 0.0287, 0.0192, 0.0183, 0.0353, 0.0305, 0.0413, 0.0688, 0.0882, 0.2938,\n", + " 0.2320, 0.0005], grad_fn=)\n", + "930000\n", + "tensor([17, 8])\n", + "tensor(10171.2754)\n", + "tensor([0.0090, 0.0090, 0.0160, 0.0275, 0.0269, 0.0174, 0.0319, 0.0338, 0.0331,\n", + " 0.0321, 0.0218, 0.0207, 0.0375, 0.0330, 0.0409, 0.0657, 0.0847, 0.2506,\n", + " 0.2080, 0.0004], grad_fn=)\n", + "940000\n", + "tensor([12, 0])\n", + "tensor(10200.9062)\n", + "tensor([0.0142, 0.0140, 0.0224, 0.0379, 0.0372, 0.0219, 0.0394, 0.0398, 0.0391,\n", + " 0.0346, 0.0238, 0.0209, 0.0373, 0.0321, 0.0391, 0.0630, 0.0792, 0.2177,\n", + " 0.1859, 0.0005], grad_fn=)\n", + "950000\n", + "tensor([17, 2])\n", + "tensor(10225.2754)\n", + "tensor([0.0228, 0.0211, 0.0317, 0.0541, 0.0485, 0.0281, 0.0510, 0.0452, 0.0454,\n", + " 0.0383, 0.0252, 0.0218, 0.0370, 0.0311, 0.0362, 0.0580, 0.0715, 0.1781,\n", + " 0.1545, 0.0003], grad_fn=)\n", + "960000\n", + "tensor([17, 0])\n", + "tensor(10228.8750)\n", + "tensor([0.0302, 0.0267, 0.0392, 0.0692, 0.0603, 0.0319, 0.0606, 0.0503, 0.0495,\n", + " 0.0396, 0.0249, 0.0213, 0.0352, 0.0294, 0.0319, 0.0499, 0.0633, 0.1485,\n", + " 0.1377, 0.0003], grad_fn=)\n", + "970000\n", + "tensor([17, 0])\n", + "tensor(10228.8750)\n", + "tensor([0.0383, 0.0356, 0.0488, 0.0893, 0.0751, 0.0351, 0.0697, 0.0543, 0.0528,\n", + " 0.0389, 0.0243, 0.0190, 0.0313, 0.0254, 0.0271, 0.0407, 0.0508, 0.1261,\n", + " 0.1170, 0.0003], grad_fn=)\n", + "980000\n", + "tensor([ 6, 18])\n", + "tensor(9813.4561)\n", + "tensor([0.0545, 0.0510, 0.0643, 0.1271, 0.0977, 0.0395, 0.0843, 0.0559, 0.0567,\n", + " 0.0367, 0.0225, 0.0167, 0.0260, 0.0208, 0.0208, 0.0293, 0.0357, 0.0854,\n", + " 0.0747, 0.0003], grad_fn=)\n", + "990000\n", + "tensor([ 0, 18])\n", + "tensor(9649.6562)\n" + ] + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# advModeNames=\"\"\n", + "# for i in range(len(adversaryProbs)):\n", + "# if adversaryProbs[i]!=0:\n", + "# tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + "# advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + "# \n", + "# name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "# neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# neuralNet.load(name=name)\n", + "# \"hi\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# demandPotential.plot()\n", + "# demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# profits.plot()\n", + "# profits" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# prices.plot()\n", + "# prices" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_2)):\n", + " learning_2[i] = learning[i][0]\n", + "plt.plot(learning_2)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/NNs/ep 10, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/NNs/ep 10, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..e036bff Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/ep 10, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..96066bc Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 2 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 2 hist, 1e-05 lr.pt new file mode 100644 index 0000000..3f0b020 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/ep 100, myopic-1.0-, 2 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/ep 1000, myopic-1.0-, 0 hist, 0.0001 lr.pt b/learningAgents/naive_policy_gradient/NNs/ep 1000, myopic-1.0-, 0 hist, 0.0001 lr.pt new file mode 100644 index 0000000..ea6e2a5 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/ep 1000, myopic-1.0-, 0 hist, 0.0001 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/nn ep 10^6 myopic, no adv history.pt b/learningAgents/naive_policy_gradient/NNs/nn ep 10^6 myopic, no adv history.pt new file mode 100644 index 0000000..c2e15b5 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/nn ep 10^6 myopic, no adv history.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/nn, ep=1000.pt b/learningAgents/naive_policy_gradient/NNs/nn, ep=1000.pt new file mode 100644 index 0000000..d9ee7f7 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/nn, ep=1000.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/nn, ep=10000.pt b/learningAgents/naive_policy_gradient/NNs/nn, ep=10000.pt new file mode 100644 index 0000000..1133e05 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/nn, ep=10000.pt differ diff --git a/learningAgents/naive_policy_gradient/NNs/nn, lr=1e-06, actions=50.pt b/learningAgents/naive_policy_gradient/NNs/nn, lr=1e-06, actions=50.pt new file mode 100644 index 0000000..1830f09 Binary files /dev/null and b/learningAgents/naive_policy_gradient/NNs/nn, lr=1e-06, actions=50.pt differ diff --git a/learningAgents/naive_policy_gradient/NeuralNetwork.py b/learningAgents/naive_policy_gradient/NeuralNetwork.py new file mode 100644 index 0000000..4462295 --- /dev/null +++ b/learningAgents/naive_policy_gradient/NeuralNetwork.py @@ -0,0 +1,40 @@ +import torch +import torch.nn as nn + +class NeuralNetwork(): + + save_path_format='./NNs/{name}.pt' + + def __init__(self,lr, num_input, num_actions, nn_dim) -> None: + + + self.lr=lr + self.num_input= num_input + self.num_actions = num_actions + + self.nn_ = nn_dim + + self.nn_name=f"nn, lr={self.lr}, actions={self.num_actions}" + + + + def reset(self): + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_), + nn.ReLU(), + nn.Linear(self.nn_,self.nn_), + nn.ReLU(), + nn.Linear(self.nn_,self.num_actions), + nn.Softmax(dim=0)) + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim + + def save(self, name=None): + self.nn_name=(self.nn_name if name is None else name) + return torch.save(self.policy.state_dict(),self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + self.nn_name=(self.nn_name if name is None else name) + self.policy=torch.load(self.save_path_format.format(name=self.nn_name)) + diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Deep_Q-Learning-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Deep_Q-Learning-checkpoint.ipynb new file mode 100644 index 0000000..1ac8fcc --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Deep_Q-Learning-checkpoint.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "authorized-valve", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from collections import deque, namedtuple\n", + "from environment import Model, AdversaryModes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f30716d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_demand = 400\n", + "agent_cost = 57\n", + "adversary_cost = 71 \n", + "costs = [agent_cost,adversary_cost]\n", + "total_stages = 25\n", + "adversary_probabilities=[0]*len(AdversaryModes)\n", + "adversary_probabilities[0]=1\n", + "\n", + "env = Model(total_demand, costs, total_stages, adversary_probabilities)\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d3611c5", + "metadata": {}, + "outputs": [], + "source": [ + "class QNetwork(nn.Module):\n", + "\n", + " def __init__(self, state_size, action_size):\n", + " super().__init__() \n", + " self.input_layer = nn.Linear(state_size, 200)\n", + " self.hidden_layer = nn.Linear(200, 200)\n", + " self.output_layer = nn.Linear(200, action_size)\n", + " \n", + " def forward(self, state):\n", + " x = self.input_layer(state)\n", + " x = F.relu(x)\n", + " x = self.hidden_layer(x)\n", + " x = F.relu(x)\n", + " x = self.output_layer(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2a6a493", + "metadata": {}, + "outputs": [], + "source": [ + "BUFFER_SIZE = int(10_000) # replay buffer size\n", + "BATCH_SIZE = 64 # minibatch size\n", + "GAMMA = 1 # discount factor\n", + "TAU = 0.001 # for soft update of target parameters\n", + "LR = 0.0005 # learning rate \n", + "UPDATE_EVERY = 8 # how often to update the network" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b0612b47", + "metadata": {}, + "outputs": [], + "source": [ + "class Agent():\n", + "\n", + " def __init__(self, state_size, action_size):\n", + "\n", + " self.state_size = state_size\n", + " self.action_size = action_size\n", + "\n", + " # Q-Network\n", + " self.qnetwork_local = QNetwork(state_size, action_size)\n", + " self.qnetwork_target = QNetwork(state_size, action_size)\n", + " self.optimiser = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n", + "\n", + " # Replay memory\n", + " self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE)\n", + " # Initialise time step (for updating every UPDATE_EVERY steps)\n", + " self.t_step = 0\n", + " \n", + " def step(self, state, action, reward, next_state, done):\n", + " # Save experience in replay memory\n", + " self.memory.add(state, action, reward, next_state, done)\n", + " \n", + " # Learn every UPDATE_EVERY time steps.\n", + " self.t_step = (self.t_step + 1) % UPDATE_EVERY\n", + " if self.t_step == 0:\n", + " # If enough samples are available in memory, get random subset and learn\n", + " if len(self.memory) > BATCH_SIZE:\n", + " experiences = self.memory.sample()\n", + " self.learn(experiences, GAMMA)\n", + "\n", + " def act(self, state, eps):\n", + "\n", + " state = state.float().unsqueeze(0)\n", + " self.qnetwork_local.eval()\n", + " with torch.no_grad():\n", + " action_values = self.qnetwork_local(state)\n", + " self.qnetwork_local.train()\n", + "\n", + " # Epsilon-greedy action selection\n", + " if random.random() > eps:\n", + " return np.argmax(action_values.data.numpy())\n", + " else:\n", + " return random.choice(np.arange(self.action_size))\n", + "\n", + " def learn(self, experiences, gamma):\n", + "\n", + " states, actions, rewards, next_states, dones = experiences\n", + " q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n", + " q_targets = rewards + gamma * q_targets_next * (1 - dones)\n", + " q_expected = self.qnetwork_local(states).gather(1, actions)\n", + " \n", + " loss = F.mse_loss(q_expected, q_targets)\n", + " self.optimiser.zero_grad()\n", + " loss.backward()\n", + " self.optimiser.step()\n", + "\n", + " self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \n", + "\n", + " def soft_update(self, local_model, target_model, tau):\n", + " \n", + " for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n", + " target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e60fdc3", + "metadata": {}, + "outputs": [], + "source": [ + "class ReplayBuffer:\n", + "\n", + " def __init__(self, action_size, buffer_size, batch_size):\n", + "\n", + " self.action_size = action_size\n", + " self.memory = deque(maxlen=buffer_size) \n", + " self.batch_size = batch_size\n", + " self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n", + " \n", + " def add(self, state, action, reward, next_state, done):\n", + " \"\"\"Add a new experience to memory.\"\"\"\n", + " experience = self.experience(state, action, reward, next_state, done)\n", + " self.memory.append(experience)\n", + " \n", + " def sample(self):\n", + " \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n", + " experiences = random.sample(self.memory, k=self.batch_size)\n", + "\n", + " states = torch.from_numpy(np.vstack([experience.state for experience in experiences if experience is not None])).float()\n", + " actions = torch.from_numpy(np.vstack([experience.action for experience in experiences if experience is not None])).long()\n", + " rewards = torch.from_numpy(np.vstack([experience.reward for experience in experiences if experience is not None])).float()\n", + " next_states = torch.from_numpy(np.vstack([experience.next_state for experience in experiences if experience is not None])).float()\n", + " dones = torch.from_numpy(np.vstack([experience.done for experience in experiences if experience is not None]).astype(np.uint8)).float()\n", + " \n", + " return (states, actions, rewards, next_states, dones)\n", + "\n", + " def __len__(self):\n", + " \"\"\"Return the current size of internal memory.\"\"\"\n", + " return len(self.memory)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7bff3bfd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0\tAverage Score: 169671.00\n", + "Episode 5000\tAverage Score: 165271.83\n", + "Episode 10000\tAverage Score: 165782.55\n", + "Episode 15000\tAverage Score: 166931.08\n", + "Episode 20000\tAverage Score: 167496.04\n", + "Episode 25000\tAverage Score: 169142.78\n", + "Episode 30000\tAverage Score: 171067.50\n", + "Episode 35000\tAverage Score: 171962.95\n", + "Episode 40000\tAverage Score: 172211.15\n", + "Episode 45000\tAverage Score: 172176.92\n", + "Episode 50000\tAverage Score: 173292.13\n", + "Episode 55000\tAverage Score: 174271.68\n", + "Episode 60000\tAverage Score: 176350.42\n", + "Episode 65000\tAverage Score: 177105.63\n", + "Episode 70000\tAverage Score: 178208.86\n", + "Episode 75000\tAverage Score: 177706.84\n", + "Episode 80000\tAverage Score: 177841.97\n", + "Episode 85000\tAverage Score: 176620.66\n", + "Episode 90000\tAverage Score: 177956.96\n", + "Episode 95000\tAverage Score: 177746.00\n", + "Episode 100000\tAverage Score: 178210.52\n", + "Episode 105000\tAverage Score: 177339.47\n", + "Episode 110000\tAverage Score: 177947.92\n", + "Episode 115000\tAverage Score: 177841.17\n", + "Episode 120000\tAverage Score: 177980.15\n", + "Episode 125000\tAverage Score: 177477.03\n", + "Episode 130000\tAverage Score: 178026.23\n", + "Episode 135000\tAverage Score: 178510.44\n", + "Episode 140000\tAverage Score: 178235.72\n", + "Episode 145000\tAverage Score: 178676.76\n", + "Episode 150000\tAverage Score: 177196.13\n", + "Episode 155000\tAverage Score: 176133.93\n", + "Episode 160000\tAverage Score: 178601.00\n", + "Episode 165000\tAverage Score: 178233.33\n", + "Episode 170000\tAverage Score: 177109.69\n", + "Episode 175000\tAverage Score: 178397.17\n", + "Episode 180000\tAverage Score: 178324.12\n", + "Episode 185000\tAverage Score: 178026.06\n", + "Episode 190000\tAverage Score: 178197.18\n", + "Episode 195000\tAverage Score: 177351.39\n", + "Episode 199999\tAverage Score: 178157.79" + ] + } + ], + "source": [ + "def dqn(number_episodes, eps_start=1.0, eps_end=0.0001, eps_decay=0.99995):\n", + "\n", + " scores = [] # list containing scores from each episode\n", + " scores_window = deque(maxlen=100) # last 100 scores\n", + " eps = eps_start # initialise epsilon\n", + " best_payoff = 0\n", + " best_actions = list()\n", + " for episode in range(number_episodes):\n", + " state, reward, done = env.reset()\n", + " score = 0\n", + " actions = list()\n", + " while not done:\n", + " action = agent.act(state, eps)\n", + " actions.append(action)\n", + " next_state, reward, done = env.step(action)\n", + " agent.step(state, action, reward, next_state, done)\n", + " state = next_state\n", + " score += reward\n", + " scores_window.append(score) # save most recent score\n", + " scores.append(score) # save most recent score\n", + " eps = max(eps_end, eps_decay*eps) # decrease epsilon\n", + " if score >= best_payoff:\n", + " best_payoff = score\n", + " best_actions = actions\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)), end=\"\")\n", + " if episode % 5000 == 0:\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)))\n", + " return scores, best_payoff, best_actions\n", + "\n", + "agent = Agent(state_size=2, action_size=60)\n", + "scores, best_payoff, best_actions = dqn(200_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "empirical-friday", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the scores\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(np.arange(len(scores)), scores)\n", + "plt.ylabel('Score')\n", + "plt.xlabel('Episode #')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c8a33b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "180121" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_payoff" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7d0864cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([48, 52, 52, 52, 52, 50, 50, 50, 50, 50, 50, 50, 50, 50, 46, 46, 46,\n", + " 46, 46, 46, 46, 46, 46, 20, 4])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.transpose(best_actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c75ca275", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "177990.99859985997" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e9ffcee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "925.9989800259722" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29f8804a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Play-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Play-checkpoint.ipynb new file mode 100644 index 0000000..1ebec76 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Play-checkpoint.ipynb @@ -0,0 +1,164 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame as BG\n", + "import globals as gl\n", + "import torch\n", + "import numpy as np\n", + "from environmentModelBase import Model, MixedStrategy, Strategy, StrategyType\n", + "import environmentModelBase as em\n", + "from learningBase import ReinforceAlgorithm\n", + "from neuralNetworkSimple import NNBase\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sjaha\\Documents\\EquiLearn\\PGM_base\\environmentModelBase.py:344: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " adversaryDist = Categorical(torch.tensor(self._strategyProbs))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "equi: [0.72, 0.00, 0.20, 0.00, 0.08], [0.24, 0.00, 0.19, 0.57], 93424.32, 86210.12\n", + "Round 0 of 50\n" + ] + } + ], + "source": [ + "number_rounds=50\n", + "\n", + "# l1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# l1.load(\"low,1684212411\")\n", + "# l2=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# l2.load(\"low,1684332617\")\n", + "# h1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# h1.load(\"high,1684261807\")\n", + "equilibria = []\n", + "low_cost_players = [\n", + " Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)\n", + " ]\n", + "high_cost_players = [\n", + " Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)\n", + " ]\n", + "bimatrixGame = BG.BimatrixGame(low_cost_players, high_cost_players)\n", + " # bimatrixGame.reset_matrix()\n", + "bimatrixGame.fill_matrix()\n", + "low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "for round in range(number_rounds):\n", + " print(\"Round\", round, \" of \", number_rounds)\n", + "\n", + " update = False\n", + "\n", + "\n", + " acceptable, agentPayoffs, advPayoffs, low_cost_player = BG.training([gl.lowCost, gl.highCost], advMixedStrategy=MixedStrategy(\n", + " strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), targetPayoff=low_cost_payoff)\n", + " if acceptable:\n", + " update = True\n", + " low_cost_players.append(low_cost_player)\n", + " bimatrixGame.add_low_cost_row(agentPayoffs, advPayoffs)\n", + " equilibria.append(\n", + " [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(f\"low cost player {low_cost_player._name} added\")\n", + "\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "\n", + "\n", + " acceptable, agentPayoffs, advPayoffs, high_cost_player = BG.training(\n", + " [gl.highCost, gl.lowCost], advMixedStrategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), targetPayoff=high_cost_payoff)\n", + "\n", + " if acceptable:\n", + " update = True\n", + " high_cost_players.append(high_cost_player)\n", + " bimatrixGame.add_high_cost_col(advPayoffs, agentPayoffs)\n", + " equilibria.append(\n", + " [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(f\"high cost player {high_cost_player._name} added\")\n", + "\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "\n", + " if update:\n", + " gl.numEpisodes = gl.numEpisodesReset\n", + " else:\n", + " gl.numEpisodes += 1000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/TEMPLATE-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/TEMPLATE-checkpoint.ipynb new file mode 100644 index 0000000..cc016b3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/TEMPLATE-checkpoint.ipynb @@ -0,0 +1,1918 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 2, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.0001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "8562 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9869, 0.9893, 0.9854, 0.9854, 0.9847, 0.9844, 0.9871, 0.9878, 0.9833,\n", + " 0.9876, 0.9865, 0.9817, 0.9840, 0.9855, 0.9899, 0.9882, 0.9911, 0.9857,\n", + " 0.9879, 0.9917, 0.9854, 0.9881, 0.9876, 0.9837, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "21777 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 2, 2, 0, 0, 0, 0, 1, 0, 2, 0, 2, 0, 2, 2, 2, 0, 2, 2, 0, 2, 0, 2,\n", + " 0])\n", + "loss= tensor(9.6414e-06, grad_fn=) , base rewards= tensor([1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331,\n", + " 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331,\n", + " 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 1.1331, 0.5652]) return= 141175.34850645196\n", + "probs of actions: tensor([0.7237, 0.3454, 0.5849, 0.5308, 0.4958, 0.6164, 0.3024, 0.6995, 0.1097,\n", + " 0.3733, 0.4878, 0.5588, 0.5978, 0.3520, 0.4858, 0.3242, 0.5635, 0.3220,\n", + " 0.3555, 0.1909, 0.4206, 0.4134, 0.5613, 0.9990, 0.9997],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5491, 0.5630, 0.5705, 0.5665, 0.5645, 0.5635, 0.5629,\n", + " 0.5665, 0.5641, 0.5710, 0.5664, 0.5722, 0.5669, 0.5720, 0.5746, 0.5763,\n", + " 0.5690, 0.5731, 0.5755, 0.5686, 0.5733, 0.5675, 0.5727])\n", + "finalReturns: tensor([0.0071, 0.0075])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "3593 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(3.4499e-05, grad_fn=) , base rewards= tensor([1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120,\n", + " 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120,\n", + " 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.1344, 0.5644]) return= 142818.33338316283\n", + "probs of actions: tensor([0.0131, 0.9890, 0.9924, 0.9917, 0.9811, 0.9786, 0.9902, 0.9733, 0.9909,\n", + " 0.9924, 0.9853, 0.9849, 0.9925, 0.9885, 0.9901, 0.9847, 0.9913, 0.9897,\n", + " 0.9853, 0.9690, 0.9903, 0.9896, 0.9990, 1.0000, 0.9989],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5362, 0.5565, 0.5668, 0.5720, 0.5746, 0.5759, 0.5765, 0.5769,\n", + " 0.5770, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0200, 0.0204, 0.0132])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "100 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(8.0701e-05, grad_fn=) , base rewards= tensor([2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722,\n", + " 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722,\n", + " 2.2722, 2.2722, 2.2722, 2.2722, 1.6946, 1.1245, 0.5602]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9876, 0.9934, 0.9961, 0.9956, 0.9893, 0.9892, 0.9947, 0.9858, 0.9949,\n", + " 0.9961, 0.9920, 0.9917, 0.9959, 0.9936, 0.9950, 0.9913, 0.9953, 0.9942,\n", + " 0.9919, 0.9833, 0.9950, 0.9990, 0.9994, 1.0000, 0.9988],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0370, 0.0374, 0.0303, 0.0174])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "1784 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(9.5057e-05, grad_fn=) , base rewards= tensor([2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292,\n", + " 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292,\n", + " 2.8292, 2.8292, 2.8292, 2.2516, 1.6815, 1.1172, 0.5570]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9936, 0.9966, 0.9981, 0.9977, 0.9941, 0.9953, 0.9966, 0.9927, 0.9977,\n", + " 0.9980, 0.9958, 0.9963, 0.9977, 0.9965, 0.9974, 0.9962, 0.9973, 0.9969,\n", + " 0.9960, 0.9918, 0.9990, 0.9998, 0.9997, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0572, 0.0576, 0.0505, 0.0376, 0.0206])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAt6klEQVR4nO3df5BU9Znv8feHocHBJAwKbnTADFEXK4QIOlfdcrMVzRXcGHVidNVrEv6w1t3spuqajaSgjELUXPFSiVbKqtxrrsSoCSExZkKWzRKymLLWG9HBgSCJXHFFYDCBXBivkVGG4bl/9DnDmZ5z+td0T5/ufl5VXfR8z4/+dtN9nvP9LTPDOeecSzKh1hlwzjmXbh4onHPO5eWBwjnnXF4eKJxzzuXlgcI551xeE2udgUqbPn26dXR01DobzjlXV7Zs2fJHM5sRt63hAkVHRwc9PT21zoZzztUVSa8nbfOqJ+ecc3l5oHDOOZeXBwrnnHN5FQwUklZLOiDppZhtt0sySdODvy+UtDV4bJP0qci+F0jaLmmXpG9KUpA+WdLaIH2zpI7IMYslvRI8FlfkHTvnnCtJMSWKR4ErchMlzQIuB/ZEkl8COs1sfnDM/5QUNph/C7gVOCd4hOe8BThsZmcDDwD3B+c/BVgOXARcCCyXNK2E9+acc64CCvZ6MrNnonf5EQ8AXwZ+Gtn3SGT7SYABSDodeJ+Z/Tr4+zGgC/g5cA2wIjjmSeChoLSxCNhoZoeCYzaSDS5rin53zjlXgq90b+eJ5/YU3rEO7F55ZcXOVVYbhaSrgT4z2xaz7SJJO4DtwN+b2TGgHdgX2W1fkEbw716AYN83gVOj6THH5L7mrZJ6JPUcPHiwnLfknGtyjRQkADqWrq/YuUoOFJKmAHcAd8VtN7PNZjYX+E/AMkknAYrbNTxlwrZ8x+S+5sNm1mlmnTNmxI4Xcc65vNZs3lt4pyZVToniLGA2sE3SbmAm8KKk90d3MrPfAW8DHyZbGpgZ2TwT2B883wfMAgjaM6YCh6LpMcc451xFDfnaPIlKDhRmtt3MTjOzDjPrIHtBP9/Mfi9pdth4LekDwBxgt5m9Abwl6eKg/eFznGjbWAeEPZquAzZZdjWlDcBCSdOCRuyFQZpzzlVci+IqMRwU1z12DfBrYI6kfZJuybP7X5ItaWwFfgL8g5n9Mdj2eeB/AbuAV8k2ZAM8ApwqaRfwT8BSgKAR+x7gheBxd9iw7ZxzlTb9PZlaZyG1iun1dFOB7R2R548Djyfs10O2Gio3/R3g+oRjVgOrC+XROefG6g9vHa11FirqMxefWbFz+chs55xrQJVsnPdA4ZxzDaiSjfMeKJxzDrjkrFNqnYWKqmTjvAcK55xrQBd/sHIzHnmgcM454NlXG6tT5e7/O1Cxc3mgcM65BrS/3wOFc865PM5oa63YuTxQOOdcA1qyaE7FzuWBwjnnGoiAB2+YT9eC2Mm2y1JwZLZzzrn0E/BaBdegiPIShXPO1ZGk8RGVbJPI5YHCOefqRGumhZsumkVrpmVUeiXbJHJ5oHDOuRSaNiXDZy4+k/a2VgS0t7Vy37XzuLdrHvddO29UeiXbJHJ5G4VzzqVEse0MXQvaqxoYcnmJwjnnUmJqazrXxPBA4ZxzKfH20WN09/bVOhujeKBwzrmUGBwyVm3YWetsjOKBwjnnUqSSczRVigcK55xLkWqOhyiXBwrnnKuBttbMuI+HKFfBQCFptaQDkl6K2Xa7JJM0Pfj7cklbJG0P/r0ssu+vJO2UtDV4nBakT5a0VtIuSZsldUSOWSzpleCxuCLv2DnnUuCT550+7uMhylXMOIpHgYeAx6KJkmYBlwN7Isl/BK4ys/2SPgxsAKLv+mYz68k5/y3AYTM7W9KNwP3ADZJOAZYDnYABWyStM7PDRb8755xLqadfPsi9XekMDLkKlijM7BkgbumnB4Avk72Ih/v2mtn+4M8dwEmSJhd4iWuA7wbPnwQ+LknAImCjmR0KgsNG4IpC+XXOuXqQxkbrJGW1UUi6Gugzs215dvs00Gtm70bSvhNUO90ZBAPIljj2ApjZMeBN4NRoemAfI0sn0fzcKqlHUs/BgwfLeUvOOTeu0thonaTkQCFpCnAHcFeefeaSrUL6u0jyzWY2D/ho8PhsuHvMKSxP+uhEs4fNrNPMOmfMmFH4TTjnXJVMEGRa4md4DaW10TpJOSWKs4DZwDZJu4GZwIuS3g8gaSbwE+BzZvZqeJCZ9QX/vgV8H7gw2LQPmBUcOxGYSraqazg9MBPYj3POpdS0KRm+8TfzWXXdeSMaqeMm96uHtolQyZMCmtl24LTw7yBYdJrZHyW1AeuBZWb2bGSfiUBbsE8G+CTwy2DzOmAx8GvgOmCTmZmkDcB/kzQt2G8hsKzU/Drn3HjYnTOZXz0FgkKK6R67huxFfI6kfZJuybP7F4CzgTtzusFOBjZI+g2wFegDvh0c8whwqqRdwD8BSwHM7BBwD/BC8Lg7SHPO1bHu3j4uWbmJ2UvXc8nKTamc26gcjfI+4sgsttq/bnV2dlpPT24PXOdcGnT39rHsqe0MDA4Np7VmWlJRFdOxdP2Yjk/L+yiXpC1m1hm3zUdmO+fGzaoNO0cECYCBwaFUToRXqkZ5H3E8UDjnxk3S2IF6GlOQT6O8j1weKJxz4yZp7EA9jSnIp1HeRy4PFM65cbNk0Zy6mQivVI3yPuL4mtnOuXETNvSu2rCT/f0DnNHWypJFc+q2AbhF4rhZ3b+PQjxQOOfGVdeC9oa5oB4347Wc8RONyKuenHOugBbFT8nRqG0SubxE4ZxrCt29fWVXed100Sx+vKVv1PiPRm2TyOUlCudcwwsH+vX1D2BAX/8Ay57aXvRo6s4PnFI3iwxVg5conHMNL99Av2Iu9qs27OTZpZc1TWDI5SUK51zDG+tAv0YdSFcsL1E458akUN1/d28fK9btoH9gEMhOxb38qrkVvzvPl48z2lrpi7nYF9sY3SyN1km8ROGcK1uhuv/u3j6W/GjbcJAAOHxkkCVPbqvobKuF8jHWgX6XntvcC6J5oHDOla3QJH+rNuxk8PjoGaoHh6yiE+gVykfXgvYxNUY//XJzL7HsVU/OubIVqvvPV7dfbL1/Md1ai2mDiA70C8/5xbVbh8+ZT7O3UXiJwjlXtqS6eyO7vsOEhIFq0X3m3vWvidVQxXZrLWWywbhz3rZ2a2I+852/WXigcM6VLa7uP2qoiIXR3j46xJd+FN9mUez6FaW0QcSds5Ali+bwle7tnLXsX+hYup6zlv0LX+neXtI56plXPTnnyhZW5Xzph9uKCgpJho4bt63dym1rt47oFVVst9ZCkw1Gq6/KyWXP64d44rk9J/JrNvz3vV3zyjhjffEShXNuTLoWtHO8gksqR3tF5avaiq63HXbBDauTjhw9NrxvblVTOdZs3ltSeqPxEoVzbsySximUK+wVtWTRnFFrbIf6+gdY8uQ2el4/xNrn947oXRUGGyivqilXUmlpLKWoelKwRCFptaQDkl6K2Xa7JJM0Pfj7cklbJG0P/r0ssu8FQfouSd+Usq1ckiZLWhukb5bUETlmsaRXgsfiirzjBN29fVyychOzl64fcafinBsp7rdSjXEGYfXS5InJl6nBIeP7m/fk7YJbiR5LSbPHJqU3mmKqnh4FrshNlDQLuBzYE0n+I3CVmc0DFgOPR7Z9C7gVOCd4hOe8BThsZmcDDwD3B+c/BVgOXARcCCyXNK3YN1aKsU4Y5lyzSPqtrP/NGxV/ramtGZY9tX3EYL04MTFiWNheMVY3XTSrpPRGUzBQmNkzwKGYTQ8AX4YT1X5m1mtm+4M/dwAnBSWG04H3mdmvzcyAx4CuYL9rgO8Gz58EPh6UNhYBG83skJkdBjYSE7AqodieFc41u6TfyuEj+S/mpcq0CIkxVxmFjdr5emYV496ueXzm4jOHSxAtEp+5+MymaMiGMtsoJF0N9JnZNiUXvT4N9JrZu5LagX2RbfuAcMRMO7AXwMyOSXoTODWaHnNMRY11wjDnmsV4/CbCXk9fLDC2IdSamcCxIRtV/ZRp0XDPp9xeS+W4t2te0wSGXCX3epI0BbgDuCvPPnPJViH9XZgUs5sV2JbvmNzXu1VSj6SegwdLH2pfymAd55rZePwmrvzI6XQtaC/qtSYA9137EVZdfx5trZkR2waHsl1uF9z9izFVjbU0RzNEXuV0jz0LmA1sk7QbmAm8KOn9AJJmAj8BPmdmrwbH7Av2C80E9ke2zQqOnQhMJVvVNZwec8wIZvawmXWaWeeMGaU3qo11wjDnmsWSRXPITKjulfN7z+3JTia4aE7s3WJUS3AV71rQztblC3nwhvmj8nf4yOCYqsaGmqNjU14lBwoz225mp5lZh5l1kL2gn29mv5fUBqwHlpnZs5Fj3gDeknRx0P7wOeCnweZ1ZBu+Aa4DNgXtGBuAhZKmBY3YC4O0ihvrhGHONYuuBe2856Tq9qo3YMW6HXQtaC847iE6uWB3bx9f+uG22B5QbmwK/o9LWgN8DJguaR+w3MweSdj9C8DZwJ2S7gzSFprZAeDzZHtQtQI/Dx4AjwCPS9pFtiRxI4CZHZJ0D/BCsN/dZhbXqF4R0QnDnHPJ+ivccB37GgODfKV7OyKhvjlif//AcG+sZhnXMN5kDfbBdnZ2Wk9PT62z4VzDumTlpooOrhur9qAto1p5OnlSCzvurkqHy1SRtMXMOuO2+RQezrmSVKK7aaWEbYnV7I11RttJVTt3vfBA4ZwrSdeCdj59QXvBhubxcFImewmrZm+sVw68XbVz1wsPFM65kq3/zRtlT7BXSYePDLLsqe1ceu6M1JRyGpFPCuicSxS3uhxQ8ZHYYzEwOMQTz+2hrTWDMI4MHq91lhqOBwrnXKywJ1E4jUY4r1NY3ZM2heaEKpcPuPNA4ZxLkDSv01jnX6o3PuDO2yiccwl8rjMX8kDhnIvlc51ltaa0qm08+ScQ8IWLnBspTeMlaukk/wy8jQKSG+0An9bDNa3wu79qw076+geKmk6jEaWph1eteIkCX7jIuSRdC9p5dulltLe1NmWQgOZZ7jQfDxQkzxGTpvlsnKuV7t6+pv4t+ESDXvXknCN+YF3XgvbhatlmVuXlN+qCBwrnmly+Nrq4atlm48tbeNUTEL/mar505xpJvjY6H0vhwAMFAFMmxXd/S0p3rpEkBYP9/QO0TcnEbnPNxQMFcORofNH67YR05xpJ0sC6qa0Z/vTOsXHOTfp4G4UHCiD/yEsfeOcaXdzAutZMCxK+/jTwXy46s9ZZqDkPFJB3WmIfS+EaXdeCdu67dh7tba2I7NKi9107zweaBe7tmlfrLNScB4oCvDHPNbrcrrGXnjuDFet21DpbqeG1Ch4oCvKJ0VwjC7vG9vUPYGS7xj7x3J6qre1Qj7xWoYhAIWm1pAOSXorZdrskkzQ9+PtUSU9L+pOkh3L2/ZWknZK2Bo/TgvTJktZK2iVps6SOyDGLJb0SPBaP+d2W4dJzZ9TiZZ0bFz5OojCvVSiuRPEocEVuoqRZwOXAnkjyO8CdwO0J57rZzOYHjwNB2i3AYTM7G3gAuD84/ynAcuAi4EJguaRpReS3op5++eB4v6Rz48YvgoV5rUIRgcLMngEOxWx6APgykQklzextM/t3sgGjWNcA3w2ePwl8XJKARcBGMztkZoeBjcQErGpr5jluXOPzi2BhXqtQZhuFpKuBPjPbVuKh3wmqne4MggFAO7AXwMyOAW8Cp0bTA/uCtLj83CqpR1LPwYOVLQH4xJGukfmaE4V5rUIZgULSFOAO4K4SD73ZzOYBHw0enw1PGbOv5UkfnWj2sJl1mlnnjBmVjf4+caRrZNGusS6eV8+VV6I4C5gNbJO0G5gJvCjp/fkOMrO+4N+3gO+TbXeAbElhFoCkicBUslVdw+mBmcD+MvLrnMuja0G7V6/k4dVzZQQKM9tuZqeZWYeZdZC9oJ9vZr9POkbSxEjPqAzwSSDsRbUOCHs0XQdsMjMDNgALJU0LGrEXBmnjzvtRu0bW3dvH957bU3jHJrVk0ZxaZ6HmCk4zLmkN8DFguqR9wHIzeyTP/ruB9wGTJHWRvcC/DmwIgkQL8Evg28EhjwCPS9pFtiRxI4CZHZJ0D/BCsN/dZhbXqF51qzbs9CVRXUFJazpUat++/gFaJIbMaC9wTClWbdjZtKvXFcN/+yBrsEr4zs5O6+npKemYjqXr824X8NrKK8eQK5cr7uLX1ppBgv4jgwUvnmmTu6YDZL83N1985qgpIOL2bc20cN+184YXCwqDyNTWDG8fPcbg0OjfabiGdW7QyLcIUVz67KXrPVDksbtJfvuStphZZ9w2X7ioCF5HWVm5F8pwqcnoaOC+/gGW/GgbX/3ZjroIHHED1wx4IqjSiQaLQmu0Rz+bfCOkw4t7dKGh3OPDbT2vH+LHW/piFyc6o63Vu4Hn0d3bl9rv3XjxKTyK4HWUlVXsaODB48bhI4PDU0sse2p7atuL8vWM+d5ze0bkO+mivL9/oOyR0mGgSQpCazbvTQxO3kU2P5/Cw0sUrgbK7W4YXtjSeHfXNiWTONuqAV/64Ta+uHYrU1uTFwKaII3pzj7f5zqUUMW8v39g+PO8be3Wsl+7kXn3WA8URUnrxakedff2MSFokyhH3I+2u7ePFet2DFfTTJuSYflVcwGq2rgc7ttxamvBKbnjqteS9ilXOUdPkJi9dL1Xr+bhK116oCiK31FURtg2MZYLYu4Frbu3jyU/2jZigZ3DRwZH3R1H6+RzA0Bum0lf/wBfXLuVntcPFWyI7usfqOv6/fD/op7fQ7UlrYDZTLyNogi+bnBlFFP/LmV787S1Zsi0jByc35ppGdVetGrDzqJXYYs2GBfKlzG6baHY9+Aai/cI8xJFURqsB3FNdPf2FXXXapbt7jncNfTdQcIFCN89NkTP64dGlAhKLe3t7x8YVXWUlC9jdLWjly6bj6+Z7YGiKG/6Ii4l+Ur3dtZs3lt2FVN44c6tzz9u2e6mT4xhFPHU1syoqqNCeYl2j/SupM1n8kSvePFPoAj5eqq4kb7SvZ0nntsz5obZasi0CImSq45uW7uVBXf/ItsesmiO/2iazDthkbaJ+Xe+CD7VePHWbN5beKcaOXnSRPoL9E5KcvjI4HBjePpCoKsm7xHmgaIohbo+uqzu3r5UliRCbw4MjulHPzA4xG1rt3qgaDI+4NYDRdHSOiI4LcJuo2k2tTXj02m7kvkYKg8URfvqz3bUOgupVg/dRvsHBsfUEO6ak98keqAomlc/5ec9gVyj8rmePFC4CmnxFn/XoHzsjAcKVwFpb8R2biy815MPuCtaa8Zjaq7sPEtb8W7mrpF5rycvURTt2HHzRq2I7t4+/mmtBwnX+LzXkweKog0OmTdqRazasBOPEc41Bw8UJfBGrRO8l5NzzaNgoJC0WtIBSS/FbLtdkkmaHvx9qqSnJf1J0kM5+14gabukXZK+KWW7yUiaLGltkL5ZUkfkmMWSXgkei8f8bsfIG7VO8F5OzjWPYkoUjwJX5CZKmgVcDkRHML0D3AncHnOebwG3AucEj/CctwCHzexs4AHg/uD8pwDLgYuAC4HlkqYVkd+q8VG9J3gvJ+eaR8FAYWbPAIdiNj0AfJnIHGlm9raZ/TvZgDFM0unA+8zs12ZmwGNAV7D5GuC7wfMngY8HpY1FwEYzO2Rmh4GNxASs8fTEc3u4ZOUmb9TGSxTONZOy2igkXQ30mdm2Ig9pB/ZF/t4XpIXb9gKY2THgTeDUaHrMMbn5uVVSj6SegwcPFv0+yhEuqdnswcJLFM41j5IDhaQpwB3AXaUcFpNmBbblO2ZkotnDZtZpZp0zZlS/eihpSc1m0u7tNc41jXJKFGcBs4FtknYDM4EXJb0/zzH7gv1CM4H9kW2zACRNBKaSreoaTo85puaavQeUL+DjXPMo+bduZtvN7DQz6zCzDrIX9PPN7Pd5jnkDeEvSxUH7w+eAnwab1wFhj6brgE1BO8YGYKGkaUEj9sIgLRWavQdU14J2pk7xlf+cawYFp/CQtAb4GDBd0j5guZk9kmf/3cD7gEmSuoCFZvZb4PNke1C1Aj8PHgCPAI9L2kW2JHEjgJkdknQP8EKw391mFteoPu5aMy0+rB+fUde5ZlEwUJjZTQW2d+T7O5LeA3w4Jv0d4PqEY1YDqwvlcTxNm5Jh+VVzm35Yf7M35jvXTLyauURTJk1s+iABPke/c83EA0WJmr0RO+RTeDjXPDxQlKjNG3Cdc03GA0WJfJyZc67ZeKAo0ZsD3tMHYILP4OFc0/BAUaJmHz8ROu4lK+eahi+FSnY6imIaZzMt4tJzZ3DJyk3s7x/gjLZWliya472gnHMNzUsUFD99+OCQsfaFvfT1D2D4BIHONbpLzjql1llIBQ8UwNMvFz/j7ODQyDqXZpwg0AOjaxbXd55Z6yykggcKxj4moNnGVqxYt6PWWXBuXDTbTWASDxSMvQdPszVw93vPL9ckmu0mMIkHCsbWg8cnCHSucU30KyTggWJM2ttaue/aeU3X62maj053TWLweK1zkA7ePRZozUxgoMRvRHtbK88uvaxKOUq3D53+Xp59NRUzvjvnxoGXKICTMi0lH9PM1U3P/cfhWmfBOTeOPFAA/SUuwNPS5PNXDPmEV65JnHPaybXOQip4oKD0GWGHjpt3m3OuCRw56o0U4IECKG9GWF+PwbnG591jszxQUN6MsC1q7uon55pBs42RSuKBAjgpU/rH4PX0zjW2TIuautNKVMErpKTVkg5Ieilm2+2STNL0SNoySbsk7ZS0KJL+qyBta/A4LUifLGltcMxmSR2RYxZLeiV4LB7zu03w7rHS6yHbWn0sgXONatqUDKuuO6/pxkglKWYcxaPAQ8Bj0URJs4DLgT2RtA8BNwJzgTOAX0r6czMbCna52cx6cs5/C3DYzM6WdCNwP3CDpFOA5UAnYMAWSevMrOJ9M8sZmd3MNU+ZCT4QyZVm2pQMh0vsXVgLzTw+Kp+CJQozewaIG131APBlshfx0DXAD8zsXTN7DdgFXFjgJa4Bvhs8fxL4uCQBi4CNZnYoCA4bgSsK5bcc5bQ3HD4y2LSzqHqQcKWqhyAB3nidpKw2CklXA31mti1nUzuwN/L3viAt9J2g2unOIBiMOMbMjgFvAqcWca5ofm6V1COp5+DB4qcMD9100aySjwF8LQo3Ju1trTx4w/xaZ8NFeON1vJIDhaQpwB3AXXGbY9LCEsfNZjYP+Gjw+GyBY/Kda2Si2cNm1mlmnTNmFLcIUdS9XfOY1FJ6qaIZ16JwleFVHOnUf+So3/zFKKdEcRYwG9gmaTcwE3hR0vvJ3vVHb89nAvsBzKwv+Pct4PucqJIaPkbSRGAq2aquxHNVw8mTy5v2youqrhyXnjuDr3Rv54trt9Y6K+OmrTWT+k4gbx8d8pqCGCUHCjPbbmanmVmHmXWQvaCfb2a/B9YBNwY9mWYD5wDPS5oY9oySlAE+CYS9qNYBYY+m64BNZmbABmChpGmSpgELg7SqKHUaj9DUlH/xXTr987Y3+N5ze+KLyA2oNdPCiqvnln1DNp68pmC0gv9rktYAHwOmS9oHLDezR+L2NbMdkn4I/BY4BvyjmQ1JOhnYEASJFuCXwLeDwx4BHpe0i2xJ4sbgXIck3QO8EOx3t5lVbcrSM9payxpt/fbRY8N3H6s27GR//wBntLWyZNEc71rnEjXD4k8tEkNmtEd+D/VSgvKagpEKBgozu6nA9o6cv78GfC0n7W3ggoTj3wGuT9i2GlhdKI+VsGTRHG4r40s8OGSsWLeDd48dZ2Aw2wu4r3+AZU9tB/Bg4aqiva2VS8+dwdMvH6Svf2D4opwGLRPE16+PH4OQdEOWpvyDN2rn8pHZgbFc0PsHBoeDRMiLr6Vra800xReyNdPCyZNKn9o+PPbBG+bz7NLLuLdrHs8uvYwHb5jP+6eeVOFclu+mC2cl/p6WLJpDa860/iLb83D3yit58Ib5NW/H8FUrR2uG32XNePE1We5U7WEd9jdumE9rGVOq1ItpUzLcd+08Mi2lv8cWadSKit29fSx5cluqJql8+uXkLupdC9r59AXtI7o0GvDjLX109/bRtaCdrcsXsnvllVXPZ5xmXbWykPS3LI0jkdD/tkxefE323skTOXnyxNg2ndwL4Yp1OwrW6V9y1impX3XvwRvmD7+3curqj5uNuoB99Wc7GBxK/tZOUDYo59un0grdID398sFRv7OwBB59f+1lthuWy7ssJ2vcW7cynPbeSRU7l08olt+bA4M8u/QyXlt5Jc8uvSzxDq5rQXtRPWW+97d/UeksVlR7W+uI91jOTUTcMflGPLe3tfKNv5nPquvOK/m1xmKCxOyl67lk5abYbqZJgSQ3Pa6aqlpEc69aWYgHiog/vHW0cidLT7tcKpVyoSx0h9oenKvWddv55F6ESr0IllNvHgbg8a5GGTLDONGpIzdYJP3f56Z3LWjnvmvnDf//hlPtVHqaNQE3X3ymVzfl4YGiSgZ9FbxEpV708gWV6Lk+ed7pY85bkrGsP9LWmhl1Ecq9CCa9pshfb54UHHPTxyOIxq0QHNepIy5IJn0nuha08+zSy9i98kpeve8T7F55JQ9UcNqTaVMyPHDDfO7tmlexczYiDxRVlO9OuLu3j0tWbspbRG9UpTYWJt19hw3D4bnyNaKORWumhZsumpV4J9vWmhnusRN3AVxx9dzY48KLYNJxX/+b8wpWza24ei6ZnCt0ZoJGvWbcfpUkkleKzP0dRINkoUAYFf5mKjkWY8qkiV6SKII3ZldR0p1wd28fy57a3pTjLnLr6osR7l9oQGM1eplNm5Jh+VVz6VrQzhPP7YndJ1whsdh85ir3uFKOje5XjQbi8Lsed+6430GpVWK5v5lK8Z6JxfFAUSX5qldWbdiZOO6i0QNFuQ2GxVxYyh1dn0/vXQuHnyf1woleCMttExhLW0Kxx0b361i6vqzXihP9rudezCsxJqG7t48v/XBbVQbktU1Jb7tWmnjVU5XkK0oX2+sjjcZSRRZXV19Jle4lk1uvX0rdetqVO+AvTvhdL7dKKZ+wJFGtUdspGgyeal6iqIJC1StJd771MO6i3Ab6fHX1lZJbvTKWcTFx9fxjqSJKmyNHK1OFk/tdr3Qvq7jSdyW92QRzblWCB4oq6D9ylNlL1ydeSJYsmlOVIvp4KLXUIxjXC2r0QtXd2zd8UZ/amkkctCfggRvmFxUAatHdtBoqUU03Ht/ZSpWyk24a6uHmLA08UEScPKmFtytwpxWeI6mRup7vTPNdcOO8VqOpGODERT2s405yRnBXXA+ff6XE3azkylciO3lSC1/7VPWnumirwFrbEtx80Zn8eEtfXd6cpYEHiojjVaiwTGqkrtcL05/ePVb0vmMZe1BItLSQL9AWU8fdjBeLQr2gwkDw1Z/tiL1Qt02ZNC7f36T/Nqn49gWz7CqWnR84pS5vztLAA0XEwODxqpy3Hhqpi3XsePHBtNy1yAsppXtxoTruajewp1kxNytJYxbG6zud1IZQzj1dvd6cpYEHinHQjKvgZSZQtdGupXQvzndBG48G9jRLKpVF0yckrBMxXt/ppLaU9rZWjhw9VlS11DTvAjtm3j02olpfqP6BQebe9a9NNfq6SoUzoLTuxUmNlXFTdjeTsFTW1z8wPC/Tkh9t40N3/pzb1m4dTk+qsouu7FhN+bokL79qbsHu0JkWsfyq5r0ZqBQvUUQsv2puWavcFePto0MsefJEg6rXlZavlO7FST3MmjlIQHypbPC4MVhk1eLgkI3LANFiOn6E7SzhKnlxS7C6sfFAEdG1oL1qgQKab9nUcCGaSiule3E99zCrpkq0MYxXO0W+tgVvdxgfHijGWVzX0kadvuOrP9tRlfdU6sXfLyajVWIcRT20vRXbO87l54Eix5+9d1Jl16UoUl//AJes3NRQX+Sx9n/Pxy/+Y1PMOIpQZkK2Kie3Vipsp0jr/0MzT75ZaQUbsyWtlnRA0ksx226XZJKmR9KWSdolaaekRZH0CyRtD7Z9U8p2spc0WdLaIH2zpI7IMYslvRI8Fo/53RbQ3dvHgRoEiVDSQi/OVVruvExtrRkyLaPHvUybkmHV9efFlh7Cdoq0ytc7zpWmmBLFo8BDwGPRREmzgMuBPZG0DwE3AnOBM4BfSvpzMxsCvgXcCjwH/AtwBfBz4BbgsJmdLelG4H7gBkmnAMuBTrIDRLdIWmdmh8t/u/mt2rCz5gvT5VZD1XPROc0rzrnRpbJ837Vaj6coRz1Pvpk2BQOFmT0TvcuPeAD4MvDTSNo1wA/M7F3gNUm7gAsl7QbeZ2a/BpD0GNBFNlBcA6wIjn8SeCgobSwCNprZoeCYjWSDy5rS3mLxxnMh93zCL3KxRedSRikXG3S6e/tYsW7HcJtKuC5DseIm1XPplq86rx4nsqzHPKdVWeMoJF0N9JlZ7gQ67cDeyN/7grT24Hlu+ohjzOwY8CZwap5zxeXnVkk9knoOHix/lbNqTjlRijPaWofnJypUdI7rDx9XfVXsfuG+S360bUTD++EjgyO69yYJp5dedf15dVPycYXV4xTr9ZjntCq5MVvSFOAOYGHc5pg0y5Ne7jEjE80eBh4G6OzsLLv2qFpz3peiZYK49NwZeecnihadix2lXMpo5lUbdsb2px8cKvz51HISQFc99djNuB7znFbl9Ho6C5gNbAvao2cCL0q6kOxdf3SCn5nA/iB9Zkw6kWP2SZoITAUOBekfyznmV2Xkt2hJK5iNp6HjlrjkZigsOnf39iXmN7cetpT6Wq/DdXHqsadZPeY5jUquejKz7WZ2mpl1mFkH2Qv6+Wb2e2AdcGPQk2k2cA7wvJm9Abwl6eKg/eFznGjbWAeEPZquAzaZmQEbgIWSpkmaRrYEs6H8t1pYPRRJw6JzWJWUJLceNqleNi7d63Cdc1EFSxSS1pC9s58uaR+w3MweidvXzHZI+iHwW+AY8I9BjyeAz5PtQdVKthH750H6I8DjQcP3IbK9pjCzQ5LuAV4I9rs7bNiulmqPzB4rcWLZyUtWbsrbB76vf6CodZFz95uSmcDgUBUnanKuyuq5p2BaFdPr6aYC2zty/v4a8LWY/XqAD8ekvwNcn3Du1cDqQnmspJaE2TLTwICe1w/RtaC9alVkR6o5m59zVeaD7KrDZ4/NkdYgEVqzeW/hnZxrUj7Irjo8UORoT3n9fNoDmXO15IPsqsMDRY4li+bE9stNk2LaHpxrRqV02nDF80CRo2tBOzdffGats+GcK4MPsqsODxQxqrWEp3OuunInO2xva236RaoqwacZdxXjaxO7NPBBdpXnJYoYPs13eXxtYucakweKHIVGPLtkfhfnXGPyQJEjrh+2c841Mw8UOby/tXPOjeSBIof3t3bOuZE8UOSI64ftnHPNzANFjrAfdtpHZzvn3HjxQBHDe+8459wJHigSeFuFc85leaBI4HPDOOdclgeKBF795JxzWR4o8kj72hTOOTcePFDk4V1lnXPOZ4/NK6x+WrVhZ9XWqG4UXvpyrnEVLFFIWi3pgKSXImn3SPqNpK2SfiHpjCB9kqTvSNouaZukj0WO+ZWkncExWyWdFqRPlrRW0i5JmyV1RI5ZLOmV4LG4gu+7aF0L2nl26WV8xhczyssb/51rXMVUPT0KXJGTtsrMPmJm84F/Bu4K0v8WwMzmAZcDX5cUfY2bzWx+8DgQpN0CHDazs4EHgPsBJJ0CLAcuAi4ElkuaVuL7q5h7u+Z5sEjw4A3zvfHfuQZWsOrJzJ6J3uUHaf8v8ufJgAXPPwT8W7DPAUn9QCfwfJ6XuAZYETx/EnhIkoBFwEYzOwQgaSPZgLWmUJ6r5d6ueb76nXOu6ZTdmC3pa5L2AjdzokSxDbhG0kRJs4ELgFmRw74TVDvdGQQDgHZgL4CZHQPeBE6Npgf2BWlxeblVUo+knoMHD5b7lpxzzsUoO1CY2R1mNgv4HvCFIHk12Qt6D/Ag8L+BY8G2m4MqqY8Gj88G6XHTKlme9Li8PGxmnWbWOWPGjDLejXPOuSSV6B77feDTkC0RmNkXgzaIa4A24JVgW1/w71vBMRcGx+8jKHVImghMBQ5F0wMzgf0VyK9zzrkSlBUoJJ0T+fNq4OUgfYqkk4PnlwPHzOy3QVXU9CA9A3wSCHtRrQPCHk3XAZvMzIANwEJJ04JG7IVBmnPOuXFUsDFb0hrgY8B0SfvI9kT6hKQ5wHHgdeDvg91PAzZIOg70caJ6aXKQngFagF8C3w62PQI8LmkX2ZLEjQBmdkjSPcALwX53hw3bzjnnxo+yN++NQ9JBssGrXNOBP1YoO9VUL/mE+slrveQT6iev9ZJPqJ+8ViufHzCz2EbehgsUYyWpx8w6a52PQuoln1A/ea2XfEL95LVe8gn1k9da5NPnenLOOZeXBwrnnHN5eaAY7eFaZ6BI9ZJPqJ+81ks+oX7yWi/5hPrJ67jn09sonHPO5eUlCuecc3l5oHDOOZeXB4qApCuC9TJ2SVpaozzsDtby2CqpJ0g7RdLGYE2OjdGp1iUtC/K7U9KiSPoFwXl2SfpmZALGseQtbl2SiuUt37okFcjnCkl9kbVQPpGCfM6S9LSk30naIem/Bulp/EyT8pqqz1XSSZKeV3YtnB2Svhqkp/EzTcprqj7TYWbW9A+yo8VfBT4ITCI7C+6HapCP3cD0nLT/DiwNni8F7g+efyjI52RgdpD/lmDb88BfkJ1Y8efAX1cgb38FnA+8VI28Af8A/I/g+Y3A2grmcwVwe8y+tczn6cD5wfP3Av8nyE8aP9OkvKbqcw3O+Z7geQbYDFyc0s80Ka+p+kzDh5cosi4EdpnZf5jZUeAHZNfJSINrgO8Gz78LdEXSf2Bm75rZa8Au4EJJpwPvM7NfW/Yb8ljkmLKZ2TNkp1ipVt6i53oS+Hh4Z1SBfCapZT7fMLMXg+dvAb8jO41+Gj/TpLwmqUleLetPwZ+Z4GGk8zNNymuSmuUVvOopVPTaF1VmwC8kbZF0a5D2Z2b2BmR/sGTn04LkPLcHz3PTq6GSeUtal6RSvqDs8r2rI1UPqchnUCWwgOxdZao/05y8Qso+V0ktkrYCB8gufJbazzQhr5CyzxQ8UISKXvuiyi4xs/OBvwb+UdJf5dl3zOt4VFE5eatmvr8FnAXMB94Avl7gNcctn5LeA/wYuM1Grhw5ateE161lXlP3uZrZkGWXaJ5J9o77w3l2r+lnmpDX1H2m4IEilIq1L8xsf/DvAeAnZKvE/hAULwn+DdcaT8rzvuB5bno1VDJvSeuSjJmZ/SH4UR4nO2vxqLVQapFPZWdT/jHwPTN7KkhO5Wcal9e0fq5B3vqBX5FdPjmVn2lcXtP6mXqgyHoBOEfSbEmTyDb8rBvPDEg6WdJ7w+dk1994iZHrdSwGfho8XwfcGPRsmA2cAzwfFK3fknRxUB/5ucgxlVbJvCWtSzJm4UUi8ClGroVSk3wG530E+J2ZfSOyKXWfaVJe0/a5SpohqS143gr8Z7Jr5aTxM43Na9o+02HltoI32gP4BNneHK8Cd9Tg9T9ItlfDNmBHmAeydYr/RnalwH8DTokcc0eQ351EejYBncEX7FXgIYIR+GPM3xqyReFBsncqt1Qyb8BJwI/INtI9D3ywgvl8HNgO/Cb48Zyegnz+JdlqgN8AW4PHJ1L6mSblNVWfK/ARoDfIz0vAXZX+DVXwM03Ka6o+0/DhU3g455zLy6uenHPO5eWBwjnnXF4eKJxzzuXlgcI551xeHiicc87l5YHCOedcXh4onHPO5fX/AbjnGxg9dn+KAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "83 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838,\n", + " 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838,\n", + " 3.3838, 3.3838, 2.8062, 2.2362, 1.6718, 1.1117, 0.5546]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9954, 0.9976, 0.9987, 0.9983, 0.9955, 0.9965, 0.9974, 0.9949, 0.9983,\n", + " 0.9985, 0.9969, 0.9973, 0.9983, 0.9974, 0.9981, 0.9973, 0.9980, 0.9978,\n", + " 0.9970, 0.9990, 0.9992, 0.9999, 0.9998, 1.0000, 0.9993],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0798, 0.0802, 0.0730, 0.0602, 0.0431, 0.0230])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAt/0lEQVR4nO3dfZBV9Z3n8feH5oINGWkQnGiDaaKOqRCiaI8y5WTLmBWcmGiPMaNZTdgqa53JTKo2cSQFZRSfsuJSGVMpq7JrRmPMAyExpkOWyRAymLLGVbQREJmEEUcEGhPIQLuOdKRpvvvHORdO3z7n3Ie+D6fv/b6qbvXt33no37197/me37PMDOeccy7JhEZnwDnnXLZ5oHDOOZfKA4VzzrlUHiicc86l8kDhnHMu1cRGZ6DaZs6caV1dXY3OhnPOjSubN2/+nZnNitvWdIGiq6uLvr6+RmfDOefGFUmvJ23zqifnnHOpPFA455xL5YHCOedcqqKBQtKjkg5Iejlm222STNLM8PeLJW0NH9sk/Xlk34skbZe0S9LXJClMnyxpTZi+SVJX5Jglkl4JH0uq8oqdc86VpZQSxWPAlYWJkuYAVwB7IskvA91mdkF4zP+WlG8w/zpwC3Bu+Mif82bgsJmdAzwIPBCefwawArgEuBhYIWl6Ga/NOedcFRTt9WRmT0fv8iMeBL4I/CSy75HI9lMAA5B0BnCqmT0b/v440AP8DLgGuCs85gngobC0sRjYYGaHwmM2EASX1SW/OuecK1Hvln4+v2Zro7NRNbtXXlW1c1XURiHpaqDfzLbFbLtE0g5gO/BXZnYM6AT2RXbbF6YR/twLEO77JnBaND3mmMK/eYukPkl9Bw8erOQlOedaWLMFCYCuZeuqdq6yA4WkKcDtwJ1x281sk5nNA/4YWC7pFEBxu+ZPmbAt7ZjCv/mwmXWbWfesWbHjRZxzLtGq9TsbnYVMq6REcTYwF9gmaTcwG3hR0rujO5nZr4C3gQ8QlAZmRzbPBvaHz/cBcwDC9oxpwKFoeswxzjlXNfsHBhudhUwrO1CY2XYzO93Musysi+CCfqGZ/UbS3HzjtaT3AOcBu83sDeAtSQvD9ofPcLJtYy2Q79F0HbDRgtWU1gOLJE0PG7EXhWnOOVdVZ3a0NzoLmVZK99jVwLPAeZL2Sbo5Zfc/JShpbAV+DPy1mf0u3PZZ4O+BXcCrBA3ZAI8Ap0naBdwKLAMIG7HvBV4IH/fkG7adc66ali4+r9FZyDQ121Ko3d3d5nM9OefKVc3G3yyYOqmNHfeMGtmQSNJmM+uO2+Yjs51zrgm9fXS4aufyQOGccy6VBwrnnGtCceMLKuWBwjnnmtCNC8+q2rk8UDjnXBO6r2d+1c7lgcI551wqDxTOOedSeaBwzrW8L/Vub3QWqurc06dW9XweKJxzLW/1pr3Fdxonzj19Khtuvayq5yy6HoVzzjW74XE+Q4WA16q4/kQhL1E451pem6o56qD+aj2poQcK51zLe++sKY3OQklyE0SubWRQa8+11XxSQw8UzrmW928HjxTfqc6mT8lx08Kz6OxoR0BnRzurPnk+q647f0Ta/dfOp2dB7OKfVeNtFM65lpeVNopS17mudWAo5CUK51zLy0obRe+W/kZnIZYHCudcy8tKG8XyJ7dnMlh4oHDOtbxXD77d6CwAMDg0zKr1OxudjVE8UDjnWt7xOjdRiORpwPcPDNYzKyXxQOGcc3VmJI99qPWYiEp4oHDOtbx6XwgFLF18Hu25thHp9RgTUYmi74+kRyUdkPRyzLbbJJmkmeHvV0jaLGl7+PPyyL6/lLRT0tbwcXqYPlnSGkm7JG2S1BU5ZomkV8LHkqq8YuecK2B17vQ0YULwB++/dn7dx0RUopRxFI8BDwGPRxMlzQGuAPZEkn8HfNzM9kv6ALAeiL7qG82sr+D8NwOHzewcSTcADwDXS5oBrAC6CUpqmyWtNbPDJb8655wrQb2HUQwfN1at38kzyy7PZGAoVLREYWZPA4diNj0IfJHgIp7fd4uZ7Q9/3QGcImlykT9xDfCt8PkTwEckCVgMbDCzQ2Fw2ABcWSy/zjk3HmSx0TpJRVVzkq4G+s1sW8punwC2mNk7kbRvhtVOd4TBAIISx14AMzsGvAmcFk0P7WNk6SSan1sk9UnqO3jwYCUvyTnn6iqLjdZJyg4UkqYAtwN3puwzj6AK6S8jyTea2XzgQ+Hj0/ndY05hKemjE80eNrNuM+ueNWtW8RfhnHM1IBg1aV+jJvKrpkpKFGcDc4FtknYDs4EXJb0bQNJs4MfAZ8zs1fxBZtYf/nwL+B5wcbhpHzAnPHYiMI2gqutEemg2sB/nnKuyCVVozJ46qY0Hr79g1KR9jZrIr5rKnhTQzLYDp+d/D4NFt5n9TlIHsA5YbmbPRPaZCHSE++SAjwG/CDevBZYAzwLXARvNzCStB/6HpOnhfouA5eXm1znnivmT987gmVfjmmJLUziZX1wQGE+BoVAp3WNXE1zEz5O0T9LNKbt/DjgHuKOgG+xkYL2kl4CtQD/wjfCYR4DTJO0CbgWWAZjZIeBe4IXwcU+Y5pwbp3q39HPpyo3MXbaOS1duzMy8Rrv/fWwNy1l5HbUiy8j0utXS3d1tfX2FPXCdc43Wu6Wf5U9uZ3Bo+ERae64tE9UwXcvWjen4rLyOsZC02cy647b5yGznXF2sWr9zRJCA7E6CV65meR1JPFA45+oiadzAeBpPkKZZXkccDxTOuboYT5PgVaJZXkccDxTOuboYT5PglatZXkcSXzPbOVcX+YbeVet3sn9gkDM72lm6+Lxx2wDcJnHcbNy/jlJ4oHDO1U3Pgs6muaAeN+O1gvETzcqrnpxzrgLN3CZRyEsUzrmm17ulf0xVXu25tlHjP5q5TaKQlyicc00tP9Cvf2AQA/oHBln+5PayRlN/4qLOcT1X01h5icI519TSBvqVerF/6tcHeWbZ5cV3bFJeonDONbVqDPRr5sF0pfAShXNuTNLq/3u39HPX2h0MDA4BMH1KjhUfn1f1apu0PJzZ0U5/zIW+nMboVmq4juOBwjlXscKJ/vL1/3lLf7iNoeMnJx49fGSIpU8EC2NWK1ik5aFnQSdLF58XOxlhqY3RgpZquI7jVU/OuYql1f+vWr9zRJDIGxq2qk6gV2yywZ4Fndx/7fwxNUa3UsN1HC9ROOcqVmn9f6l1/qV0ay0lD4UD/fLrYuTPm6a5FmKojJconHMVS7rIGjBByeuLGsEaEPPu/MfEbqqldmstd7LBuPOmaUt5Ha3CA4VzrmJLF59HLmHB6eESFkV7++gwf/vDbbHBotT1K8qdbDDuvGk+dckcvtS7nbOX/wNdy9Zx9vJ/4Eu924sf2ES86sk5V7GeBZ3c/dMdHD4yVPE5ho8bX1izlc+v2Qqc7BlVarVWKZMNRquwKqlK+s5ze07m1+zE7/f1zK/gbOOPlyicc2MyMIYgkRe9eOd7RnVMySXuG11vO98FN1+VdOTosRH7F1Y1lWv1pr1lpTcjL1E458YkaZzCWAwNG2aj51jK6x8YZOkT2+h7/RBrnt+b2gW33KqmQklVaKVUrTWLoiUKSY9KOiDp5Zhtt0kySTPD36+QtFnS9vDn5ZF9LwrTd0n6mhS0EEmaLGlNmL5JUlfkmCWSXgkfS6ryihPke0HMXbZuxN2Kc+6kuO/Jh983qyZ/683BIT5xUWdiY/LQsPG9TXuKdsEd66jqpL/fSo3cpVQ9PQZcWZgoaQ5wBbAnkvw74ONmNh9YAnw7su3rwC3AueEjf86bgcNmdg7wIPBAeP4ZwArgEuBiYIWk6aW+sHJUY9Iw55pd0vdk3Utv1OTvTWvP8aPN/al37jEx4oR8gBjrqOpPXTKnrPRmVDRQmNnTwKGYTQ8CXyRSvWhmW8xsf/jrDuCUsMRwBnCqmT1rZgY8DvSE+10DfCt8/gTwkbC0sRjYYGaHzOwwsIGYgFUNpfaucK6VJX1PxtKQnSTXJiTGVGWUDxBxvaLKcV/PfG5aeNaJEkSbxE0Lz2qZhmyosI1C0tVAv5ltU3Lx6xPAFjN7R1InsC+ybR+Q75LQCewFMLNjkt4EToumxxxTVdWYNMy5Zlev70O+19MXwl5QadpzEzg2bKOqn3JtOtE9tmdBJ32vHxrRc6lc9/XMb6nAUKjsXk+SpgC3A3em7DOPoArpL/NJMbtZkW1pxxT+vVsk9UnqO3jwYFK2EpU7YMe5VlSv78NVHzyDngWdTGuP7/WUNwG4/9oPsuqT59MR2Tc3Iehy+/k1W0+MeXjq1+VfFwDaWqcZIlUl3WPPBuYC2yTtBmYDL0p6N4Ck2cCPgc+Y2avhMfvC/fJmA/sj2+aEx04EphFUdZ1IjzlmBDN72My6zax71qzyG9bKHbDjXCtKG1xXTd99bg+9W/op1lasMC89CzrZumIRu1dexU0Lz2Lo+Mm2i/yYh0p7ZQ23TsemVGUHCjPbbmanm1mXmXURXNAvNLPfSOoA1gHLzeyZyDFvAG9JWhi2P3wG+Em4eS1BwzfAdcDGsB1jPbBI0vSwEXtRmFZ11Zg0zLlm17Ogk3edUvse9UbQHlJsfMbw8ZM9m/K9scZSveSSFf2vS1oNXAbMlLQPWGFmjyTs/jngHOAOSXeEaYvM7ADwWYIeVO3Az8IHwCPAtyXtIihJ3ABgZock3Qu8EO53j5nFNapXReGkYc650aoxuK4U/QODTJ3UxttH0xuz9w8Mjppm3FWfrMkGjXR3d1tfX1+js+FcU7p05caqD64bi86w3aRWeZo6qY0d99Sks2XmSNpsZt1x23wKD+dcycba1bSa8j2batkb612Ts/FaG80DhXOuZPn2vI4iPZLq4V2Tg5rzWvbG+u1bR2t27vHEA4Vzriw9CzqL9kiqh8NHhlj+5HY+/L5ZmSnlNCufFNA5FytpdbneLf01GY1dicGhYb7z3B462nOckpuQmXw1Gw8UzrlRCnsS5ed1AjI5tc3AYBAg2iaI4bQJoFxFvOrJOTdK2vxnWer1VMiDRG14oHDOjZI2/1krTa/tAh4onHOjpM1/1koL9uT8Cgl4oDjBFy5y7qS48RK5CeLw2+80KEeNMWmi96YCb8wG0hvufFoP14ryn/t8r6dp7TnePnqMI0PHG5yz+io2hUir8BIFvnCRc3F6FnTyzLLLeW3lVUydPJEhn0q1ZXmgIHmemCz37nCuXnq39Pt3ocV51ZNzLnVwXb4a1rUuDxTOtbhig+t8+m7nVU/Er7malu5cM0lro/N14x14oABgyqT4LnBJ6c41k6Rg0D8wyAQfXOfwQAHAkYQucN41zrWCpMF1gpYaXOeSeaAA2lOGX/rAO9fs4gbXiWDtaufAAwVA6iAiH0vhml1+MaLOjnZEsLyoB4mAz2sV8EBRhDfmuWYX7Ro7rT3XctN0pFn43umNzkImePfYImq5zKJzjVbYNTa/roMLbN37ZqOzkAlFSxSSHpV0QNLLMdtuk2SSZoa/nybpKUn/Iemhgn1/KWmnpK3h4/QwfbKkNZJ2SdokqStyzBJJr4SPJWN+tRX48PtmNeLPOlcXPk4inXdoCZRS9fQYcGVhoqQ5wBXAnkjy74E7gNsSznWjmV0QPg6EaTcDh83sHOBB4IHw/DOAFcAlwMXACkl1Lwc+9euD9f6TztWNV626UhQNFGb2NHAoZtODwBeJdI4ws7fN7J8JAkaprgG+FT5/AviIJAGLgQ1mdsjMDgMbiAlYteZz3Lhm5lWrrhQVNWZLuhroN7NtZR76zbDa6Y4wGAB0AnsBzOwY8CZwWjQ9tC9Mi8vPLZL6JPUdPFjdEoB3enDNLK5rrHOFyg4UkqYAtwN3lnnojWY2H/hQ+Ph0/pQx+1pK+uhEs4fNrNvMumfNqm6bgo83cs0s3zW2oz3X6Ky4DKukRHE2MBfYJmk3MBt4UdK70w4ys/7w51vA9wjaHSAoKcwBkDQRmEZQ1XUiPTQb2F9Bfp1zRbx99Fijs+AyrOxAYWbbzex0M+sysy6CC/qFZvabpGMkTYz0jMoBHwPyvajWAvkeTdcBG83MgPXAIknTw0bsRWFa3fnobNfM7v7pDl+UyKUqOo5C0mrgMmCmpH3ACjN7JGX/3cCpwCRJPQQX+NeB9WGQaAN+AXwjPOQR4NuSdhGUJG4AMLNDku4FXgj3u8fM4hrVa27V+p2+JKorKmlNh0r3K9y/f2CQNolhMzpLOK5Uh4/42AmXTtZklfDd3d3W19dX1jFdy9albhfw2sqrxpArVyju4leLi2C9FA5cg+Bzc+PCs7ivZ37qfu25Nu6/dv6JhYKiQeTD75vFjzb3J451mD4lx4qPzxvxXqUtQhSXXuzz3+p2t8h3X9JmM+uO2+Yjs0vgXQirq/BimZ+hNP+zf2CQpT/cxt0/3cHAkaGS7robLW7gmgHfeW4P3e+ZcSLvxdZnL1xA6LvP7Umdd+nwkaETiwxFV6QrXISo7/VDIwJOdHGijvacj8h2qXyupxIsXXxeo7PQVEoZDTx03Dh8ZAjj5EUty21FaQPX7lq7o+h++wcGE4NNMdFAkxSIVm/amxig7rp6HrkJ3g88jr8rAQ8Uru4qGQ0cvRhmUceU5O6lA4NDzF22jktXbkxcDEsa2+DO/Hua9N4mrSuxf2CQngWdXH/xnNjtra65KuYr51VPJfDG7Orp3dLPhLAtolxJF8HeLf3ctXbHieqTfL09UHKjcTkNzIX7dp3WXrRBOF8ySnJ8jFcko3hbW9Jxl67cyMCRo2PLQJOaPNHvpcEDRUl8PpzqyNefV7pqWlxbUe+Wfpb+cBtDkSvt4SNDfH7N1hH7RevkCwNAXL3+F9Zspe/1QyMaopP2He/TvIz3/NfSO8eS16ppJR4uS5BWreBKV+pMpR3tOXJtI2uH23NtsW1Fq9bvHBEk0iRVXyW1DXz3uT2j2kV8tlXXirxEUYIm60Fcd9GusGkEPHj9Baxav5OBwaERy3EODg1z90+DRuFoiaDc0t7+gcFRVUdJ+TJGVzt66dK1Ig8UJXjTuw6W5Uu921m9aW/ZVUwGI6qMCo/OVykVViuVY1p7bkRVVbHgVbg9LbA416y86qkE03zCtJJ9qXc733luT8XtELWUaxNHjw2XXFWVt+Cen5+ogvKFrFwr8hJFCXyq8dKt3rS3+E4NMnXSxIoGlkUHta176Y1qZ8u5zPNAUQKfC6c0vVv6M1mSyBtLFeLg0DB/+4NtmX59ztWKVz2VKMujgrMg3200y6a158bUL96DhGtVHihKlO9x4+KNh26jA4ND3i/euQp4oCiRVz+l855AzjUvDxSuKtq8xd+5puWBwo1Z1huxnXNj472eStSe85haKJhnaStDXu3vXFPzq1+Jjh037/kU0buln1vXeJBwzc2rVAMeKEo0NGyZXg+h3lat34nHCNfsvEo14IGiDD4h3Eney8m1Ai9PBIoGCkmPSjog6eWYbbdJMkkzw99Pk/SUpP+Q9FDBvhdJ2i5pl6SvSUGZTtJkSWvC9E2SuiLHLJH0SvhYMuZXO0a+dvZJXiR3rcDLE4FSShSPAVcWJkqaA1wB7Ikk/x64A7gt5jxfB24Bzg0f+XPeDBw2s3OAB4EHwvPPAFYAlwAXAyskTS8hvzXjE8Kd5EVy51pH0UBhZk8Dh2I2PQh8kUjQNbO3zeyfCQLGCZLOAE41s2fNzIDHgZ5w8zXAt8LnTwAfCUsbi4ENZnbIzA4DG4gJWPX0nef2cOnKjd6ojZconGslFbVRSLoa6DezbSUe0gnsi/y+L0zLb9sLYGbHgDeB06LpMccU5ucWSX2S+g4ePFjy66hEfknNVg8WXqJwrnWUHSgkTQFuB+4s57CYNCuyLe2YkYlmD5tZt5l1z5pV++qhpCU1W0mnt9e4FnDTwrManYVMqKREcTYwF9gmaTcwG3hR0rtTjtkX7pc3G9gf2TYHQNJEYBpBVdeJ9JhjGq7Ve0DFrV/tXLO5r2d+o7OQCWUHCjPbbmanm1mXmXURXNAvNLPfpBzzBvCWpIVh+8NngJ+Em9cC+R5N1wEbw3aM9cAiSdPDRuxFYVomtHoPqJ4FnUzx0erOtYRSuseuBp4FzpO0T9LNRfbfDfwd8F/D/d8fbvos8PfALuBV4Gdh+iPAaZJ2AbcCywDM7BBwL/BC+LgnTGu49lyb31EDR3xYtmtyrd4WmVd0ricz+1SR7V1pv0fS+4APxKT/HvhkwjGPAo8Wy2M9TZ+SY8XH59GzILZdvWV8qTfbixQ5Vw2r1u9s+e86+Mjssk2ZNNE/OGR7bWznqsVnIAh4oChTqzdi53n3WNcKfLRQwANFmTqm5BqdBedcnfjtUMADRZn8Rto512o8UJTpzUFfO9u5VjHB654ADxRla/XxE861kuNegwD4UqhAMMFdKY2zuTbx4ffN4tKVG9k/MMiZHe0sXXye94Jyrkn5VDUBDxSU3oNnaNhY88JehoaD/fMTBAIeLJxrMhPkU9XkedUT5U2ZnQ8Sea04QaCPVnWt4E/eO8NvAEMeKBj7mIBWG1tx19odjc6CczX33L8dbnQWMsMDBWPv2dBqDdwD3vPLtQAfVHqSBwrG1rPBJwh0rnn5nGYBDxRj0NnRzv3Xzm+5ekz/0LhW4XOaBbzXE9Cem8BgmVNmd3a088yyy2uUo2zzycVdq/Dqp4DfHAKn5NrKPsarm5xrfuX0iGxmHiiAgSPlNc62+bh+51rCpy6ZU3ynFuCBgvJnhB0+bi03dsK5VuRrZgc8UFDZjLC+oIlzrlV4oKCyGWG97tK55ubf8ZM8UACn5Mp/G7w3hHPNzdsnTip6hZT0qKQDkl6O2XabJJM0M5K2XNIuSTslLY6k/zJM2xo+Tg/TJ0taEx6zSVJX5Jglkl4JH0vG/GoTvHOs/A6fHe2+0p1zzWiC4KaFZ3n7REQp4ygeAx4CHo8mSpoDXAHsiaS9H7gBmAecCfxC0h+Z2XC4y41m1ldw/puBw2Z2jqQbgAeA6yXNAFYA3QQrEm6WtNbMqj4BSyUjs71U6lxppk5q4+2jw8V3zIBWHh+VpmiJwsyeBg7FbHoQ+CIjl5W9Bvi+mb1jZq8Bu4CLi/yJa4Bvhc+fAD4iScBiYIOZHQqDwwbgymL5rUQldZGHjwz5LKrOlWC8BAlovQk+S1VRG4Wkq4F+M9tWsKkTiI553xem5X0zrHa6IwwGI44xs2PAm8BpJZwrmp9bJPVJ6jt48GDZr6fSusjlT273YOEq1tnRzqQ2L5pmSatN8FmqsgOFpCnA7cCdcZtj0vIljhvNbD7wofDx6SLHpJ1rZKLZw2bWbWbds2bNSst+rErrIltxLQpXHZ3h6ohHh71TRJYcOXrMb/5iVFKiOBuYC2yTtBuYDbwo6d0Ed/3R2/PZwH4AM+sPf74FfI+TVVInjpE0EZhGUNWVeK5aqHSwtRdVXSWmTJrAF9ZsbXQ26qajPTcuOoAcPjLkNQUxyg4UZrbdzE43sy4z6yK4oF9oZr8B1gI3hD2Z5gLnAs9LmpjvGSUpB3wMyPeiWgvkezRdB2w0MwPWA4skTZc0HVgUptVEpVONTxsHH/5q8i9Qdbxy4O344nETas+1cdfV85g6eXzMQeo1BaMV/c9JWg1cBsyUtA9YYWaPxO1rZjsk/QD4F+AY8DdmNixpKrA+DBJtwC+Ab4SHPQJ8W9IugpLEDeG5Dkm6F3gh3O8eM4trVK+Kzo72ikZbvx0pqq5av5P9A4OcGVYrNOP04/4FyobcBDE0loVU6qQz8l0YTyUorykYSdZkA8e6u7utr6+wB25xvVv6+XyFH+SO9hzvHDvO4NDJ3h3tubamXKti7rJ1LXMnnFVtEl/5i/OBYFnarK04mGsTq647f9Rn/9KVG2NvxtqkzA1gbcVuspI2m1l33DYfmR0aywV9YHBoRJCA5i2+VqNXSFJzUEd7zj+QRbTn2vjKXwQX4Z4Fndx19Tw6M9RTZ+qkttggAcHU/O0xU/qf2j6Rr15/AV+9/oJMtGP4qpWj+feyhpqx+Prh95Xfq6yQFNx1RuXrsf/u+gtor2BKlfFi+pQcUyp8fYUrKvZu6WfpE9tSq0zrPSN+x5RJiTddPQs6uf/a+aOCQb4BGWDrikXsXnlVzfOZpFVXrSxmfLQujVPN2Cd73UtvjPkcxw1OnTSRqZMnxrbpRL+kvVv6Wf7kS0VXIJw8cUJFU7HU01evv4CeBZ3MXbau7GMFo6pC7v7pDoZSutfm2sT1fzyH7zy3J3Gfait2c9SzoJNV63eOqi7Ll8Dz//tK2wzHohWrm0rVvLduDZZrU1MWXw+XuchTkjcHh3hm2eW8tvIqnll2eepd6Iypk4ue72jGg0RnR/uJ11jJDUTcMWn/i86OdlZdd37d5yuaIDF32TouXbkxsYdcUjCJpidVU9WK8FUr03igqJVstc1lTjkXy2J3qZ0d7ZkvvUUvQuVeBCupM08LvrU0bIYRrNeSNB4h6X8VTc9XU3V2tCOC9qvpZS4wVioBNy48y6ubUnjVU40MhavgNduHr6M9N+ZeNuVe+M5MqYaInmvpD7fVpMvoBBUfZyOS7w062nMjPgf55/nu1BNSev10pnS1TvpfFLYBVON/Vkzce1RYnZS3dPF5LH9y+6hegoWfiXyDfaGuCqruCuX/X2nvrzvJSxQ1lHYn3Luln0tXbixaTM+aj51/xpjPUW5jYdId+PQpuRPn6lnQybtOqf59T65N/JdLzkotAXS053ht5VV89foLRu2Xb6Qv1LOg80TV21f+4vzY4756/QWpJYO7rp5HrqC1OjdBo/5e3H7VltS7Ne47UFhaKKUBOfp9qcaCQvkg0aiS13jjJYoaSipiBw20J++o8sV0GFs33Xp46tflT7oYFa2rL1XhHXjSgMaBKrWfROW7ena/Z0biOJv8Coml5rNQrY+L7leLBuLpU3JMmTQx9txJ34Gk0kKcwu9LtcZcNGOvxFrxQFEjadUrq9bvTBx3kfVAMdYvV6UNhqVcWNKqqCoV7YmVdKEtrFuv5H9Y6+Oi+y245+dV65SQaxMrPh6UYEqpTqrE3T/dMer7Ug0dNWrzaEZe9VQjaUXpUnp9ZNVYxjgU1tVXW7V7yhTW9cedfzwOzspf2KshX+KqpDqpFL1b+qsW1AplbDB4pnmJogaKVa8k3flmvecOwGCF3VCT6uqrqbCKJa2BOWpSm0ZN9x1X119pFVHW9CzorHi6mqjCz3mlpaI0tZzd4M2MTX2SZR4oamDgyFHmLluXeCEptddHFpVzF6bwSl3PC2r0YtW7pf/ERT0t2//65Y+O2Dctv7W4GDbCWAe01WvcQS1L2ePhxiwrPFBEVGtt3/w5khqpx/OdqVRGsDB4rYHTMeQv6mkTPuZ70DRLAChV3M1KOeo17qBjSm7MVU+Xnj2DF/e8OS5vzLLCA0XE8RpUWiY1Uo/bC1MZb1Gt7thKvfvP75sP1nGyNmtpvaT1hMoPQFv30huxF+mO9lzdRnxX49+z+98Huf/a+ePyxiwrPFBEFJtPqFLjoZG6VKV+b9sm1GYKk3K7Fsf1MIvK0syr9VbsZuW7CXNE1bNuvxp/a//A4Pi9McsIDxR10Gqr4AFMblNNvpjldi1OC9KtXv0QVzKD4iPG6/l5Tur40dGe463fHyupROhtEWPn3WMjajWXzMDgEPPu/MdxM/q6Go7UuXSWlJ50kWiTWno66XzJrD9s6O8fGOTWNVv5/JqtJ9KSLsLRVR1rLalL8l1Xz4sd0V6o1W8GqsVLFBErPj6vKt0G47x9dJilT2w78bvXl1am3K7FST3MWjlIQHzJrNTQPjRcv3nMSun4kW9nya+Ul//p8zhVjweKiGr1L08yNGzctXbHiGVTx9P0HeXq3dJf9ddUbtfi8dzDrJbG2m5Wz3a3tPYFb3uoDw8UdRY3i+d4mb6jXHf/dEfVX1MlF36/mIw21ulOxku7Wzk95FwyDxQF/vAPJvHbt47W/e/2Dwxy6cqNTfVBrtXUC37hH7tyxlHETSGeb6fI8v9hPE++mTVFG7MlPSrpgKSXY7bdJskkzYykLZe0S9JOSYsj6RdJ2h5u+5oUjHSSNFnSmjB9k6SuyDFLJL0SPpaM+dUW0bulnwMNCBJ5aYu9OFdNcQsDFa5jLuCmhWfFlh7y7RRZltZDzpWnlBLFY8BDwOPRRElzgCuAPZG09wM3APOAM4FfSPojMxsGvg7cAjwH/ANwJfAz4GbgsJmdI+kG4AHgekkzgBVAN0H3/c2S1prZ4cpfbrpV63c2fGG6wmqo8Vx0LpxUz2VLYcks6bOWNJ4i6+ODxvPkm1lTNFCY2dPRu/yIB4EvAj+JpF0DfN/M3gFek7QLuFjSbuBUM3sWQNLjQA9BoLgGuCs8/gngobC0sRjYYGaHwmM2EASX1eW9xNLVezH3JPkPcqlF51KCSbkBp3dLP3et3XGiTWX6lFxZs47GTarnsi2pSm+8TmI5XvOdRRWNo5B0NdBvZtsKNnUCeyO/7wvTOsPnhekjjjGzY8CbwGkp54rLzy2S+iT1HTxY+cI61Vg5qxrO7Gind0s/f/uDbUWLznH94Qurr0rZJ6p3Sz9Lf7htRMP74SND3PqDrUXznp9ietUnzx83JR+XbrxOrz5e851FZTdmS5oC3A4sitsck2Yp6ZUeMzLR7GHgYYDu7u6Ka4+yMO9Prk18+H2zWP7k9sT8RIvOpYxULnc086r1O2PXni5lOepGTgLoamO8djEer/nOokp6PZ0NzAW2he3Rs4EXJV1McNc/J7LvbGB/mD47Jp3IMfskTQSmAYfC9MsKjvllBfkt2VinXq6GY8eN7yTUCefli869W/oT8xsNJuXW1Xodris0Xnuajdd8Z03ZVU9mtt3MTjezLjPrIrigX2hmvwHWAjeEPZnmAucCz5vZG8BbkhaG7Q+f4WTbxlog36PpOmCjmRmwHlgkabqk6QQlmPWVv9TislAkLVaoyRedi82KGq2HTaqTTeoLX2kd7pQxrH7nnMuuoiUKSasJ7uxnStoHrDCzR+L2NbMdkn4A/AtwDPibsMcTwGcJelC1EzRi/yxMfwT4dtjwfYig1xRmdkjSvcAL4X735Bu2a6XWI7PHSpxcYvXSlRtT+8D3DwzStWxd6vkGBodG7TMlN4Gh4crmaarV/E7OlWo89xLMslJ6PX2qyPaugt+/DHw5Zr8+4AMx6b8HPplw7keBR4vlsZpKXT6zEQzoe/0QPQs6a1ZF5hd7N175ALva8bqCAlkNEnmrN+0tvpNzLcgH2NWOB4oCWV/IJgs9s5JMnZQ+5bNzteSdM2rHA0WBpYvPi+2XmyXF2h4a5c8v9OK9a5ykThg+wG7sPFAU6FnQyY0Lz2p0Nsalp35d+WBH58bKB9jVjgeKGPVaOL7ZeBHfNVLhRIedHe0tv0BVtfg0465qvIjvGs0H2NWGlyhi+DTflfEivnPNyQNFgWIjnl0yv5Nzrjl5oCgQ1xfbOedamQeKAt4g65xzI3mgKOANss45N5IHigJxfbGdc66VeaAokO+LnfXR2c45Vy8eKGJ47x3nnDvJA0UCb6twzrmAB4oEPnjMOecCHigSePWTc84FPFCkyPraFM45Vw8eKFJ4V9nSnXv61EZnwTlXIz57bIp89dOq9TtrtkZ1s9hw62WNzoJzrkaKligkPSrpgKSXI2n3SnpJ0lZJP5d0Zpg+SdI3JW2XtE3SZZFjfilpZ3jMVkmnh+mTJa2RtEvSJkldkWOWSHolfCyp4usuWc+CTp5Zdjk3+WJGzrkWVUrV02PAlQVpq8zsg2Z2AfB/gDvD9P8GYGbzgSuAr0iK/o0bzeyC8HEgTLsZOGxm5wAPAg8ASJoBrAAuAS4GVkiaXubrq5r7euZ7sEiwe+VVjc6Cc66GilY9mdnT0bv8MO3/RX6dClj4/P3AP4X7HJA0AHQDz6f8iWuAu8LnTwAPSRKwGNhgZocAJG0gCFiri+W5Vu7rme+r3znnWk7FjdmSvixpL3AjJ0sU24BrJE2UNBe4CJgTOeybYbXTHWEwAOgE9gKY2THgTeC0aHpoX5gWl5dbJPVJ6jt40Ndtds65aqo4UJjZ7WY2B/gu8Lkw+VGCC3of8FXg/wLHwm03hlVSHwofnw7T46ZVspT0uLw8bGbdZtY9a9asCl6Nc865JNXoHvs94BMQlAjM7AthG8Q1QAfwSritP/z5VnjMxeHx+whLHZImAtOAQ9H00GxgfxXy65xzrgwVBQpJ50Z+vRr4dZg+RdLU8PkVwDEz+5ewKmpmmJ4DPgbke1GtBfI9mq4DNpqZAeuBRZKmh43Yi8I055xzdVS0MVvSauAyYKakfQQ9kT4q6TzgOPA68Ffh7qcD6yUdB/o5Wb00OUzPAW3AL4BvhNseAb4taRdBSeIGADM7JOle4IVwv3vyDdvOOefqR8HNe/OQdJAgeFVqJvC7KmWnljyf1Tde8jpe8gnjJ6+eT3iPmcU28jZdoBgrSX1m1t3ofBTj+ay+8ZLX8ZJPGD959Xym87menHPOpfJA4ZxzLpUHitEebnQGSuT5rL7xktfxkk8YP3n1fKbwNgrnnHOpvEThnHMulQcK55xzqTxQhCRdGa6XsUvSsgblYXe4lsdWSX1h2gxJG8I1OTZEp1qXtDzM705JiyPpF4Xn2SXpa5EJGMeSt7h1SaqWt7R1SaqQz7sk9UfWQvloBvI5R9JTkn4laYek/x6mZ+o9TclnFt/TUyQ9r2AtnB2S7g7Ts/aeJuUzc+/pCWbW8g+C0eKvAu8FJhHMgvv+BuRjNzCzIO1/AsvC58uAB8Ln7w/zORmYG+a/Ldz2PPAnBBMr/gz4syrk7T8BFwIv1yJvwF8D/yt8fgOwpor5vAu4LWbfRubzDODC8PkfAP8a5idT72lKPrP4ngp4V/g8B2wCFmbwPU3KZ+be0/zDSxSBi4FdZvZvZnYU+D7BOhlZcA3wrfD5t4CeSPr3zewdM3sN2AVcLOkM4FQze9aCT8njkWMqZmZPE0yxUqu8Rc/1BPCR/N1RFfKZpJH5fMPMXgyfvwX8imAa/Uy9pyn5TNLI99TM7D/CX3Phw8jee5qUzyQNe0/zPFAESl77osYM+LmkzZJuCdP+0MzegOBLSzCfFiTnuTN8XpheC9XMW9K6JNXyOQXL9z4aqXrIRD7DaoEFBHeWmX1PC/IJGXxPJbVJ2gocIFj4LJPvaUI+IYPvKXigyCt57Ysau9TMLgT+DPgbSf8pZd8xr+NRQ5XkrZb5/jpwNnAB8AbwlSJ/s275lPQu4EfA523kypGjdk34u3XJa0w+M/memtmwBUs0zya46/5Ayu4Ny2tCPjP5noIHirxMrH1hZvvDnweAHxNUif02LGIS/syvNZ6U533h88L0Wqhm3pLWJRkzM/tt+MU8TjBr8ai1UBqRTwWzKf8I+K6ZPRkmZ+49jctnVt/TPDMbAH5JsHxy5t7TuHxm+T31QBF4AThX0lxJkwgaf9bWMwOSpkr6g/xzgvU3Xmbkeh1LgJ+Ez9cCN4S9G+YC5wLPh0XrtyQtDOskPxM5ptqqmbekdUnGLH+RCP05I9dCaUg+w/M+AvzKzP4usilT72lSPjP6ns6S1BE+bwf+M8FaOVl7T2PzmcX39IRKW8Gb7QF8lKBHx6vA7Q34++8l6NmwDdiRzwNBveI/EawU+E/AjMgxt4f53UmkZxPQHX7IXgUeIhyBP8b8rSYoDg8R3K3cXM28AacAPyRoqHseeG8V8/ltYDvwUvgFOiMD+fxTgqqAl4Ct4eOjWXtPU/KZxff0g8CWME8vA3dW+ztUpfc0KZ+Ze0/zD5/CwznnXCqvenLOOZfKA4VzzrlUHiicc86l8kDhnHMulQcK55xzqTxQOOecS+WBwjnnXKr/D+MrAICXUhdkAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "52 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0004, grad_fn=) , base rewards= tensor([3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367,\n", + " 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367,\n", + " 3.9367, 3.3591, 2.7891, 2.2247, 1.6645, 1.1075, 0.5529]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9944, 0.9970, 0.9983, 0.9978, 0.9943, 0.9956, 0.9968, 0.9939, 0.9979,\n", + " 0.9981, 0.9960, 0.9967, 0.9979, 0.9968, 0.9976, 0.9967, 0.9975, 0.9972,\n", + " 0.9990, 0.9993, 0.9987, 0.9998, 0.9997, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1041, 0.1045, 0.0973, 0.0845, 0.0675, 0.0473, 0.0247])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "32 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0004, grad_fn=) , base rewards= tensor([4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883,\n", + " 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883,\n", + " 3.9107, 3.3406, 2.7762, 2.2161, 1.6591, 1.1044, 0.5516]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9953, 0.9976, 0.9986, 0.9981, 0.9952, 0.9962, 0.9974, 0.9950, 0.9983,\n", + " 0.9984, 0.9967, 0.9973, 0.9983, 0.9973, 0.9980, 0.9972, 0.9980, 0.9990,\n", + " 0.9994, 0.9995, 0.9989, 0.9998, 0.9997, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1297, 0.1301, 0.1230, 0.1101, 0.0931, 0.0729, 0.0504, 0.0260])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAtjklEQVR4nO3dfZBU9Z3v8feHocWBXRkQ2OiADlGXVAiro3OVLTdbxlzBjVFnjUa8JqFqrXWfcuuaRFJwjYIPueKlXFIpq3KvKYgPSQjRZCdkWS8hiylrXZ8GhwmShCsmBBlMIBdwjaAOw/f+0ecMZ5rTp5+nz3R/X1Vd0/M7D/3rnunzPb9nmRnOOedcPuPqnQHnnHPp5oHCOedcIg8UzjnnEnmgcM45l8gDhXPOuUTj652Baps2bZp1dHTUOxvOOTembN269XdmNj1uW8MFio6ODnp7e+udDeecG1Mk/TrfNq96cs45l8gDhXPOuUQeKJxzziUqGCgkrZW0X9IrMdtul2SSpgW/XyxpW/Dol/SXkX0vkrRd0i5JX5WkIH2CpPVB+guSOiLHLJb0avBYXJV37JxzriTFlCgeAa7MTZQ0C7gC2BNJfgXoMrMLgmP+t6SwwfxrwK3AecEjPOctwCEzOxdYDTwQnH8qsBy4BLgYWC5pSgnvzTnnXBUU7PVkZs9E7/IjVgNfBH4Q2fdIZPupgAFIOgM4zcyeC35/DOgGngKuBVYExzwJPBSUNhYCm83sYHDMZrLBZV3R784554p089ef49nXDtY7G1Wze+VVVTtXWW0Ukq4BBsysP2bbJZJ2ANuBvzWzY0A7sDey294gjeDn6wDBvm8Cp0fTY47Jfc1bJfVK6j1w4EA5b8k518QaLUgAdCzdWLVzlRwoJE0E7gDuittuZi+Y2VzgPwHLJJ0KKG7X8JR5tiUdk/uaD5tZl5l1TZ8eO17EOefyarQgUW3llCjOAWYD/ZJ2AzOBlyW9L7qTmf0ceBv4ENnSwMzI5pnAvuD5XmAWQNCeMRk4GE2POcY559woKTlQmNl2M5thZh1m1kH2gn6hmf1G0uyw8VrS2cAcYLeZvQG8JWl+0P7wGU60bWwAwh5N1wNbLLua0iZggaQpQSP2giDNOefcKCrYmC1pHXAZME3SXmC5ma3Js/ufAUslDQLHgb83s98F2/6ObA+qVrKN2E8F6WuAxyXtIluSWARgZgcl3Qu8FOx3T9iw7Zxz1XTahBb+492hemcjtYrp9XRTge0dkeePA4/n2a+XbDVUbvo7wA15jlkLrC2UR+ecq0QjBolLz5latXP5yGznnGtA1Wyg90DhnHMukQcK51zTGz8urje+C3mgcM41vWPHY4dojWneRuGccy6vS8+Zyrf++k+rdj4PFM4512CqGSTAA4VzzrkCPFA451wDOW/GpKqf0wOFc841iPNmTGLz5y+r+nkLjsx2zjmXXgJ+VcW1J+J4icI558awM9taa/4aHiicc24MyIwTmZaRAwNbMy0sWTin5q/tgcI551JmysQMn5p/Fu1trQhob2tl1Q3ns+r680ek3X/dPLo7Yxf+rCpvo3DOuRQotq1hNAJDLi9ROOdcCkxuzdQ7C3l5oHDOuRR4+71j9PQN1DsbsTxQOOdcCgwOGas27ax3NmJ5oHDOuZTYd/hovbMQywOFc86lxGiMiSiHBwrnnBtlba0ZWjMtI9JGa0xEOQoGCklrJe2X9ErMttslmaRpwe9XSNoqaXvw8/LIvj+RtFPStuAxI0ifIGm9pF2SXpDUETlmsaRXg8fiqrxj55yrs4+ffwb3XzevLmMiylHMOIpHgIeAx6KJkmYBVwB7Ism/A642s32SPgRsAqLv/GYz6805/y3AITM7V9Ii4AHgRklTgeVAF2DAVkkbzOxQ0e/OOedS6OlfHOC+7vQGhlwFSxRm9gxwMGbTauCLZC/i4b59ZrYv+HUHcKqkCQVe4lrg0eD5k8BHJQlYCGw2s4NBcNgMXFkov845l3ZpbbTOp6w2CknXAANm1p+w2yeAPjN7N5L2jaDa6c4gGEC2xPE6gJkdA94ETo+mB/YysnQSzc+tknol9R44cKCct+Scc6MmrY3W+ZQcKCRNBO4A7krYZy7ZKqS/iSTfbGbzgA8Hj0+Hu8ecwhLST040e9jMusysa/r06YXfhHPO1UDLuJGXrXpO5FdN5ZQozgFmA/2SdgMzgZclvQ9A0kzgn4DPmNlr4UFmNhD8fAv4NnBxsGkvMCs4djwwmWxV13B6YCawD+ecS5lxgk/NP4sHbzg/NRP5VVPJkwKa2XZgRvh7ECy6zOx3ktqAjcAyM3s2ss94oC3YJwN8HPhxsHkDsBh4Drge2GJmJmkT8D8kTQn2WwAsKzW/zjlXa7+8/8RkfnFBYKwFhlwFA4WkdcBlwDRJe4HlZrYmz+6fBc4F7pR0Z5C2AHgb2BQEiRayQeLrwfY1wOOSdpEtSSwCMLODku4FXgr2u8fM4hrVnXNjRE/fAKs27WTf4aOc2dbKkoVzxvxFNK6OvNEUDBRmdlOB7R2R5/cB9+XZ9aI8x78D3JBn21pgbaE8OufSr6dvgGXf387RwSEABg4fZdn3twP1veOudCK+ceNET9/AmA94SXxktnNuVKzatHM4SISODg7VfSK8Sl9/6Hh6J/OrFg8UzrlRkW/sQL3HFFTj9ev9HmrNA4VzblTkGztQ7zEF1Xj9er+HWvNA4ZwbFUsWzknlRHiVvn4a3kOteaBwzo2K7s72VE6EV8nrp+U91FrJ4yicc65c3Z3tDXNRFfDs0ssL7tcIvEThnHMJWhQ/UqLR2yWivEThnGt4lQz0u+mSWXxv68CIrr3N0C4R5SUK51xDCwf6DRw+inFioF840K7QgLuus6emsm1lNHmJwjnX0JIG+nV3thccLLdq006eXXp5UwWGXF6icM41tEID/QYKDJZr9MF0xfAShXOubIXq/nv6BlixYQeHjw4CMGVihuVXz6363XlSPs5sa40NBmFjdIvEkMUudTNiv2bmJQrnXFmKqftf8kT/cJAAOHRkkCVP9lc8EV8p+Sg00C8pSAB85AO+GJoHCudcWQpN8rdq004Gj598ER4cqu4keoXyUelAv6d/4csre9WTc64sher+k+r2i633L6ZbazGTDUYH+oXn/Nz6bUVVK3kbhZconHNlyneRNaBj6UbG5RmoFt1n7l3/J281VKEqpUL5iEuPO2ch3kbhgcI5V6a4uv+oQnX/AG+/N8QXnohvsyh2/YpSJhuMO2chSxbO4Us92zln2b/QsXQj5yz7F77Us72kc4x1XvXknCtLWJXzhe/2FxUU8hk6bty2fhu3rd82oldUsetXhPnIV0UVrb4qJ5e9vz7IN5/fcyK/ZsO/39c9r4wzjj1eonDOla27s53jFQSJXNFeUUlVW5eu3EJP3wA9fQNcunILt63fxm/efOekQJBb1VSOdS+8XlJ6I/IShXOuIvnGKZQr7BW1ZOGcEWtsRw0cPsrnv7uNlnFicCgbAsJSTXQt7nKqmnLlKy1VUooaawqWKCStlbRf0isx226XZJKmBb9fIWmrpO3Bz8sj+14UpO+S9FUp29IlaYKk9UH6C5I6IscslvRq8FhclXecR3hnMnvpxuG7FefcSHHfk1qMMwirlyaMz3+JOm4MB4lcYVtGNXos5Zs9Nl96Iyqm6ukR4MrcREmzgCuAPZHk3wFXm9k8YDHweGTb14BbgfOCR3jOW4BDZnYusBp4IDj/VGA5cAlwMbBc0pRi31gpiu1d4Vwzy/c92fjTN6r+WpNbMyz7/vYRg/VKFbZXVOqmS2aVlN6ICgYKM3sGOBizaTXwRThR9WdmfWa2L/h1B3BqUGI4AzjNzJ4zMwMeA7qD/a4FHg2ePwl8NChtLAQ2m9lBMzsEbCYmYFVDsb0rnGtm+b4nh46UfzGPk2kREhVXGYWN2kk9s4pxX/c8PjX/rOESRIvEp+af1TQN2VBmG4Wka4ABM+tX/uLXJ4A+M3tXUjuwN7JtLxCOmmkHXgcws2OS3gROj6bHHFNVxfaucK6Zjcb3Iez19Ln12yo6T9g9truz/aReS+W4r3teUwWGXCX3epI0EbgDuCthn7lkq5D+JkyK2c0KbEs6Jvf1bpXUK6n3wIHSh9uXMmDHuWY1Gt+Hq/7kDLo724t6rXHAp+afRXtkcr/Q0cEhvvDdfr7Us72iKThaM94xFMrrHnsOMBvol7QbmAm8LOl9AJJmAv8EfMbMXguO2RvsF5oJ7ItsmxUcOx6YTLaqazg95pgRzOxhM+sys67p00tvWCtlwI5zzWrJwjlkxtW2Afdbz+/JTia4cE7snWJUS4voOnsqzy69nN0rrzqpzSAc71BJj6xPXDSz8E5NoORAYWbbzWyGmXWYWQfZC/qFZvYbSW3ARmCZmT0bOeYN4C1J84P2h88APwg2byDb8A1wPbAlaMfYBCyQNCVoxF4QpFVdpZOGOdcMujvb+YNTa9uj3oAVG3bQ3dlecNxDdHLBnr6BiquX4viEgFkF/+qS1gGXAdMk7QWWm9maPLt/FjgXuFPSnUHaAjPbD/wd2R5UrcBTwQNgDfC4pF1kSxKLAMzsoKR7gZeC/e4xs7hG9aqIThrmnIt3uMoN17GvcXSQL/VsR+Spa47Yd/jocG+sWvB2yixZgw0a6erqst7e3npnw7mGdOnKLVUdXFepsH2iVnlqb2vl2aWXF96xAUjaamZdcdu8pcY5V7RqdDetlrAdsZZ3/R2ne4cW8EDhnCtBd2c7n7iovWBD82g4NeiRVMveWM//8lDNzj2WeKBwzpVk40/fKHuCvWo6dGSQZd/fzkc+ML1mpZxmms8piU8K6JyLFbe6HFD1kdiVODo4xDef30NbawZhHBk8XtXzN9N8Tkk8UDjnThL2JAqn0QjndTo1pQPQKpkTKkkzzeeUxAOFc+4k+eZ1qnT+pbGmmaftiErn7YFzrq58/ICL8kDhnDuJz3PmojxQBHzhIudOiBsv4ReL5uVtFORvuAN8Wg/XlML/+7DX0+TWTM0ajF36+U0CvnCRc3G6O9t5dunl/GrlVUya4PeUzcz/+uSfJyZNc9o4Vw/hWAr/LjQ3DxTONbm4gXXdne0nVcm65uWBwrkmltQ+F1cl65qTt1EQv+ZqUrpzjSKpfc7HUriQBwpg4inxE4rlS3euUeQLBvsOH6VtYmaUc+PSygMFcOS9+OL123nSnWsU+QbWTW7N8Pt3jo1yblxaeaAAWhMmOvOBd66RxQ2sa820IMHgcZ9i22V5oIDEqYl9LIVrZN2d7dx/3Tza21oR2aU/779uXqqmEq+Xcd5IOcwDRQHeoOcaWW7X2I98YDorNuyod7ZSocUDxTDvHluAT47mGlVc19hvPr+nzrlKjyqvgTSmFSxRSForab+kV2K23S7JJE0Lfj9d0tOSfi/poZx9fyJpp6RtwWNGkD5B0npJuyS9IKkjcsxiSa8Gj8UVv9syfOQD0+vxss7VnI+TcMUqpurpEeDK3ERJs4ArgOgtyDvAncDtec51s5ldEDz2B2m3AIfM7FxgNfBAcP6pwHLgEuBiYLmkKUXkt6qe/sWB0X5J50aFV6u6YhUMFGb2DHAwZtNq4ItwYp11M3vbzP6NbMAo1rXAo8HzJ4GPShKwENhsZgfN7BCwmZiAVWs+x41rVF6t6opVVmO2pGuAATPrL/HQbwTVTncGwQCgHXgdwMyOAW8Cp0fTA3uDtLj83CqpV1LvgQPVLQH42uquUcV1jXUuTsmBQtJE4A7grhIPvdnM5gEfDh6fDk8Zs68lpJ+caPawmXWZWdf06dVtUzDvSu4aVLRrrHNJyilRnAPMBvol7QZmAi9Lel/SQWY2EPx8C/g22XYHyJYUZgFIGg9MJlvVNZwemAnsKyO/zrk8ujvbvcOGK6jkQGFm281shpl1mFkH2Qv6hWb2m3zHSBof6RmVAT4OhL2oNgBhj6brgS1mZsAmYIGkKUEj9oIgbdT56GzXqHr6BviWd4l1BRQcRyFpHXAZME3SXmC5ma1J2H83cBpwiqRushf4XwObgiDRAvwY+HpwyBrgcUm7yJYkFgGY2UFJ9wIvBfvdY2Zxjeo1t2rTTl8S1RWUb12HcveL7r9iw47hpUinTMyw/Oq5VfmfXLVpZ3x9rnMRsgarhO/q6rLe3t6SjulYujFxu4Bfrbyqgly5XNGV01okhsyGf7YXcfFMm7hFfgTcPP8s7uuel7hfa6aF+6+bN7xYUO5I6fUvvp533qXczyppEaK49NlLN3qgSLC7ib73kraaWVfcNh+ZXQTvRlhduRfLoeBmJfw5cPgoS57o5+4f7uDwkcGi7rrrLW7wmgHffH4PXWdPHc57ofXZc0dKf+v5PYkX8uhCQ3HHL/v+dnp/fZDvbR2IXZzozLZW7wLuCvK5noqwZOGcemehoRQzInjwuHHoyCDGiQtbmtuKkgavRedOyndR3nf4aN5gU0gYaPIFoXUvvJ43OHkXWVcML1G4UVfOiODwwpbGUkVP3wDjgmqzOIePDjJ76UYmt+ZfCGicVNGdfdJnmi9f+w4fHf48b1u/rezXdo3PA0UR0nqBGosKXVSTxF0M8zX0AkU3GJfTuBzuP7k1w1vvHiv4fgyG8xinnM8j9/ylGicxe+lGr1p1BXmgKILPiVMdYdtEuRfF3AtaT98AS57oH9HQe+jI4El3x9E6+dwAEDeD6m3rt3H3D3fE9izK3T/p4p920TYh55J4G0URfO3g6ih2ttK21gyZnMUAWjMtJ7UVrdq0s+hV2KINxsXk6dCRwdh2EZ9x1TUjDxRFaLAexKOup2+AS1duKXjnKuArN17ApAnjGRyyEXO4HB0c4u4f7hhx4S61pBfuH+Zn9tKNiXmKCy5eunTNyKueivDmGK5eGG25bQalMEY2qubG57BaqdyG1zPbWmOrq5LkBhLvTuqakZcoipDUW8WdEF6E01hvn2kRSxbOYcWGHUUHiVDnPT8aLsl0nO4Nv675eKAogk81XpxS2gxG26RTxtPd2V5WEIu2Vzz3y7rMIuNcXXmgKMKhI+m7Q06jNFfJVFrKOTo4xBe+209K46BzNeWBokhpHhWcBj19A7ELiKTNhPHl/8tXOtbBubHKA0WR7v7hjsI7NbGxMAtpx9KNvHvseL2z4dyY44GiSF79lCzN1U7Oucp4oHBV0eIt/s41LA8UrmI9fQNef+9cA/MBd0VqzXhMjapkYJ1zbmzxq1+Rjh037/kUSPPAOudc9XmgKNLgkMVOKteM0jywzjlXfR4oSuATwmX55+BccykYKCStlbRf0isx226XZJKmBb+fLulpSb+X9FDOvhdJ2i5pl6SvStluMpImSFofpL8gqSNyzGJJrwaPxRW/2wr5Ai9Z/jk411yKKVE8AlyZmyhpFnAFsCeS/A5wJ3B7zHm+BtwKnBc8wnPeAhwys3OB1cADwfmnAsuBS4CLgeWSphSR35r5yAem1/PlU8PXEHeuuRQMFGb2DBA3E9pq4ItEZoM2s7fN7N/IBoxhks4ATjOz58zMgMeA7mDztcCjwfMngY8GpY2FwGYzO2hmh4DNxASs0fTN5/dw6cotTd+o3d3ZzjgfNuFc0yirjULSNcCAmfUXeUg7sDfy+94gLdz2OoCZHQPeBE6Ppscck5ufWyX1Suo9cOBA0e+jHOGyms0eLLwt27nmUXKgkDQRuAO4q5TDYtKswLakY0Ymmj1sZl1m1jV9eu2rh/Itq9lM2r2dwrmmUU6J4hxgNtAvaTcwE3hZ0vsSjtkb7BeaCeyLbJsFIGk8MJlsVddweswxddfsPX+8ncK55lFyoDCz7WY2w8w6zKyD7AX9QjP7TcIxbwBvSZoftD98BvhBsHkDEPZouh7YErRjbAIWSJoSNGIvCNJSodl7/nR3xtYCOtcwfP6yEwpO4SFpHXAZME3SXmC5ma1J2H83cBpwiqRuYIGZ/Qz4O7I9qFqBp4IHwBrgcUm7yJYkFgGY2UFJ9wIvBfvdY2apWF6sNdPid9TONTifteeEgoHCzG4qsL0j6fdIei/woZj0d4Ab8hyzFlhbKI+jacrEDMuvntv0d9Rf6tle7yw4V1PvDHmPjZDHzBJNDNZebnbffmFP4Z2ccw3BA0WJmr0RG7KTAnr3WOeahweKErVNzNQ7C3XX7F2DnWs2HihK5OvzeKnKuWbjgaJEb/oaDF6qcq7JeKAoUbOPnwAvVTnXbHwpVLIDa4pZ8znTIj7ygelcunIL+w4f5cy2VpYsnNN0vaC8VOVcc/ESBRQVJCC7yt36l15n4PBRjOadINBLVa4ZXHrO1HpnITU8UFDaUP3BnEE4zThBoK/L4ZrBDV1n1TsLqeGBguJLFPk0Wy+gf+5/o95ZcK7mmu0GMIkHCqh4EZ5mq4o57G0Urgk02w1gEg8UVLYIj08Q6FxjOtVnBRzmvZ4q0N6kvZ6cawbvHjte7yykhgcKoDUzjqODpf1TtLe18uzSy2uUI+dcvfl8Zid42Qo4NdNS8jFe3eRcY/OFi07wQAEcPlJa42xLpa3fzrnUm//+KfXOQmp4oKD0uYuGjpt3nXOuwe3+f97rKeSBgvLmLhrwrnPONTTvHnuCBwrKm7vI6y+da2zNNj4qiQcKyusvXelobudcemVa5B1WIgpeISWtlbRf0isx226XZJKmRdKWSdolaaekhZH0nwRp24LHjCB9gqT1wTEvSOqIHLNY0qvBY3HF7zaPcvpLt7X6mgzONaIpEzOsuv58Hx8VUcw4ikeAh4DHoomSZgFXAHsiaR8EFgFzgTOBH0v6YzMbCna52cx6c85/C3DIzM6VtAh4ALhR0lRgOdAFGLBV0gYzO1TieyyonP7SXvPkXHGmTMxwqMSehfXgY6PyK1iiMLNngIMxm1YDXyR7EQ9dC3zHzN41s18Bu4CLC7zEtcCjwfMngY9KErAQ2GxmB4PgsBm4slB+y1FOe8OhI4NNN724c+UYC0ECvPE6SVltFJKuAQbMrD9nUzvweuT3vUFa6BtBtdOdQTAYcYyZHQPeBE4v4lzR/NwqqVdS74EDB0p+PzddMqvkY4CmXIvCVc9Xbryg3llwEd54nV/JgULSROAO4K64zTFpYYnjZjObB3w4eHy6wDFJ5xqZaPawmXWZWdf06aWvlXBf97ySj4HmXIvCVUe7X5RS58h7x/zGL49yShTnALOBfkm7gZnAy5LeR/auP3p7PhPYB2BmA8HPt4Bvc6JKavgYSeOByWSruvKeqxbKHWztxVVXqkyL6Di9lc+t31bvrIyattZM6juAHDoy6LUEeZQcKMxsu5nNMLMOM+sge0G/0Mx+A2wAFgU9mWYD5wEvShof9oySlAE+DoS9qDYAYY+m64EtZmbAJmCBpCmSpgALgrSaKHcCsMkp/+evNv8SVW78OPHvrx2MLx43oNZMCyuumcukCemfg9RrCeIV/MtJWgdcBkyTtBdYbmZr4vY1sx2Svgv8DDgG/IOZDUmaBGwKgkQL8GPg68Fha4DHJe0iW5JYFJzroKR7gZeC/e4xs7hG9apob2sta7T125Hi6qpNO9l3+ChnNvD04/4lqlypMxXHyYwTgyme3rRFYshsxFT8Y6UE5bUEJ5M12MCxrq4u6+3N7YFbWE/fALeV+Y/c1prh3WPHOTo4NJzWmmnh/uvmNVywmL10Y03uhEW2MdGnRimsReLBT54PwIoNO1K14mDLOPHgDfFjEC5duSX27yvyND7WSbN2k5W01cy64rb5yOxAJRf0w0cHRwQJaNwibK16hoSlsEb/hxQw6ZTSp7UPtWZaePCT2Qtxd2c7K66Zm6qG8ZsunpX3u7Rk4Rxac6b0F3Dz/LP4yo0XpKINw1esjNfo38u6asQibMfp1b8ohV/O7s52/vHGC2ht0CUow4tipqW899fe1jqilNrTN8CSJ/tTVQp7+hf5u6d3d7bziYvaR3RnNOB7W7NVt9uWL2D3yqvq1m049/N1J6S/dWkMa8R+2f/+WnWaiVokjpud1J4T3imHevoGWPb9nybW64+Vkb+rb7yA7s52vvX8nsI75xCcVB1y9w93MDiUv9JmnLJVQUn7VFuhm6Onf3HgpGqmsPQd/R9YtWnnqAbAZq1uKlZj3rqlQKNOKlatS85xM3618iqeXXp54h1cd2c7UydNSDxX310LqpSr2mlvax1+n+XcQMQdkxQc29ta+cdPXsCq688v+bUqMU5i9tKNXLpyS2wPuXyBJDc9rpqqVoSvWFmIB4paSVPrXAqVcrFMuksN6+fTUL+dJHohKvUiWE69eRiAR7saZcgMI7teS9yYhHx/99z07s527r9u3vDfN5xmp9pTrIXVgV7dlMwDRY0M+ip4eZV64ct3cYneCX78/DOqkbVYxQ7GzDdnWFtrZsSFKPcimO9cIrnePF9wzE0fjSAa9xnFdeiIC5L5/h+6O9t5dunl7F55Fa/d/zF2r7yK1VVsv5gyMcPqGy8oe2aGZuKBooaS7oR7+ga4dOWWxGJ6GlXjjq7UBsOk3jLheZIaUSuRaRH/5ZKzEksA7W2t7F55FQ9+8vzYi+CKa+aedEx4EfzKjRfEHvPgJ88vWDW34pq5ZHKu0JlxOun14varJpF/lcjc70A0SBYKhFHh96WaYzEmnjLeSxJF8sbsGsp3J5xtoN0+3KU2LKZDZd10R0OlNWrRuvpihfsnDWisVQ+zcF2CrrOn5h1nE752MfnMVc4xpR4b3a8WDcTh/3ncueO+A6VWieV+X6qlEXsl1ooHihpJql5ZtWln3nEXaQ8Ulaikj3qhi0utBusV0xMnejEsp12gkraEYo+N7texdGNZrxUn+jfNvZhXY0xCT98AX/huf01WlGybmO52rTTxqqcaSSpOF9vzo5G0SDXto16LXjK5dful1K+nWSUD/nKFf9Nyq5SShCWJWi073GCTUtSUlyhqoFD1Sr6730YcdwGjM51JbjXM5NYMb793rOAYgnHAaa2Zk6bBiKvrr6SaKE2OvFedKpzc//Nq97KKK3lX05spmvok7TxQ1MDhI+8xe+nGvBeSJQvn1KSYnkbto3gxjRusF17U84WL42RHBEf3TQoA9ehyWm3VqKYbjf/XapWw880l1ag3ZrXggSJi0iktvF2Fu63wHPkaqRvlzrSQ3SuvquvrF9OIG3ZpbYQAUKy4G5VcSRP1TTqlhS//Ze2numirwoh7CW6+5Cy+t3WgKW7MasUDRcTxGlRa5mukbvQLUznrkBer2Lv/YnrL1Kr+O80KBdAwENz9wx2xF+q2iaeMyv9uvj+NVHz7gll2Bcuus6c2/I1ZLXmgiKjGOgFxGrmROp/5759Sk/OW0rW4mDruNM28OpqKuVHJN2ZhtP6f87UhlBPbG/3GrNY8UIyCZqwL/dkbb9XkvKV0LS50QWvm6od8pbJo+rhg8aFco7WqY762lPa2Vo68d6yoaqkp3gW2Krx7bESt/qkGDh+l854fjZnR19VQq9lcS+lanBSgm3lK6bBUNhA08g8cPsqSJ/r54J1Pcdv6bcPp+arloqs61lJSd+TlV88t2B060yKWX33yqHhXOi9RRCy/em7Zq9wVcujIIEue7B/+3etLy1NK1+J8vcuaNUCE4kplg8et6KVVB4dsVAaHFtPpI2xnCZdejVuC1VXOA0VEd2d7zQIFZL9gKzbsGLFs6liavqNUPX0DVX9PpXQtbpbeZaWqRhvDaLVTJLUteLvD6PFAMcri1jdu1Ok77v7hjqq/p1Iv/n4xOVk1xlGMVjtFJYrtHecK80CR44/+8BR++9Z7o/66A4ePcunKLQ31z1yrdgq/+FemmHEUocy4bFVObq1U2E6R1r/DWJ54M40KNmZLWitpv6RXYrbdLskkTYukLZO0S9JOSQsj6RdJ2h5s+6qU7WgvaYKk9UH6C5I6IscslvRq8Fhc8bstoKdvgP11CBKhfIu9OFdNufMytbVmyLScPO5lysQMq244P7b0ELZTpFVS7zhXumJKFI8ADwGPRRMlzQKuAPZE0j4ILALmAmcCP5b0x2Y2BHwNuBV4HvgX4ErgKeAW4JCZnStpEfAAcKOkqcByoIvsINGtkjaY2aHy326yVZt21n1hutxqqLFcfE77qnPNLGm6k9z/s3qPpyhHM068WUsFA4WZPRO9y49YDXwR+EEk7VrgO2b2LvArSbuAiyXtBk4zs+cAJD0GdJMNFNcCK4LjnwQeCkobC4HNZnYwOGYz2eCyrrS3WLzRXMw9SfjPXGzxuZhgUmrA6ekbYMWGHcNtKlMmZkrqahg3qZ5Lr6TqvLE4ieVYzHOalTWOQtI1wICZ9edsagdej/y+N0hrD57npo84xsyOAW8CpyecKy4/t0rqldR74ED5K53VctqJUpzZ1jo8D3+h4nNcn/jc6qti9onq6RtgyRP9IxreDx0Z5PPf3VYw7+EU06tuOH/MlHxcsrE4vfpYzHOaldyYLWkicAewIG5zTJolpJd7zMhEs4eBhwG6urrKrj1Kw7w/mRbxkQ9MT5yHP1p8LmakcqkLJa3atDO2T32hbvYtEq/d/7HkndyYMxa7GY/FPKdZOb2ezgFmA/1Be/RM4GVJF5O9658V2XcmsC9InxmTTuSYvZLGA5OBg0H6ZTnH/KSM/BatvUarpJXi2HHjm8/vSdwnLD739A3kzW80mJRaX1tuPe5Nl8wqvJMbk8ZiT7OxmOe0Krnqycy2m9kMM+swsw6yF/QLzew3wAZgUdCTaTZwHvCimb0BvCVpftD+8BlOtG1sAMIeTdcDW8zMgE3AAklTJE0hW4LZVP5bLSwNxdJChZqw+BxWJ+UTrYvNVy+bry98ufW4XWdPLes451y6yQpcmSStI3tnPw34LbDczNZEtu8Guszsd8HvdwB/BRwDbjOzp4L0LrI9qFrJNmL/VzMzSacCjwOdZEsSi8zsl8ExfwX89+Clvmxm3yj0hrq6uqy3t7eY9x6rmusJV5uA1TdeQHdnO533/Kgm4xQmZsYxOHSccibSbWvNsG15XI2kc6NjLPcSrDdJW82sK25bMb2ebiqwvSPn9y8DX47Zrxf4UEz6O8ANec69FlhbKI/VlLRgS70Z0Pvrg0DtBrMdqWCq9bhR586NFh9kVzs+e2yOtAaJ0LoXXvdBQ87F8EF2teOBIkfaF7IZMkvtoCGf+9/Vkw+yqx0PFDmWLJwT2y83TdJa6vG5/1095euE4YPsKueBIkd3Zzs3zz+r3tkYk7we2NWTD7KrHQ8UMe7rnlfvLDjnSpQ72WEzr2JYbT7NuHOuYfggu9rwEkUMn+bbOedO8ECRo9CIZ+ecazYeKHLE9cV2zrlm5oEih/e5ds65kTxQ5PA+1845N5IHihxxfbGdc66ZeaDIEfbFTvvobOecGy0eKGJ4P2znnDvBA0Ue3lbhnHNZHijy8PlhnHMuywNFHl795JxzWR4oEqR9bQrnnBsNHigSeFfZ4p03Y1K9s+CcqxGfPTZBWP20atNOBnzEdqLNn7+s3llwztVIwRKFpLWS9kt6JZJ2r6SfStom6UeSzgzST5H0DUnbJfVLuixyzE8k7QyO2SZpRpA+QdJ6SbskvSCpI3LMYkmvBo/FVXzfRevubOfZpZfzKV/MyDnXpIqpenoEuDInbZWZ/YmZXQD8M3BXkP7XAGY2D7gCeFBS9DVuNrMLgsf+IO0W4JCZnQusBh4AkDQVWA5cAlwMLJc0pcT3VzX3dc/zYJHH7pVX1TsLzrkaKlj1ZGbPRO/yg7T/iPw6iRPLOH8Q+Ndgn/2SDgNdwIsJL3EtsCJ4/iTwkCQBC4HNZnYQQNJmsgFrXaE818p93fN89TvnXNMpuzFb0pclvQ7czIkSRT9wraTxkmYDFwGzIod9I6h2ujMIBgDtwOsAZnYMeBM4PZoe2BukxeXlVkm9knoPHDhQ7ltyzjkXo+xAYWZ3mNks4FvAZ4PktWQv6L3AV4B/B44F224OqqQ+HDw+HaTHTatkCelxeXnYzLrMrGv69OllvBvnnHP5VKN77LeBT0C2RGBmnwvaIK4F2oBXg20Dwc+3gmMuDo7fS1DqkDQemAwcjKYHZgL7qpBf55xzJSgrUEg6L/LrNcAvgvSJkiYFz68AjpnZz4KqqGlBegb4OBD2otoAhD2arge2mJkBm4AFkqYEjdgLgjTnnHOjqGBjtqR1wGXANEl7yfZE+pikOcBx4NfA3wa7zwA2SToODHCiemlCkJ4BWoAfA18Ptq0BHpe0i2xJYhGAmR2UdC/wUrDfPWHDtnPOudGj7M1745B0gGzwKtc04HdVyk4teT6rb6zk1fNZXWMln1DbvJ5tZrGNvA0XKColqdfMuuqdj0I8n9U3VvLq+ayusZJPqF9efa4n55xziTxQOOecS+SB4mQP1zsDRfJ8Vt9Yyavns7rGSj6hTnn1NgrnnHOJvEThnHMukQcK55xziTxQBCRdGayXsUvS0jrlYXewlsc2Sb1B2lRJm4M1OTZHp1qXtCzI705JCyPpFwXn2SXpq5EJGMvNV9yaJFXLV9KaJFXK6wpJA5G1UD5W77xKmiXpaUk/l7RD0n8L0lP1uSbkM1WfqaRTJb2o7Do4OyTdndLPM18+U/V5nsTMmv5BdrT4a8D7gVPIzoL7wTrkYzcwLSftfwJLg+dLgQeC5x8M8jkBmB3kvyXY9iLwp2QnVnwK+IsK8/XnwIXAK7XIF/D3wP8Kni8C1lc5ryuA22P2rVtegTOAC4Pnfwj83yA/qfpcE/KZqs80OOcfBM8zwAvA/BR+nvnymarPM/fhJYqsi4FdZvZLM3sP+A7ZdTLS4Frg0eD5o0B3JP07Zvaumf0K2AVcLOkM4DQze86y/ymPRY4pi5k9Q3Z6lVrlK3quJ4GPhndHVcprPnXLq5m9YWYvB8/fAn5Odhr9VH2uCfnMp175NDP7ffBrJngY6fs88+Uzn7p+n0IeKLKKXvuixgz4kaStkm4N0v7IzN6A7JeW7HxakD/P7cHz3PRqq2a+8q1JUk2fVXb53rWR6odU5DWoGugke3eZ2s81J5+Qss9UUoukbcB+souepfLzzJNPSNnnGeWBIqvotS9q7FIzuxD4C+AfJP15wr4Vr+NRI+Xkq9Z5/hpwDnAB8AbwYIHXHbW8SvoD4HvAbTZy5ciTds3zuqOS15h8pu4zNbMhyy7PPJPsXfeHEnZPWz5T93lGeaDISsXaF2a2L/i5H/gnslVivw2KmQQ/w7XG8+V5b/A8N73aqpmvfGuSVIWZ/Tb4ch4nO2vxSWuh1COvys6m/D3gW2b2/SA5dZ9rXD7T+pkGeTsM/ITs0smp+zzj8pnmzxM8UIReAs6TNFvSKWQbgDaMZgYkTZL0h+FzsutvvMLI9ToWAz8Inm8AFgU9HGYD5wEvBsXrtyTND+olPxM5ppqqma98a5JURXihCPwlI9dCqUteg/OuAX5uZv8Y2ZSqzzVfPtP2mUqaLqkteN4K/Gey6+Sk7fOMzWfaPs+TlNsK3mgP4GNke3S8BtxRh9d/P9neDf3AjjAPZOsW/5XsSoH/CkyNHHNHkN+dRHo2AV3BP9prwEMEI/AryNs6ssXhQbJ3K7dUM1/AqcATZBvqXgTeX+W8Pg5sB35K9kt0Rr3zCvwZ2eqAnwLbgsfH0va5JuQzVZ8p8CdAX5CfV4C7qv39qXE+U/V55j58Cg/nnHOJvOrJOedcIg8UzjnnEnmgcM45l8gDhXPOuUQeKJxzziXyQOGccy6RBwrnnHOJ/j8bdOUcVkqPEAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "21 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0005, grad_fn=) , base rewards= tensor([5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388,\n", + " 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 4.4612,\n", + " 3.8912, 3.3268, 2.7667, 2.2097, 1.6550, 1.1021, 0.5506]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9960, 0.9979, 0.9988, 0.9984, 0.9959, 0.9967, 0.9978, 0.9958, 0.9985,\n", + " 0.9986, 0.9971, 0.9977, 0.9986, 0.9977, 0.9983, 0.9976, 0.9990, 0.9994,\n", + " 0.9996, 0.9997, 0.9990, 0.9999, 0.9998, 1.0000, 0.9993],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1564, 0.1568, 0.1496, 0.1368, 0.1197, 0.0995, 0.0770, 0.0527, 0.0270])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "22 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0006, grad_fn=) , base rewards= tensor([5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886,\n", + " 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.0110, 4.4410,\n", + " 3.8766, 3.3165, 2.7595, 2.2048, 1.6520, 1.1004, 0.5498]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9967, 0.9983, 0.9991, 0.9986, 0.9966, 0.9973, 0.9982, 0.9966, 0.9988,\n", + " 0.9988, 0.9976, 0.9981, 0.9989, 0.9981, 0.9986, 0.9990, 0.9995, 0.9996,\n", + " 0.9997, 0.9998, 0.9991, 0.9999, 0.9998, 1.0000, 0.9993],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1838, 0.1842, 0.1770, 0.1642, 0.1471, 0.1269, 0.1044, 0.0800, 0.0544,\n", + " 0.0278])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "9 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379,\n", + " 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 5.5603, 4.9903, 4.4259,\n", + " 3.8658, 3.3087, 2.7541, 2.2012, 1.6497, 1.0991, 0.5493]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9970, 0.9985, 0.9991, 0.9987, 0.9969, 0.9975, 0.9984, 0.9969, 0.9989,\n", + " 0.9989, 0.9978, 0.9983, 0.9990, 0.9983, 0.9990, 0.9993, 0.9996, 0.9997,\n", + " 0.9997, 0.9998, 0.9992, 0.9999, 0.9998, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2117, 0.2121, 0.2049, 0.1921, 0.1750, 0.1549, 0.1323, 0.1080, 0.0823,\n", + " 0.0557, 0.0283])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "14 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0008, grad_fn=) , base rewards= tensor([6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867,\n", + " 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.1092, 5.5391, 4.9748, 4.4146,\n", + " 3.8576, 3.3029, 2.7501, 2.1985, 1.6479, 1.0981, 0.5489]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9975, 0.9987, 0.9993, 0.9989, 0.9974, 0.9978, 0.9986, 0.9974, 0.9991,\n", + " 0.9990, 0.9982, 0.9985, 0.9991, 0.9990, 0.9995, 0.9996, 0.9997, 0.9998,\n", + " 0.9998, 0.9998, 0.9993, 0.9999, 0.9998, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2400, 0.2404, 0.2333, 0.2204, 0.2034, 0.1832, 0.1606, 0.1363, 0.1107,\n", + " 0.0841, 0.0567, 0.0287])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([7.2350, 7.2350, 7.2350, 7.2350, 7.2350, 7.2350, 7.2350, 7.2350, 7.2350,\n", + " 7.2350, 7.2350, 7.2350, 7.2350, 6.6576, 6.0876, 5.5233, 4.9631, 4.4061,\n", + " 3.8515, 3.2986, 2.7470, 2.1965, 1.6467, 1.0974, 0.5485]) return= 142815.4274140199\n", + "probs of actions: tensor([9.9748e-01, 9.9874e-01, 9.9929e-01, 9.9893e-01, 9.9738e-01, 4.9428e-04,\n", + " 9.9865e-01, 9.9742e-01, 9.9907e-01, 9.9905e-01, 9.9820e-01, 9.9853e-01,\n", + " 9.9915e-01, 9.9905e-01, 9.9948e-01, 9.9956e-01, 9.9972e-01, 9.9977e-01,\n", + " 9.9980e-01, 9.9984e-01, 9.9932e-01, 9.9991e-01, 9.9984e-01, 1.0000e+00,\n", + " 9.9918e-01], grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5755, 0.5686, 0.5729, 0.5750,\n", + " 0.5761, 0.5767, 0.5769, 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2687, 0.2691, 0.2619, 0.2491, 0.2321, 0.2119, 0.1893, 0.1650, 0.1394,\n", + " 0.1127, 0.0853, 0.0574, 0.0291])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "9 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835,\n", + " 7.7835, 7.7835, 7.7835, 7.2060, 6.6360, 6.0716, 5.5114, 4.9544, 4.3998,\n", + " 3.8469, 3.2954, 2.7448, 2.1950, 1.6457, 1.0968, 0.5483]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9978, 0.9989, 0.9994, 0.9990, 0.9977, 0.9981, 0.9988, 0.9978, 0.9992,\n", + " 0.9992, 0.9984, 0.9990, 0.9994, 0.9994, 0.9996, 0.9997, 0.9998, 0.9998,\n", + " 0.9998, 0.9999, 0.9994, 0.9999, 0.9999, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2976, 0.2980, 0.2908, 0.2780, 0.2610, 0.2408, 0.2182, 0.1939, 0.1682,\n", + " 0.1416, 0.1142, 0.0863, 0.0580, 0.0293])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "231 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0005, grad_fn=) , base rewards= tensor([8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316,\n", + " 8.3316, 8.3316, 7.7541, 7.1841, 6.6197, 6.0596, 5.5026, 4.9479, 4.3950,\n", + " 3.8435, 3.2929, 2.7431, 2.1938, 1.6450, 1.0964, 0.5481]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9988, 0.9993, 0.9997, 0.9994, 0.9987, 0.9988, 0.9993, 0.9988, 0.9995,\n", + " 0.9995, 0.9990, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3267, 0.3271, 0.3199, 0.3071, 0.2900, 0.2698, 0.2473, 0.2230, 0.1973,\n", + " 0.1707, 0.1433, 0.1154, 0.0870, 0.0584, 0.0295])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795,\n", + " 8.8795, 8.3020, 7.7320, 7.1677, 6.6076, 6.0506, 5.4959, 4.9430, 4.3915,\n", + " 3.8409, 3.2911, 2.7418, 2.1930, 1.6444, 1.0961, 0.5480]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9988, 0.9993, 0.9997, 0.9994, 0.9987, 0.9988, 0.9993, 0.9988, 0.9995,\n", + " 0.9995, 0.9990, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3559, 0.3563, 0.3491, 0.3363, 0.3192, 0.2990, 0.2765, 0.2522, 0.2265,\n", + " 0.1999, 0.1725, 0.1446, 0.1162, 0.0876, 0.0587, 0.0296])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0009, grad_fn=) , base rewards= tensor([9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271,\n", + " 8.8498, 8.2799, 7.7156, 7.1554, 6.5984, 6.0438, 5.4909, 4.9394, 4.3888,\n", + " 3.8390, 3.2897, 2.7409, 2.1923, 1.6440, 1.0959, 0.5479]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9988, 0.9993, 0.9997, 0.9994, 0.9987, 0.9989, 0.9993, 0.9988, 0.9995,\n", + " 0.9995, 0.9990, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3852, 0.3856, 0.3784, 0.3656, 0.3485, 0.3283, 0.3058, 0.2815, 0.2558,\n", + " 0.2292, 0.2018, 0.1739, 0.1455, 0.1169, 0.0880, 0.0589, 0.0297])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "5 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0013, grad_fn=) , base rewards= tensor([9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.3973,\n", + " 8.8276, 8.2633, 7.7032, 7.1462, 6.5916, 6.0387, 5.4872, 4.9366, 4.3868,\n", + " 3.8375, 3.2887, 2.7401, 2.1918, 1.6437, 1.0957, 0.5478]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9989, 0.9994, 0.9997, 0.9994, 0.9987, 0.9989, 0.9993, 0.9990, 0.9996,\n", + " 0.9996, 0.9990, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.4145, 0.4149, 0.4078, 0.3950, 0.3779, 0.3577, 0.3352, 0.3108, 0.2852,\n", + " 0.2586, 0.2312, 0.2033, 0.1749, 0.1463, 0.1174, 0.0883, 0.0591, 0.0298])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 9.9446,\n", + " 9.3751, 8.8110, 8.2509, 7.6940, 7.1394, 6.5865, 6.0350, 5.4844,\n", + " 4.9346, 4.3853, 3.8365, 3.2879, 2.7396, 2.1915, 1.6435, 1.0956,\n", + " 0.5478]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9989, 0.9994, 0.9997, 0.9995, 0.9987, 0.9989, 0.9993, 0.9991, 0.9996,\n", + " 0.9996, 0.9990, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.4440, 0.4444, 0.4372, 0.4244, 0.4073, 0.3872, 0.3646, 0.3403, 0.3146,\n", + " 0.2880, 0.2606, 0.2327, 0.2043, 0.1757, 0.1468, 0.1177, 0.0885, 0.0592,\n", + " 0.0298])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "4 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0019, grad_fn=) , base rewards= tensor([11.0667, 11.0667, 11.0667, 11.0667, 11.0667, 11.0667, 10.4912, 9.9223,\n", + " 9.3584, 8.7985, 8.2416, 7.6871, 7.1342, 6.5827, 6.0321, 5.4823,\n", + " 4.9330, 4.3842, 3.8356, 3.2873, 2.7392, 2.1912, 1.6433, 1.0955,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9989, 0.9994, 0.9997, 0.9995, 0.9988, 0.9990, 0.9994, 0.9993, 0.9997,\n", + " 0.9997, 0.9991, 0.9999, 1.0000, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9997, 1.0000, 0.9999, 1.0000, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.4734, 0.4738, 0.4667, 0.4539, 0.4368, 0.4166, 0.3941, 0.3698, 0.3441,\n", + " 0.3175, 0.2901, 0.2622, 0.2338, 0.2052, 0.1763, 0.1472, 0.1180, 0.0887,\n", + " 0.0593, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "6 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([11.6101, 11.6101, 11.6101, 11.6101, 11.6101, 11.0368, 10.4689, 9.9056,\n", + " 9.3459, 8.7892, 8.2347, 7.6819, 7.1303, 6.5798, 6.0300, 5.4807,\n", + " 4.9319, 4.3833, 3.8350, 3.2869, 2.7389, 2.1910, 1.6432, 1.0954,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9990, 0.9994, 0.9997, 0.9995, 0.9990, 0.9993, 0.9996, 0.9995, 0.9998,\n", + " 0.9998, 0.9991, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9998, 1.0000, 0.9999, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5029, 0.5033, 0.4962, 0.4834, 0.4663, 0.4461, 0.4236, 0.3993, 0.3736,\n", + " 0.3470, 0.3196, 0.2917, 0.2633, 0.2347, 0.2058, 0.1767, 0.1475, 0.1182,\n", + " 0.0888, 0.0594, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0023, grad_fn=) , base rewards= tensor([12.1493, 12.1493, 12.1493, 12.1493, 11.5803, 11.0145, 10.4522, 9.8931,\n", + " 9.3366, 8.7822, 8.2295, 7.6780, 7.1275, 6.5776, 6.0284, 5.4795,\n", + " 4.9310, 4.3827, 3.8346, 3.2866, 2.7387, 2.1909, 1.6431, 1.0954,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9990, 0.9994, 0.9997, 0.9995, 0.9991, 0.9993, 0.9996, 0.9995, 0.9998,\n", + " 0.9998, 0.9991, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9998, 1.0000, 0.9999, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5324, 0.5328, 0.5257, 0.5129, 0.4958, 0.4757, 0.4531, 0.4288, 0.4031,\n", + " 0.3765, 0.3491, 0.3212, 0.2929, 0.2642, 0.2353, 0.2062, 0.1770, 0.1477,\n", + " 0.1183, 0.0889, 0.0594, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0024, grad_fn=) , base rewards= tensor([12.6801, 12.6801, 12.6801, 12.1195, 11.5579, 10.9978, 10.4397, 9.8837,\n", + " 9.3296, 8.7770, 8.2256, 7.6751, 7.1253, 6.5760, 6.0272, 5.4787,\n", + " 4.9303, 4.3822, 3.8342, 3.2863, 2.7385, 2.1907, 1.6430, 1.0953,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9990, 0.9994, 0.9997, 0.9995, 0.9991, 0.9994, 0.9996, 0.9995, 0.9998,\n", + " 0.9998, 0.9992, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9998, 1.0000, 0.9999, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5619, 0.5623, 0.5551, 0.5424, 0.5254, 0.5052, 0.4826, 0.4583, 0.4327,\n", + " 0.4061, 0.3787, 0.3508, 0.3224, 0.2937, 0.2648, 0.2358, 0.2066, 0.1773,\n", + " 0.1479, 0.1185, 0.0890, 0.0595, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0027, grad_fn=) , base rewards= tensor([13.1942, 13.1942, 12.6503, 12.0972, 11.5412, 10.9852, 10.4303, 9.8767,\n", + " 9.3244, 8.7731, 8.2226, 7.6729, 7.1237, 6.5748, 6.0263, 5.4780,\n", + " 4.9299, 4.3819, 3.8340, 3.2861, 2.7384, 2.1907, 1.6430, 1.0953,\n", + " 0.5476]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9990, 0.9995, 0.9997, 0.9996, 0.9992, 0.9994, 0.9996, 0.9995, 0.9998,\n", + " 0.9998, 0.9992, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9998, 1.0000, 0.9999, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5912, 0.5916, 0.5846, 0.5719, 0.5549, 0.5347, 0.5122, 0.4879, 0.4623,\n", + " 0.4356, 0.4082, 0.3803, 0.3520, 0.3233, 0.2944, 0.2653, 0.2361, 0.2068,\n", + " 0.1775, 0.1480, 0.1185, 0.0890, 0.0595, 0.0300])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0033, grad_fn=) , base rewards= tensor([13.6758, 13.1646, 12.6281, 12.0805, 11.5287, 10.9759, 10.4233, 9.8715,\n", + " 9.3205, 8.7701, 8.2205, 7.6712, 7.1224, 6.5739, 6.0256, 5.4775,\n", + " 4.9295, 4.3816, 3.8338, 3.2860, 2.7383, 2.1906, 1.6429, 1.0953,\n", + " 0.5476]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9991, 0.9995, 0.9998, 0.9996, 0.9992, 0.9994, 0.9996, 0.9996, 0.9998,\n", + " 0.9998, 0.9992, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 0.9998, 1.0000, 1.0000, 1.0000, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.6205, 0.6209, 0.6139, 0.6013, 0.5844, 0.5643, 0.5417, 0.5174, 0.4918,\n", + " 0.4652, 0.4378, 0.4099, 0.3815, 0.3529, 0.3240, 0.2949, 0.2657, 0.2364,\n", + " 0.2070, 0.1776, 0.1481, 0.1186, 0.0891, 0.0595, 0.0300])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAtqklEQVR4nO3de5CddZ3n8fcnnZPQQU3nxgidYEdgYhkzJtADmWJmS3FJGBFoEQdY0GwVtcw4Y9V6IVZSXMLNJWzKiWVR5S4OERGNUdQ2TsZt4wSLGoZbh04MGc0ShpikgyZO0lkkLXQ63/3jeU7n6dPPc+73831Vncrp33M5v3NyzvN9fneZGc4551ySSbXOgHPOufrmgcI551xWHiicc85l5YHCOedcVh4onHPOZTW51hkot9mzZ1tXV1ets+Gccw1l+/btvzOzOXHbmi5QdHV10d/fX+tsOOdcQ5H066RtXvXknHMuKw8UzjnnsvJA4ZxzLqucgULSBkmHJb0Us+02SSZpdvj3xZJ2hI+dkj4a2fciSbsk7ZX0FUkK06dK2hSmPyepK3LMCkkvh48VZXnHzjnnCpJPieJR4IrMREnzgMuB/ZHkl4BuM1scHvO/JaUbzL8K3ApcED7S57wFOGZm5wPrgQfD888E1gCXABcDayTNKOC9OeecK4OcvZ7M7KnoXX7EeuALwI8i+56IbD8DMABJZwPvMLNnwr8fA3qAnwDXAHeHxzwBPBSWNpYDW83saHjMVoLgsjHvd+ecc1n0DgzymU07ap2Niti39sqynauoNgpJVwODZrYzZtslknYDu4C/MbOTQCdwMLLbwTCN8N8DAOG+x4FZ0fSYYzJf81ZJ/ZL6jxw5Usxbcs61mGYOEgBdq7aU7VwFBwpJ04DbgbvitpvZc2a2EPhTYLWkMwDF7Zo+ZcK2bMdkvubDZtZtZt1z5sSOF3HOuXHW9e2pdRYaRjElivOA+cBOSfuAucCLkt4Z3cnMfgm8AbyPoDQwN7J5LnAofH4QmAcQtmdMB45G02OOcc65khwaGq51FhpGwYHCzHaZ2Vlm1mVmXQQX9AvN7DeS5qcbryW9C1gA7DOz14DXJS0N2x8+yem2jc1AukfTdcA2C1ZT6gOWSZoRNmIvC9Occ65k53S01zoLDSOf7rEbgWeABZIOSroly+5/TlDS2AH8EPhbM/tduO1TwD8Ae4FXCBqyAR4BZknaC3wOWAUQNmLfB7wQPu5NN2w751ypVi5fUOssNAw121Ko3d3d5nM9OefyUc4G33pTaK8nSdvNrDtum4/Mds65JtNZ5mo1DxTOOddkyt1Q74HCOeeaTLkb6j1QOOdcE5mk8jfUe6Bwzrkm8o4zUvQsiZ3EomgeKJxzrokcHx4p+zk9UDjnXBOpxEBCDxTOuZZ0R++uWmeh7FJtqshAwpzTjDvnXDPa+NyB3Ds1kBnTUqy5amHZ2yfAA4VzrkWNNvisFAJeLeOaE9l41ZNzriW1KW4lg/qTlM9qTmrogcI515Jmvy1V6yzk1J5q48ZL5tGeapuQXs1JDT1QOOda0m9ff6vWWRhnxrQUNy89l86OdkQwX9MD1y7i/p5FPHDtognplWiLSOJtFM45VyP5tjP0LOmsamDI5CUK55yrkent9V/9BR4onHMt6o/ePqXWWeCNt07SOzBY62zk5IHCOdeSjvy+9m0UI6PGur49tc5GTh4onHMt6VSdDKMo99oRleCBwjnnaqia4yGK5YHCOdeSqn3x62hP1Xw8RLFyflaSNkg6LOmlmG23STJJs8O/L5e0XdKu8N/LIvv+XNIeSTvCx1lh+lRJmyTtlfScpK7IMSskvRw+VpTlHTvnHGBVHpj9kfefXfPxEMXKZxzFo8BDwGPRREnzgMuB/ZHk3wFXmdkhSe8D+oDop3CTmfVnnP8W4JiZnS/pBuBB4HpJM4E1QDdgwHZJm83sWN7vzjnnElR7qqcnf3WE+3saIzBkylmiMLOngKMxm9YDXyC4iKf3HTCzQ+Gfu4EzJE3N8RLXAN8Inz8BfEiSgOXAVjM7GgaHrcAVufLrnHP1qBEarZMUVU0n6Wpg0Mx2ZtntY8CAmb0ZSft6WO10ZxgMIChxHAAws5PAcWBWND10kPGlk2h+bpXUL6n/yJEjxbwl55yrqEZotE5ScKCQNA24Hbgryz4LCaqQ/jqSfJOZLQL+Inx8Ir17zCksS/rERLOHzazbzLrnzJmT+00451yZiGDBoGwapdE6STElivOA+cBOSfuAucCLkt4JIGku8EPgk2b2SvogMxsM/30d+DZwcbjpIDAvPHYyMJ2gqmssPTQXOIRzzpXBpDI0Zp85pY311y9m3XXvH9dIHTe5XyO2TaQVPCmgme0Czkr/HQaLbjP7naQOYAuw2syejuwzGegI90kBHwF+Fm7eDKwAngGuA7aZmUnqA/6HpBnhfsuA1YXm1znn4vzZu2fy9Ctxza/52ZcxmV8jB4Jc8ukeu5HgIr5A0kFJt2TZ/dPA+cCdGd1gpwJ9kn4B7AAGga+FxzwCzJK0F/gcsArAzI4C9wEvhI97wzTnXIPpHRjk0rXbmL9qC5eu3VYX8xvt+4/SGpfr4T1Ui6zBlwPM1N3dbf39mT1wnXO10jswyOof7GJ4ZHQsrT3VVvPqmK5VW0o6vh7eQzlJ2m5m3XHbfGS2c66i1vXtGRckAIZHRhtiMrxsmuE95MsDhXOuopLGDzTyuIK0ZngP+fBA4ZyrqKTxA408riCtGd5DPjxQOOcqauXyBQ07GV42zfAe8uVrZjvnKird2Luubw+HhoY5p6OdlcsXNGQjcJvEKbOGfg/F8EDhnKu4niWdTXFRPWXGqxnjJ1qBVz0551yeWqVNIpOXKJxzTal3YLCk6q72VNuEsR+t0iaRyUsUzrmmkx7kNzg0jAGDQ8Os/sGugkZTf+yizqaar6kUXqJwzjWdbIP88r3YP/mrIzy96rLcO7YAL1E455pOOQb5tcpgunx4icI5V7Bc9f+9A4PcvXk3Q8MjAMyYlmLNVQvLWnWTLQ/ndLQzGHOhL6QxulUbruN4icI5V5Bc9f+9A4Os/N7OsSABcOzECCuf2Fm2GVdz5aHUQX4Kz+ECHiiccwXJNcnfur49jJyaOCv1yKiVbRK9XHnoWdLJA9cuKqkxulUbruN41ZNzriC56v+z1e3nW++fq2ornzaIzEF+6TUx0ufMprkWXyidlyiccwVJusgawRoPk5S8xmh6n4V3/Z/Eaqh8urYWOtFg3DmzacvyHlqRBwrnXEHi6v+jRvNYDO2Nt0b5/Pfi2yzyWb+i0DaIuHNmc+Ml87ijdxfnrf4nulZt4bzV/8QdvbvyPr7ZeNWTc64g6eqcz393Z15BIcnoKeMzm3bwmU07xvWKyrdaCbJPNBitvioml48/u/90Xs3G/r6/Z1ERZ2tsXqJwzhWsZ0knp8q4jHK0V1S2qq30etvp7rfpqqQTb50ct29mVVOhNj53oKD0ZueBwjlXlHKPM0j3ispWtTU4NMznvruDz313R9but4VWNWVKKimVUoJqZDkDhaQNkg5Leilm222STNLs8O/LJW2XtCv897LIvheF6XslfUUKWoskTZW0KUx/TlJX5JgVkl4OHyvK8o4TpHtEzF+1ZeyuxTkXiPt9fPA9c8r+OunqpamTky9Npyx4ZIp2vy11VHVSY3arNnLnU6J4FLgiM1HSPOByYH8k+XfAVWa2CFgBfDOy7avArcAF4SN9zluAY2Z2PrAeeDA8/0xgDXAJcDGwRtKMfN9YIcoxgZhzzSrp97HlF6+V/bWmt6dY/YNd40oLhUgHiFJLOzdeMq+g9GaXM1CY2VPA0ZhN64EvEOlybGYDZnYo/HM3cEZYYjgbeIeZPWNmBjwG9IT7XQN8I3z+BPChsLSxHNhqZkfN7BiwlZiAVQ759LJwrlUl/T6OnSjuYp4k1SYkSqoySgeIXD2zcrm/ZxE3Lz13rATRJnHz0nNbsiEbiuz1JOlqYNDMdiq5KPYxYMDM3pTUCRyMbDsIpLsndAIHAMzspKTjwKxoeswxZVWOCcSca1bV+B2kez19dtOOos+RatNY99ieJZ30//rouJ5Lhbq/Z1HLBoZMBTdmS5oG3A7clWWfhQRVSH+dTorZzXJsy3ZM5uvdKqlfUv+RI0eSspWo0ME7zrWSavwOrvyTs+lZ0pnXa00Cbl56Lh3tqbG01KTT3W3TYx6e/FXh1wKAttZshsiqmF5P5wHzgZ2S9gFzgRclvRNA0lzgh8AnzeyV8JiD4X5pc4FDkW3zwmMnA9MJqrrG0mOOGcfMHjazbjPrnjOn8Aa2UicQc66ZrVy+gNSkyl49v/Xs/mAyweULYu8Qo9raRPe7ZrJjzTL2rb2Sm5eey8ip0w3c6TEPuUZfJxltzY5NWRUcKMxsl5mdZWZdZtZFcEG/0Mx+I6kD2AKsNrOnI8e8BrwuaWnY/vBJ4Efh5s0EDd8A1wHbwnaMPmCZpBlhI/ayMK3syjGBmHPNqmdJJ287o7Jjcw3GFhXKdZ1O925K98QqpXrJ5Sfn/76kjcAHgNmSDgJrzOyRhN0/DZwP3CnpzjBtmZkdBj5F0IOqHfhJ+AB4BPimpL0EJYkbAMzsqKT7gBfC/e41s7hG9bLInEDMOXfaUJkbruMMDg3nPU1GuudVKQ3fLn+yJhtA0t3dbf39/bXOhnNN5dK124quyqmENqlig9/OnNLG7nsr0sGyrknabmbdcdt8ZLZzLqdSu5uWU3uqraIjpN82tT7eZz3xQOGcy6lnSScfu6gzZ0NzNZyRmsSMaancOxbpt6+/VbFzNyqfPdY5l5ctv3itLhb0OXZihNQkkWoTI95FqSo8UDjnxolbXQ4o+0jsUoycMkQwUK+e8tWsPFA458ak53VK9yZK9y46I1V/tdRGELzaJonRuFkCXdl4oHDOjUma16meu6F6kKi8+rtNcM7VjM9v5uJ4oHDOjfH5zYJ5o9x4/pGEfOEi5+LHS7TaRWLKZB9HkcnbKEhuwAN8Wg/XUtLf93Svp+ntqaIXEWpUb7xVv+0xtdJqNwuxfOEi507rWdLJ06su49W1V3LmVL+XdF6iAEicw6ae5rZxrprSYyn8N+DAA4VzLS1pcJ3PzOqiPFA416KyDa7zIOGiPFAQrLkaN2SnHiZAc65SGnFwnasNb8wGpk2J7w6XlO5cM/DBdS5fHiiAEwnd4bybnGtmPrjO5csDBdCeZSimD7xzzSpucJ1Xt7o4HiiAEyOnErf5WArXrHqWdPLAtYvo7GhHQGdHe12sN1FrbfJwmckbs3PwelzXjDK7xd609Fz+cedrtc5WXVj67hm1zkLd8UCRg9fjumYT1y328Wf31zhX9WPHgeO1zkLdyVn1JGmDpMOSXorZdpskkzQ7/HuWpCcl/V7SQxn7/lzSHkk7wsdZYfpUSZsk7ZX0nKSuyDErJL0cPlaU/G6L8MH3zKnFyzpXMXHdYt1p3ollonzaKB4FrshMlDQPuByI3or8AbgTuC3hXDeZ2eLwcThMuwU4ZmbnA+uBB8PzzwTWAJcAFwNrJFW9TPjkr45U+yWdqyivTnWFyhkozOwp4GjMpvXAF4iMVTOzN8zsXwgCRr6uAb4RPn8C+JAkAcuBrWZ21MyOAVuJCViV5nPduGbj1amuUEX1epJ0NTBoZjsLPPTrYbXTnWEwAOgEDgCY2UngODArmh46GKbF5edWSf2S+o8cKW8JwDtAuGYT1y3WuWwKDhSSpgG3A3cVeOhNZrYI+Ivw8Yn0KWP2tSzpExPNHjazbjPrnjOnvG0K5v0FXZOJdot1Lh/FlCjOA+YDOyXtA+YCL0p6Z7aDzGww/Pd14NsE7Q4QlBTmAUiaDEwnqOoaSw/NBQ4VkV/nXIaeJZ188D1zfICdy0vBgcLMdpnZWWbWZWZdBBf0C83sN0nHSJoc6RmVAj4CpHtRbQbSPZquA7aZmQF9wDJJM8JG7GVhWtX56GzXbHoHBvnWs/t9gJ3LS85xFJI2Ah8AZks6CKwxs0ey7L8PeAcwRVIPwQX+10BfGCTagJ8BXwsPeQT4pqS9BCWJGwDM7Kik+4AXwv3uNbO4RvWKW9e3x5dEdYni1nRI+r4Us+/g0DBtEqNmdOY4Jl/r+vZ4kHB5kzVZJXx3d7f19/cXdEzXqi1Ztwt4de2VJeTKRcVdAMt9IayWzMFrEHxfblp6Lvf3LMq5b3uqjQeuDfaLBpAPvmcO398+mDjeYca0FGuuWjj2OWULQHHbPrtphweKLPa14O9d0nYz647d5oEid6Do7Gjn6VWXlZItF4q7WGZKTRJvO2MyQydGct5119qla7cldqG+OSNYJO3b0Z7izZOnJgSbXL/MaJDJFoDitp2RmsSxEyO53l7L8kAxnk/hkYf08pCudPmMCh45ZWMXsfSqa0BdBotsg9e+9ex+ut81cyzfSQFlaHjiBTuf27fhkdGxSSvjFiDKtm3q5Em0p9p8hHYMb+CfyGePdVVVzKjg6EWv3nRMSyVuM+Dz393J/FVbWHzPTyvy+oeGhhM/08Gh4cTgdHx4ZKzE4cZrrjqW8vASRR68Mbs8egcGmRS2RRQq7mLYOzDI3Zt3j92Rp+vtgYo2Lqf37ZrVnrP6Jv1e40oN5VDsRc3wKfSTTJ3s98+ZPFDkwefGKV26baKYIAETp53oHRhk5fd2MnLq9PmOnRjhM5t2jNsvW9VV3Cyqn920g/5fH83ZEJ3tbr1RNHr+K+XNk8nr07QqD515yFa94PKT74ylHe0pUm3ja4nbU20T2onW9e0ZFySySaq6isuTEbQtZI6d8RlXXSvzQJGHJusYVlW9A4NZewalCfjy9Ys5c+pkRkZtXIPi8Mgo9/x497iLd6GlvPT+6fzMX7UlMU9x1TJeqnStzKue8nC8QvXLzeiO3l1sfO5AwVVMBuOqjTKPTlcrZVYt5eucjvbY6qokg0PD9A4MjlVXndPR7lU1rmV5iSIP09u96ikfd/Tu4vFn9xfdDlEpqTaxcvkC7t68O+/qKggC15J7fxoEmOUL/MfiWpZ/9/PgU43nZ+NzB3LvVANnTplMz5LOonoeHTsxMtYYXl/hz7nq8aqnPPgI1tx6BwbrriSRVmrX1OGR0aKrvJxrBl6iyJPPIJss3XW03nn/eOeK47+cPN3z4921zkLdaoSuo12rtnj/eOeK5IEiT179lMx7AznX3DxQuJK1eWu/c03NA4UrST03YjvnysN7PeWpPeUxNSoYvLaDEa/2d67p+dUvTydPmfd8CvUODPK5TR4kXHPyqtSJPFDkaWTUfFrm0Lq+PXiMcM3Kq1In8kBRAJ8YLuC9nFwz8/LERDkDhaQNkg5Leilm222STNLs8O9Zkp6U9HtJD2Xse5GkXZL2SvqKFJTvJE2VtClMf05SV+SYFZJeDh8rSn63JcpcE6FVedHcNTMvT0yUT4niUeCKzERJ84DLgf2R5D8AdwK3xZznq8CtwAXhI33OW4BjZnY+sB54MDz/TGANcAlwMbBG0ow88lsxH3zPnFq+fN3worlzrSVnoDCzp4CjMZvWA18gEoDN7A0z+xeCgDFG0tnAO8zsGTMz4DGgJ9x8DfCN8PkTwIfC0sZyYKuZHTWzY8BWYgJWNT3+7H4uXbut5Ru1vUThXGspqo1C0tXAoJntzPOQTuBg5O+DYVp62wEAMzsJHAdmRdNjjsnMz62S+iX1HzlyJO/3UYz00pqtHCy8ROFcayk4UEiaBtwO3FXIYTFplmNbtmPGJ5o9bGbdZtY9Z07lq4eSltZsFZ3eVuOa2M1Lz611FupOMSWK84D5wE5J+4C5wIuS3pnlmIPhfmlzgUORbfMAJE0GphNUdY2lxxxTc63cA8oX8XHN7P6eRbXOQt0p+PduZrvM7Cwz6zKzLoIL+oVm9pssx7wGvC5padj+8EngR+HmzUC6R9N1wLawHaMPWCZpRtiIvSxMqwut3AOqZ0kn06f5qn/OtYp8usduBJ4BFkg6KOmWHPvvA/4e+K/h/u8NN30K+AdgL/AK8JMw/RFglqS9wOeAVQBmdhS4D3ghfNwbptVce6qNlcsX1DobNeWz6bpm1crtj0lyzvVkZjfm2N6V7e9Iej/wvpj0PwAfTzhmA7AhVx6raca0FGuuWkjPkth29ZZwR2/9L1LkXLHW9e1p6d93HK9qLtC0cP3lVlava2M7Vw4+88BEHigK1MqN2GnePdY1Mx8lNJEHigK1ciO2c63Ab4Mm8kBRoFZvxHbOtR4PFAVq9fYJgEleNndNzL/fE3mgKMCZU9pqnYW6cMrL5q6J+fd7Il8KlWCSu3waaD96YSe9A4Os69vDoaFhzuloZ+XyBV7KcK6J+BQ1E3mgIP9ePI8/u59NLxxgZDTYPz1BIHiVlHPNYJK8HTKOVz1R2LTZ6SCR1moTBPqoVdfM/uzdM/2mL4YHCkofF9BKYyvu3ry71llwrmKe/fdjtc5CXfJAQem9HFppbMXQsM/x5JqXDyaN54GC0no5+ASBzjUXn8tsIg8UJejsaOeBaxe1VJ1myr8xrsn5XGYTea8noD01ieGRUwUd09nRztOrLqtQjupXgR+Tcw3Hq58m8vtD4IxU4QPpvLrJueZUSC/IVuGBAhgqcBGeNh/j71zTuvGSebl3ajEeKICOApf1HD1lLTV2wrlW4mtmT+SBAiimSrKVxk4451qbBwrgeBFjA1pp7IRzrcLbJ+J5oADOKKLPpzdmO9d8vH0iXs4rpKQNkg5Leilm222STNLsSNpqSXsl7ZG0PJL+8zBtR/g4K0yfKmlTeMxzkroix6yQ9HL4WFHyu03w5knv8+lcK5skuHnpud4+kSCfcRSPAg8Bj0UTJc0DLgf2R9LeC9wALATOAX4m6Y/NbDTc5SYz6884/y3AMTM7X9INwIPA9ZJmAmuAboLVCbdL2mxmZZ+MpZiR2ev69rTUQDvnCjVjWopjBfYorIVWHRNViJwlCjN7Cjgas2k98AXGLzF7DfAdM3vTzF4F9gIX53iJa4BvhM+fAD4kScByYKuZHQ2Dw1bgilz5LUYx9ZKDQ8M+k6pzWTRCkADvmJKPotooJF0NDJrZzoxNnUB0/PvBMC3t62G1051hMBh3jJmdBI4Ds/I4VzQ/t0rql9R/5MiRgt9PsfWSq3+wy4OFK1hnRztT2rzRtF54x5TcCg4UkqYBtwN3xW2OSUuXOG4ys0XAX4SPT+Q4Jtu5xieaPWxm3WbWPWfOnGzZj1VsvWSrrUXhSpeu5nhr1KeJqBcn3jrpN3w5FFOiOA+YD+yUtA+YC7wo6Z0Ed/3R2/O5wCEAMxsM/30d+Danq6TGjpE0GZhOUNWVeK5KKHawtRdbXSG6ZrWz+J6f1jobVdPRnqKjvbABrdV27MSI1w7kUHCgMLNdZnaWmXWZWRfBBf1CM/sNsBm4IezJNB+4AHhe0uR0zyhJKeAjQLoX1WYg3aPpOmCbmRnQByyTNEPSDGBZmFYRxU41Pr3OfwSuvvzrK0dbZk2P9lQbd1+9kDOn1v/co147kF3O/0FJG4EPALMlHQTWmNkjcfua2W5J3wX+DTgJ/J2ZjUo6E+gLg0Qb8DPga+FhjwDflLSXoCRxQ3iuo5LuA14I97vXzOIa1cuis6OdwSJKB29Eiq3r+vZwaGiYczraWbl8gfeKchOUWuGUmiRGSllApcLaJEbN6Iz8Bj67aUets5UXrx1IljNQmNmNObZ3Zfz9ReCLGWlvABclHP8H4OMJ2zYAG3LlsRxWLl/AZ4r4Qo+MGndv3s2bJ08xPBL0Ah4cGmb1D4LFTzxY5CaCBsViAnUraZNY9/H3A8GStPVUMmmbJL708ffHft+T/m9F6YGznLxRO5mPzA6VckEfGh4ZCxJpXpTNX7oE5l/GZO2pNr70V8GFuGdJJ3dfvZDOOrqw3XjxvMTf0MrlC2jPmMpfwE1Lz+XL1y+uizYMX6kyO/9tVlCzFWUr0diX/oH2LOnk769fTHuTLqE3Y1qKaUW+t8yVFHsHBln5xM6sJbBqz4T/5K+Su6X3LOnkYxd1juvGaMD3twffpx1rlrFv7ZV8+frFFc1jklZcqbJQ9d/K1MCarSh7z493l+U8bRKnzCa05aTvltN6BwZZ/YNfZF19UCpu9t9q+vL1i+lZ0sn8VVsKPlYwYdTwPT/ezUiW7rWpNnH9n87j8Wf3J+5Tbrluip781ZEJ1UzpUnf0/39d356qVkH6qOz8NOftWx1ItanpirLlGml7yoxX117J06suy3oX17Okk5lnTs1+sjoPEp0d7WPvsZgbh7hjsv0/dHa0s+6691d9zqJJEvNXbeHStdtiS55JgSQzPa6aqlKET+6ZLw8UlVLnF7BaKuSCmetO9ZyO9rqo404SvRAVehEspt48V/CtlFEzjNMdOTKDRdL/eWZ6z5JOHrh20Vj7S6Wm/U63kXh1U348UFTISBOugleOC3KhF79sQSV9ro+8/+yS85WklAtVR3tq3IUoehFUjnNnqzdP+n/ITK9GAI1rC4nryBEXJJO+Cz1LOnl61WXsW3slrzzwYfatvbIseR2bM6ijnfXXL/aZYgvggaKCku6GewcGuXTttqxF9XpUjgtyoY2GSXfhM6alxs6VrSG1FO2pNm68ZF7sXDIQXIjTjbBxF8G7r1444Zj0RfDVtVfypb96f+xxX75+cdaSwd1XLySVcYVOTdKE14vbr9yS2ocyv/uZQTLfBuT0b6UseeV0m4SXJArjjdkVFHc3HDTQ7mrIMRelXpCj9fX5Su+fbTBjJXqXzZiWYs1VC+lZ0pnYKJxeGTGfPMap9HHR/SrRQDxjWoppUybHnjvuu5/ZWSGXzN9KOTRbT8Rq8UBRIUnF6nV9exLHXNR7oCj1R1Zsw2GuC0wlBusN3LVs7HnSqP3oxbDQi2C1jovu9+7VW4qeqiZTqk2suSoowWRezMsxJqF3YJDPf3cno2Xu0tYxrX7bs+qZVz1VSFKxOt/eH/WolB9ZZn19OZW7p0xm3X4h9ev17L9ccm7ZzrXuutOD/4qpUsomXZIod5CA+u9KXa+8RFEB2apYku5+G2HMRbE/sqT6+nLJrIqZ3p7ijbdOZh1rkCSurr/YKqJ6c3/PorKMrcj8fhdbKkoSV+oul+N1NO1JI/FAUQFDJ95i/qotsReUlcsXVKSoXg2F/MgUTuRTrYtq3GC9XHXzAtZfvzivAFDui2GtFDv5ZVo1vquVLF03wg1ZPfJAEXHmlDbeeKv0O5n0OeIaqhv57nR6eyr/iegMXi1Tt8ZipD/PbPXc54R3xo3w2ZfLyuULWPm9nYkz0GabqO/MKW188aOVn+qiowxrbV963kxe3H+8IW/I6pEHiohTFajAjGuobtSL0+/fPJn3vpW6c0uXFHIF2XzquVvxopH+rOJmn00Hgnt+vDv2Qt0xbUpVvrfl+Bnu+49hHrh2UUPekNUjDxQR2eYUKkUjNFTn42SeXWbaJlVm+pJCuhbnqueuZON6vct1o5K0fkS1vsflaEc4NDTcsDdk9cgDRRW0Wr3o1DZV5AdaSNfibBe1Sjeu17u4Uhmcrg6dFC4+lKlaqzkmdfjoaE/x+h9O5tUbqtV+c5Xm3WMjZlSoj/WhoWHu6N1VkXPXoxNVLpnFpSddKNqklp5SOl0qGxwaHpub6XObdvCZTTvG0pIuxNHVHCspqTvy3VcvjB3NnsnbIsrPA0VEegBRuRnw+LP7uaN3V8NO31EP8p1YDpIvNunFf1pVXKks37A+Mlqd+cuyjc1ImjQw/a+vLVEZXvUU0bOks6jlUPP1+LP7+f72wYacvqNQvQODZX9PhXQtbuTeZZVUajtDtdopsrUveNtD9XmgqLJGnb6jUPf8eHfZ31OhF3+/oExU6nQn1WqnKEW+PeNc/jxQZPijt0/ht6+/VdXXHBwa5tK125rqC12uRY4y+cW/NHGlsiSTxIS5odLtFPX6f9DIk27Ws5xtFJI2SDos6aWYbbdJMkmzI2mrJe2VtEfS8kj6RZJ2hdu+IgWVipKmStoUpj8nqStyzApJL4ePFSW/2xx6BwY5XOUgkZa04Itz5ZRZ/9/RniLVNn4qcgE3Lz03tvRQrXaKYmXrGeeKl0+J4lHgIeCxaKKkecDlwP5I2nuBG4CFwDnAzyT9sZmNAl8FbgWeBf4JuAL4CXALcMzMzpd0A/AgcL2kmcAaoJugPXi7pM1mdqz4t5vdur49NV2YLrMaqpGL0PW86lyrS5ruJPN79q2EeaHqeVxQI0+6Wc9yBgozeyp6lx+xHvgC8KNI2jXAd8zsTeBVSXuBiyXtA95hZs8ASHoM6CEIFNcAd4fHPwE8FJY2lgNbzexoeMxWguCysbC3mL9qLuqeJP2FzrcIXchI5XyDTnSepLawT31nAf3S4ybWc/UrqTqvESewbMQ8N4KiusdKuhoYNLOdGZs6gQORvw+GaZ3h88z0cceY2UngODAry7ni8nOrpH5J/UeOFL+4TqXW5y3EOR3tY3Px5ypCx/WJj6u+yne/zH3hdJ/6fIJouivjuo+3dhfUZtGI06s3Yp4bQcGN2ZKmAbcDy+I2x6RZlvRijxmfaPYw8DBAd3d30bVHlZj/vlBds9qzzlEULULnO1K5kBHNpUzxXMtJAF35NWIX40bMcyMoptfTecB8YGfYHj0XeFHSxQR3/fMi+84FDoXpc2PSiRxzUNJkYDpwNEz/QMYxPy8iv3krdQrmcnj6laNZt0eL0El5zayPLaTe1utyXVQj9jJrxDzXu4Krnsxsl5mdZWZdZtZFcEG/0Mx+A2wGbgh7Ms0HLgCeN7PXgNclLQ3bHz7J6baNzUC6R9N1wDYzM6APWCZphqQZBCWYvuLfam71XjyNFqF7BwZji1wwsT62kBHNXpfrnMuUs0QhaSPBnf1sSQeBNWb2SNy+ZrZb0neBfwNOAn8X9ngC+BRBD6p2gkbsn4TpjwDfDBu+jxL0msLMjkq6D3gh3O/edMN2pVR6ZHapPnbR6Tule368O7GH1uDQMF2rtuQ8X+Z+01KTGBmtzDxNzlVKI/cObBT59Hq6Mcf2roy/vwh8MWa/fuB9Mel/AD6ecO4NwIZceSynbAu31NrG5w/Q/a6ZQGUGtFVqMj/nKsUH2FWHj8zOUK9BAmD0VH0PdnKu2grpqOGK57PHZihkvEAtHBoarssG58mTat+12LUeH2BXHR4oMqxcviCxkbgeGPVZ6smcBsK5aiiko4YrngeKDD1LOrlp6bm1zkbDqdQyss5l4wPsqsMDRYz7exbVOgvOuTxkW+TIlY83ZruyqNQyss7l4gPsKs9LFDF8qu/CVWoZWedc7XmgyNA7MMjK72XOdehy8Ts655qXB4oM6/r2MJK5rJdzzrUwDxQZvP+1c86N54Eig/e/ds658TxQZFi5fAEpH2XsnHNjvHtshnSjbD3PIuucc9XkJYoYPUs663oaD+ecqyYPFAm8rcI55wIeKBL4XDHOORfwQJHAB5A551zAA0UW9b42hXPOVYMHiizipjB2zrlW491js0hXP63r28Ogj9hO5CUv55pbzhKFpA2SDkt6KZJ2n6RfSNoh6aeSzgnTp0j6uqRdknZK+kDkmJ9L2hMes0PSWWH6VEmbJO2V9JykrsgxKyS9HD5WlPF9561nSSdPr7qMm30xo0Te8O9cc8un6ulR4IqMtHVm9idmthj4R+CuMP2/AZjZIuBy4EuSoq9xk5ktDh+Hw7RbgGNmdj6wHngQQNJMYA1wCXAxsEbSjALfX9nc37PIg0WML1+/2Bv+nWtyOauezOyp6F1+mPb/In+eyellnN8L/HO4z2FJQ0A38HyWl7gGuDt8/gTwkCQBy4GtZnYUQNJWgoC1MVeeK+X+nkW++p1zruUU3Zgt6YuSDgA3cbpEsRO4RtJkSfOBi4B5kcO+HlY73RkGA4BO4ACAmZ0EjgOzoumhg2FaXF5uldQvqf/IkSPFviXnnHMxig4UZna7mc0DvgV8OkzeQHBB7we+DPwrcDLcdlNYJfUX4eMTYXrcbBmWJT0uLw+bWbeZdc+ZM6eId+Occy5JObrHfhv4GAQlAjP7bNgGcQ3QAbwcbhsM/309PObi8PiDhKUOSZOB6cDRaHpoLnCoDPl1zjlXgKIChaQLIn9eDfwqTJ8m6czw+eXASTP7t7AqanaYngI+AqR7UW0G0j2argO2mZkBfcAySTPCRuxlYZpzzrkqytmYLWkj8AFgtqSDBD2RPixpAXAK+DXwN+HuZwF9kk4Bg5yuXpoapqeANuBnwNfCbY8A35S0l6AkcQOAmR2VdB/wQrjfvemGbeecc9Wj4Oa9eUg6QhC8ijUb+F2ZslNJjZDPRsgjeD7LzfNZXtXK57vMLLaRt+kCRakk9ZtZd63zkUsj5LMR8giez3LzfJZXPeTT53pyzjmXlQcK55xzWXmgmOjhWmcgT42Qz0bII3g+y83zWV41z6e3UTjnnMvKSxTOOeey8kDhnHMuKw8UIUlXhOtl7JW0qkZ52Beu5bFDUn+YNlPS1nBNjq3RqdYlrQ7zu0fS8kj6ReF59kr6SmQCxmLzFbcmSdnylW1NkjLk825Jg5F1UD5cy3xKmifpSUm/lLRb0n8P0+vq88ySz3r7PM+Q9LyC9W92S7qnTj/PpHzW1eeZyMxa/kEwWvwV4N3AFIJZcN9bg3zsA2ZnpP1PYFX4fBXwYPj8vWE+pwLzw/y3hdueB/6MYGLFnwB/WWK+/hNwIfBSJfIF/C3wv8LnNwCbypjPu4HbYvatST6Bs4ELw+dvB/5vmJe6+jyz5LPePk8Bbwufp4DngKV1+Hkm5bOuPs+kh5coAhcDe83s383sLeA7BOtk1INrgG+Ez78B9ETSv2Nmb5rZq8Be4GJJZwPvMLNnLPjGPBY5pihm9hTB9CqVylf0XE8AH0rfJZUhn0lqkk8ze83MXgyfvw78kmD6/Lr6PLPkM0mt8mlm9vvwz1T4MOrv80zKZ5Ka/Y7ieKAI5L32RYUZ8FNJ2yXdGqb9kZm9BsGPl2A+LUjOc2f4PDO93MqZr6Q1Scrl0wqW7t0QqYKoeT7DqoElBHeXdft5ZuQT6uzzlNQmaQdwmGCxs7r8PBPyCXX2ecbxQBHIe+2LCrvUzC4E/hL4O0n/Kcu+Ja/jUSHF5KuSef4qcB6wGHgN+FKO16xKPiW9Dfg+8Bkbv2LkhF0TXrNW+ay7z9PMRi1YlnkuwV33+7LsXm/5rLvPM44HikBdrH1hZofCfw8DPySoEvttWNwk/De91nhSng+GzzPTy62c+Upak6RkZvbb8Ad6imDG4gnroFQ7nwpmUf4+8C0z+0GYXHefZ1w+6/HzTDOzIeDnBEsm193nGZfPev48ozxQBF4ALpA0X9IUgoagzdXMgKQzJb09/Zxg/Y2XGL9exwrgR+HzzcANYU+H+cAFwPNhMft1SUvD+slPRo4pp3LmK2lNkpKlLxahjzJ+HZSq5zM85yPAL83s7yOb6urzTMpnHX6ecyR1hM/bgf9MsD5OvX2esfmst88zUbGt4M32AD5M0LPjFeD2Grz+uwl6OewEdqfzQFDH+M8EKwX+MzAzcsztYX73EOnZBHSHX7hXgIcIR+CXkLeNBMXiEYK7llvKmS/gDOB7BA12zwPvLmM+vwnsAn5B8EM6u5b5BP6coDrgF8CO8PHhevs8s+Sz3j7PPwEGwvy8BNxV7t9NhfNZV59n0sOn8HDOOZeVVz0555zLygOFc865rDxQOOecy8oDhXPOuaw8UDjnnMvKA4VzzrmsPFA455zL6v8D+l94IlnLrrMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=3)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm.solver(print_step=50_000,options=codeParams,)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.neuralNetwork.save(name=algorithm.name)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[0.0001, 1, 0]-stage 0-1682148921'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.name" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "9963 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9846, 0.9795, 0.9847, 0.9846, 0.9876, 0.9836, 0.9863, 0.9876, 0.9867,\n", + " 0.9797, 0.9856, 0.9800, 0.9846, 0.9898, 0.9834, 0.9833, 0.9854, 0.9870,\n", + " 0.9870, 0.9932, 0.9866, 0.9875, 0.9812, 0.9855, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "5937 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460,\n", + " 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460,\n", + " 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 1.1460, 0.5695]) return= 142526.17684561815\n", + "probs of actions: tensor([0.8758, 0.9059, 0.0969, 0.8857, 0.8430, 0.8771, 0.8852, 0.8644, 0.9249,\n", + " 0.8842, 0.8962, 0.8955, 0.8634, 0.9031, 0.8912, 0.8832, 0.1186, 0.8325,\n", + " 0.8951, 0.2176, 0.8052, 0.8722, 0.8843, 0.9990, 0.9656],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5606, 0.5612, 0.5692, 0.5732, 0.5752, 0.5762, 0.5767,\n", + " 0.5769, 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776, 0.5696,\n", + " 0.5734, 0.5757, 0.5687, 0.5729, 0.5751, 0.5761, 0.5771])\n", + "finalReturns: tensor([0.0072, 0.0076])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "2331 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0004, grad_fn=) , base rewards= tensor([1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120,\n", + " 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.7120,\n", + " 1.7120, 1.7120, 1.7120, 1.7120, 1.7120, 1.1344, 0.5644]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9690, 0.9803, 0.9777, 0.9759, 0.9555, 0.9699, 0.9746, 0.9711, 0.9842,\n", + " 0.9745, 0.9783, 0.9750, 0.9712, 0.9789, 0.9776, 0.9717, 0.9753, 0.9622,\n", + " 0.9748, 0.9474, 0.9378, 0.9656, 0.9990, 0.9999, 0.9697],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0200, 0.0204, 0.0132])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "2831 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0004, grad_fn=) , base rewards= tensor([2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722,\n", + " 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722, 2.2722,\n", + " 2.2722, 2.2722, 2.2722, 2.2722, 1.6946, 1.1245, 0.5602]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9906, 0.9939, 0.9930, 0.9931, 0.9840, 0.9905, 0.9928, 0.9910, 0.9957,\n", + " 0.9929, 0.9936, 0.9915, 0.9921, 0.9938, 0.9932, 0.9905, 0.9928, 0.9875,\n", + " 0.9919, 0.9825, 0.9784, 0.9990, 0.9999, 1.0000, 0.9793],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0370, 0.0374, 0.0303, 0.0174])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "243 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0005, grad_fn=) , base rewards= tensor([2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292,\n", + " 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292, 2.8292,\n", + " 2.8292, 2.8292, 2.8292, 2.2516, 1.6815, 1.1172, 0.5570]) return= 142815.5210190614\n", + "probs of actions: tensor([0.9951, 0.9966, 0.9964, 0.9965, 0.0087, 0.9952, 0.9962, 0.9954, 0.9977,\n", + " 0.9964, 0.9968, 0.9952, 0.9961, 0.9965, 0.9964, 0.9949, 0.9961, 0.9938,\n", + " 0.9955, 0.9903, 0.9990, 0.9995, 0.9999, 1.0000, 0.9801],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5733, 0.5675, 0.5723, 0.5748, 0.5760,\n", + " 0.5766, 0.5769, 0.5770, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0572, 0.0576, 0.0505, 0.0376, 0.0206])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "152 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0006, grad_fn=) , base rewards= tensor([3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838,\n", + " 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838, 3.3838,\n", + " 3.3838, 3.3838, 2.8062, 2.2362, 1.6718, 1.1117, 0.5546]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9956, 0.9968, 0.9967, 0.9970, 0.9920, 0.9958, 0.9966, 0.9960, 0.9979,\n", + " 0.9968, 0.9973, 0.9956, 0.9966, 0.9968, 0.9969, 0.9953, 0.9966, 0.9947,\n", + " 0.9960, 0.9990, 0.9995, 0.9994, 1.0000, 1.0000, 0.9835],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.0798, 0.0802, 0.0730, 0.0602, 0.0431, 0.0230])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAtIUlEQVR4nO3df5BdZZ3n8fe3O03ooNL5OUonsSNQccUogZ4ks5mZGrFIM6LQIg4wQTNV1DDrjFWjLu2GRQwCDmFTTizLGndxiMgPY8aIbUbWbTMTLWoyEAl0msBolmSISW5wEkyaRdJAp/PdP85zO6dv7o9zf/W9t/vzqrqV28855/a5J6fP95zn+T7PY+6OiIhILk213gEREalvChQiIpKXAoWIiOSlQCEiInkpUIiISF5Tar0DlTZr1izv6Oio9W6IiDSUp59++mV3n51t2YQLFB0dHezcubPWuyEi0lDM7Fe5lqnqSURE8lKgEBGRvBQoREQkr4KBwsw2mNkRM3suy7JbzMzNbFb4eYmZ7QqvATP7aGzdS81st5ntNbOvmZmF8qlmtimU7zCzjtg2q8zshfBaVZFvLCIiRUnyRPEAcEVmoZnNAy4HDsSKnwM63f3isM3/MrN0g/k3gJuBC8Mr/Zk3Acfd/QJgPXBv+PwZwBpgKbAEWGNm04v4biIiUgEFs57c/fH4XX7MeuDzwA9j656ILT8bcAAzewfwNnd/Ivz8INAN/Bi4GrgjbLMZ+Hp42ugCtrr7sbDNVqLgsjHxtxOZRHr7U9yx5XkGh4bHlDcZ/OnS+dzdvajg+tOntbDmIxfRvbg972dOa2liakszgyeGOa+tlZ6uhWO2Wde3h8ODQ0xpguFT1fi2Usj+tVdW7LNKSo81s6uAlLsPhBqk+LKlwAbgncAn3P2kmbUDh2KrHQLaw/t24CBAWPcVYGa8PMs2mb/zZqKnFebPn1/KVxJpaL39KXq+N8DwqTNHgz7l8PCT0YN/OljkWv/4iWF6Ng+M/pzrM08Mn+JEiACpwSFufXT36LJbH93N0PAIoCBRSx2rH6tYsCg6UJjZNOA2YEW25e6+A7jIzP4T8G0z+zFg2VZNf2SOZfm2yfyd9wH3AXR2dmrcdJl01vXtyXpBj9u44+BooMi3/vCIs65vT/S+wGemDQ2PjG6TDhIycZSS9XQ+sAAYMLP9wFzgGTN7e3wld/8F8BrwXqKngbmxxXOBw+H9IWAeQGjPOBc4Fi/Pso2IxBweHCq4zkhs7plC6x8eHEr0meVuI42h6EDh7rvdfY67d7h7B9EF/RJ3/7WZLUg3XpvZO4GFwH53fwl41cyWhfaHT3K6bWMLkM5ouhbY5tFsSn3ACjObHhqxV4QyEclwXltrwXWaY9XEhdY/r6010WeWu400hiTpsRuBJ4CFZnbIzG7Ks/rvEz1p7AJ+APylu78cln0K+HtgL7CPqCEb4H5gppntBT4HrAYIjdh3AU+F153phm0RGaunayEtTdlqa0+7YenpB/R867c0Gz1dC+mYmfyi39rSTE/XQnq6FtLa0px4O2kMSbKebiiwvCP2/iHgoRzr7SSqhsosfx34eI5tNhA1jItIHumMo6RZT7nWT2c9Afzrvvz3ZdOntWTNeoKoDSSlaqiaqnnWk4jUn+7F7WMu1vmkU1hfGRqmrbUFMxg8Mcy0s6JLwrq+PdkzRwID+r+YNZ9ldD86Vj9W5DcYH5kX0OVrtxUV1Ax4MeFFON8xiO9Hrn1ob2tl++rLil6v0sx9YiUJdXZ2ukaPlckq3och251+ep14Cmum1pbmgplLba0t7FozNlDk6nMh48Mg5/95ou3Nnnb3zqzLFChEGssXenezccdBRtwxojaFN0dq+3ds5Mhdl5q4cdmZHSwLyRcoNCigSAP5Qu9uHn7ywGiqq0PNg0R6P6R+PPzkAXr7UxX7PAUKkQayccfBwiuJwGgHyEpQoBBpICMTrKpYqqeSnR8VKEQaSLPl7yshklbJzo8KFCINJN5pTiSXJos6VVaK+lGINJB0Jks860mVURI3dUoT937sfSWlyOai9FiRBlevHdsk6ghXar+G8aZ+FCINIrPD3AfePZuf/vIohweHOLuliTdOniLhyN8ywTUbpDOjMyecKkW+QKGqJ5E6kdljOjU4NDrhEMCQZgGSmHj3mfiEU9V4elFjtkidWNe3R5P+SMniE05VmgKFSJ3QpD9SrmqdQwoUInVCk/5Iuap1DqmNQqTG0g3YqcEhpbtKydITTlWDnihEaijdgJ2eY8CJRmKFKLXyxmXzadeThhQwfVoL6659f9XScPVEIVID8aeITM7p/Pt0qqxMPu1trXTMbGV7npkGl58/g0f+/Peqvi8KFCLjrNDEQRClxhZaRyLpGefyBd9SnHNWM1/+6CI+u2lXwerA6dNauPJ972DTzw8Qz2Jefv4MPt45v+BkUrn09qfY/5uhkratJHW4Exknlb6QSeMyYOWy+QBj+sqkNZux7F3TeebAK2NuFlpbmrnnmkVVCRZlTVxkZhvM7IiZPZdl2S1m5mY2K/x8uZk9bWa7w7+Xxdb9mZntMbNd4TUnlE81s01mttfMdphZR2ybVWb2QnitKuG7i9SFzLYImdycKEBkCxIQDSe/fd+xM54oh4ZHqtZXIp8kjdkPAFdkFprZPOByIP5NXwY+4u6LgFXAQxmbrXT3i8PrSCi7CTju7hcA64F7w+fPANYAS4ElwBozm570i4nUE3Wmk0qpRZtVwUDh7o8D2VpT1gOfJ5bN5+797n44/Pg8cLaZTS3wK64Gvh3ebwY+aGYGdAFb3f2Yux8HtpIlYIk0AjVIS6XUor9NSemxZnYVkHL3gTyrfQzod/c3YmXfCtVOt4dgANAOHARw95PAK8DMeHlwKJRl25+bzWynme08evRoKV9JpKrUmU4qobWluWp9JfIpOlCY2TTgNuCLeda5iKgK6S9ixStDldQfhNcn0qtn+QjPU35moft97t7p7p2zZ88u/CVExllP10JaW5prvRvSYJafP4P2tlaMKF22Wg3ZhZSSHns+sAAYCA8Fc4FnzGyJu//azOYCPwA+6e770hu5eyr8+6qZfYeo3eFBoieFecAhM5sCnEtU1XUI+KPY750L/KyE/RWpufQfdzpNcmLlGlbf77z1LN446QwODdd6V4BoBrlyhntvMvjTpfmznm5YOm90oqpaKzpQuPtuYE76ZzPbD3S6+8tm1gY8Btzq7ttj60wB2sI6LcCHgX8Ki7cQNXw/AVwLbHN3N7M+4G9iDdgrgFuL3V+RetG9uH00YCy+8yccP1EfF716Z8CO2y6v9W5UTb0Eg3wKBgoz20h0Zz/LzA4Ba9z9/hyrfxq4ALjdzG4PZSuA14C+ECSaiYLEN8Py+4GHzGwv0ZPE9QDufszM7gKeCuvd6e65uyiKNIB0XwoFieQcWL5222jdfDGd13r7U9yx5fnRJ5EmIHNWj/T4WqXcxWd+PiSbRChzgqp6nwVPHe5ExkmSHtmSW0uTgUXzLsTL3nL2FAZPDI+54Ga7gCe1/PwZ7P/NEKnBIZrNGHHPOqXpF3p35+wHAXDjsvlZg06286CaHemS0gx3InVAfSnKM5ylUWD4lI8+naWHPdn5q2N8/+lUycc6PrbSSLiRTn82MBqIHskTJAAeefIAne+cccbFP9t5kO5IV69PFRo9VmScqC9F9Q0Nj7Bxx8GqBOR4r+h1fXsKJiR4WC9TrvOgns8PBQqRcaK+FONjpIrV6emLedKLerb1cp0H9Xx+KFCIjJOeroX6gytTS3O27lVjNVvhdUqVvpgnvahnWy9bn5padaRLSuetyDjKzLiR4qy79v2jHdDaWlvOCBytLc3csHReSZ0bmyxqyM61bfxinqQDZa6Lf/fidu65ZlFddKRLSo3ZIuOkFqN+TiTtba1j+qJA7jTTznfOyJl+mpkRlZnOGh8OPlfWU2YHyvPaWvnAu2fz018eTZTymvk96p3SY0XGyYLVj6lHdonqIX10olN6rEiN9fanar0LDStbHwYZXwoUIlXW25/icwmm05Tstq++rPBKUlVqzBapsnV9e9SILQ1NgUKkyuq5I5VIEqp6ChptkC5pHOe2ttTN8NiNZvq0llrvgqBAAZw5SFfmuC4i5ahi/68J73WNjVUXVPVE/kG6RMo1qCHFSzY0rNadeqBAQfQEUUy5SDHqeQwfkSQUKMg9Nkw1x4yRyaOex/Cpd5Vso+jtT7F87TYWrH6M5Wu3qW9LERQoyD3aZDVHoZTJQ+1cpZv1lrMq8jnpdshUmK883Q6pYJGMAgVRz89iykWKpafT0rxw5LWKfI7aIcujQEFjDvsrjUVPp7XViJMF1RMFChpz2F9pHL39KT1R1FgjThZUTwoGCjPbYGZHzOy5LMtuMTM3s1nh58vN7Gkz2x3+vSy27qWhfK+Zfc0s+ssxs6lmtimU7zCzjtg2q8zshfBaVZFvnEP34na2r76MF9deyfbVlylISEWk68b1RFGa5efPqMjnqNagPEmeKB4ArsgsNLN5wOVAfIbxl4GPuPsiYBXwUGzZN4CbgQvDK/2ZNwHH3f0CYD1wb/j8GcAaYCmwBFhjZtOTfjGRepCtblySuXDOOTzy579Xkc9SrUF5CvbMdvfH43f5MeuBzwM/jK3bH1v+PHC2mU0FZgBvc/cnAMzsQaAb+DFwNXBH2GYz8PXwtNEFbHX3Y2GbrUTBZWPyrydSW6oDL81Xr7u44hfxRpssqJ6U1EZhZlcBKXcfyLPax4B+d38DaAcOxZYdCmWEfw8CuPtJ4BVgZrw8yzZVoTxrqTTVgZdm56+O1XoXJKboQGFm04DbgC/mWecioiqkv0gXZVnNCyzLt03m77vZzHaa2c6jR4/m2q28lGct1aA68NI8/OQBvtC7u9a7IUEpTxTnAwuAATPbD8wFnjGztwOY2VzgB8An3X1f2OZQWC9tLnA4tmxe2HYKcC5wLF6eZZsx3P0+d+90987Zs2eX8JWUZy3VoaqO0n1nx4HCK8m4KDpQuPtud5/j7h3u3kF0Qb/E3X9tZm3AY8Ct7r49ts1LwKtmtiy0P3yS020bW4gavgGuBbZ5NJF3H7DCzKaHRuwVoawqco3rpDpmkdo4pUSxupEkPXYj8ASw0MwOmdlNeVb/NHABcLuZ7QqvOWHZp4C/B/YC+4gasgHuB2aa2V7gc8BqgNCIfRfwVHjdmW7YrrTe/lTWei5QHbOUb1qLuitJY0uS9XRDgeUdsfd3A3fnWG8n8N4s5a8DH8+xzQZgQ6F9LNe6vj1ZGz8M1TFL+f7mmvfxmU27ar0bDadVAbZu6H+C3NVLjuqYpXw6h4rXBNxzzftqvRsSKFCQu3pJgwKKjD8D/nTZfAXYOqJAgbr3i9QTB376y9LS3KU6NGc2p6sG1vXt4fDgEOe1tdLTtVB3NCJV0GxWcOwrzS5ZX/REIVJlK7/5RK13oW60NBs3LJ1Hc1Ph0XTV2bV+KFCgXtlSXdv3aTiKtHPOiioxRhJ0klBn1/qhQIF6ZYuMl1eGhtm442DhFVFn13qiQIFmv5Lq0VPpWOe1tSaem0OdXeuHAgW5T8gmM/2hS1n0VHpac5PR07Uw0Wx/yjqsLwoUwAfenX0gwRF3tVVIWZS9EznnrGa+8vH30724nRuWzsu77vRpLZpUqM4oPRZ47NmXci4bGh7hji3P66SVkjSZBrfLnITo7u5FAGzccXBMNVS70tLrlp4ogOMnhvMuHxwa1lOFFK23PzXpgwRkr367u3sR++75EF+97uLR6UmlfilQJKS6ZinWf3/02VrvQl3IlRSitPTGoUCRkDKgpBi9/SlODJ+q9W7UhVzJIkpLbxwKFET1yIUoVU+KoYvdabmyl5SW3jgUKCjc2KhUPSmWLnan5WqcznXzpZuy+qNAQZSOl8/HLm1XJoYURRe7SL65hzRqc+NQoABez6gnzaQhj6VYPV0LJ2QmT0uzceOy+Ym/21vOzn0T1r24nXuuWTSa9dTe1qr+E3VKgQIYKtDoqGoEKVb34nZWLptf690o2fRpLdy4bD5trS1jytZd+37u7l6UdergbAYLpJ53L26np2sh57W1cnhwiHV9e5T1VIfU4S4BVSNIKe7uXsTDTx6oye82SHQxbw8X6FxzsKQ7x2XbLkmv80J/O+kU2XT2UzpFFjSFbD3REwXR8AL5qM5USlHLO+OkQWL76st4ce2V9HQtZF3fHhasfozla7cV3PckfxNJ2huUItsYCgYKM9tgZkfM7Lksy24xMzezWeHnmWb2UzP7rZl9PWPdn5nZHjPbFV5zQvlUM9tkZnvNbIeZdcS2WWVmL4TXqrK/bQ6nCoxmqTsbKUW9X+xOvHmS3v5U1o5vn920i448QSPJ30SSJBClyDaGJFVPDwBfBx6MF5rZPOByIP5s/TpwO/De8Mq00t13ZpTdBBx39wvM7HrgXuA6M5sBrAE6iW6QnjazLe5+PME+F6VQG4VIKer9Ynf8xDC3Prqbs1uazrirT9865aoK6u1PFazeSpIEcl6OKixV99aXgk8U7v44kG2KrvXA54mdK+7+mrv/C1HASOpq4Nvh/Wbgg2ZmQBew1d2PheCwFbiiiM+tGE1lKaU4tzV/2nU9GBoeKTjWWbaqoHV9ewpWbyVpw1CKbGMoqY3CzK4CUu4+UOSm3wrVTreHYADQDhwEcPeTwCvAzHh5cCiUZdufm81sp5ntPHq08qms2/cdUyaGFC3BtAsNI/PpKEkQMAq30yhFtjEUnfVkZtOA24AVRW660t1TZvZW4PvAJ4iqs7L9OXme8jML3e8D7gPo7Oysynid6/r26OSVohRKDa0Xba0tvHHy1BnVT3GZVUHNZgVnqnOS/d10L1aH1npXyhPF+cACYMDM9gNzgWfM7O35NnL3VPj3VeA7wJKw6BAwD8DMpgDnElV1jZYHc4HDJexvRdR7fbPUn7YCPf6r6avXXUxrvm7RQWtLM3dcddHoXT2ceYeWrSoo6XSm+ruZGIoOFO6+293nuHuHu3cQXdAvcfdf59rGzKbEMqNagA8D6SyqLUA6o+laYJu7O9AHrDCz6WY2negJpq/Y/a0UNa5JsX77eu2eKLoXt/OLu/54zHwP7W2t3Lhs/hnVPBDd+R8eHKK9rZWVWdbJvONvT/j3oL+biSFJeuxG4AlgoZkdMrObCqy/H/hb4M/C+u8BpgJ9ZvYssAtIAd8Mm9wPzDSzvcDngNUA7n4MuAt4KrzuDGU1kRocSpRfLpJWy2S69Hma2fP5p788Sk/XQl5ceyXbV18GcEZq7MNPHuDEmydZf93FbF99WdZqoUr1o5DGYJ7wEbJRdHZ2+s6dmRm4+XWsfizxuq0tzWpsk4J6+1N8ZtOumv3+dGe6zJ7Paeec1cyXP7qIdX17cjZMFzrX8/3daFrTxmNmT7t7Z7ZlGsKjSOlUQf0BSD617myXGhxiwerHaMrR6PzamyP0bB5geCT3jWKhcz3XMB7pICUTh4bwKIEa6KSQejhHnPyNzsMjTnOBHN5830N9ICYPBYoSqIFOCmmUc2TE/YyLfVy+76E+EJOHAkWRdMckSTTKOZK+uLdl6UWuc13SFCgS0h2TFKNW50ihqqS4lmYbbXDetWbFGam0hc71bIMJ3vrobmUGTkBqzE6obVqLsjgksVpdLNNVSfl6Wadd97vzxpzPxfaQzjdEuP5OJhY9USSUHmlTd0uSRK2yntJPArl6WceVO8WvhgifPBQogGkJhjoATagiydXiYmkw+tS7ffVl7F97Jeuvuzjn+uXuY66G7kZpyJfkFCiAqXmyPjLpbkmSqMXFMlsibPfi9pzDbZS7j0qPnTwUKChulE/dLUkSH3j37Jr83mzVo9W6oCs9dvJQYzZw1pQm3jiZbGCeWl0ApLGUW/9fqmyNyen36YH/zqvg8BoaInxyUKCAxEEC4EcDL3F396Iq7o1MBLWsosz2u3VBl3Ko6qlIg0PDynySgqo9DWqzWdXaHkQyKVCUQJlPUsjwSHXHGL9h6byaNCb39qdYvnYbC1Y/pmH3JxFVPZVAmU+ST29/itfeLNzhrRzx6s9qtD1kkzlkebonNtSuJ7qMDwWKEujRXvL50j8+P26/azzbHtQTe/JS1VMJlPkk+RwvIt26FEmnIa009cSevBQoSlCr1EeRWnZoU0/syUuBogS5po4UAbIO2V0JzWY17dCmntiTlwIF8DtvPauo9ZMP5CyT0Yff/46qfO4p95q2Bagn9uRVsDHbzDYAHwaOuPt7M5bdAqwDZrv7y2Y2E9gM/C7wgLt/OrbupcADQCvwv4G/dnc3s6nAg8ClwG+A69x9f9hmFfCF8BF3u/u3y/iuOb382+LqlHNPLilSvarJeqjiUce9ySnJE8UDwBWZhWY2D7gcOBArfh24Hbgly+d8A7gZuDC80p95E3Dc3S8A1gP3hs+fAawBlgJLgDVmNj3B/hYt37zCIsWqRtVkS5Nx4s2T6r8gNVEwULj748CxLIvWA58ndoPt7q+5+78QBYxRZvYO4G3u/oS7O9ETRHdYfDWQflLYDHzQzAzoAra6+zF3Pw5sJUvAEpnoDDhFlE2lmeSkFkpqozCzq4CUuw8k3KQdOBT7+VAoSy87CODuJ4FXgJnx8izbZO7PzWa208x2Hj1a/YykpPNXiFSCAyOnxj71am4UGU9FX/HMbBpwG/DFYjbLUuYFluXbZmyh+33u3ununbNnV7+PQzHzV4hUi/ovyHgp5db4fGABMGBm+4G5wDNm9vY82xwK66XNBQ7Hls0DMLMpwLlEVV2j5Vm2qajp04pLZyxm/gqRaqmHxm2ZHIoOFO6+293nuHuHu3cQXdAvcfdf59nmJeBVM1sW2h8+CfwwLN4CrArvrwW2hXaMPmCFmU0PjdgrQlnFXfm+4tIZ9QcquZTTblBM2rX6L8h4KhgozGwj8ASw0MwOmdlNBdbfD/wt8Gdh/feERZ8C/h7YC+wDfhzK7wdmmtle4HPAagB3PwbcBTwVXneGsor70cBLRa2fGhxS5olkVU67Qa761jj1X5BaKNiPwt1vKLC8I9/PsfKdwHuzlL8OfDzHNhuADYX2sVyDQ8VXJWnkTMmm3HaDfIna7W2tbF99WVmfL1IKpe+UQZknkqla1ZKqapJaUqAokzJPJK4aF/Naj/EkokABWBmDN6lhW+K6F7eX1c+mpXnsydja0sxX/uT9ChJSUwoUQKkjeBjVuYOUxjZSxogwLU2mQfek7ihQUPqw0I4asuVMb5wsfb7sE8PVnWtbpBSaCpXSq55qNdOYTGzpQQWVWSf1Qk8UlN7TWlOiSrUps07qgQIF0FbkEB5pmhJVxoMy66TWFCiA14dHStpOf8CSqdTe+s1mOcccU2ad1JoCBTBUYgOig4bykDFKqSYy4Ct/8n7WfOQizUktdUmN2WVKDQ7RszmalkMNjlLKU+bKZfPHnDvr+vZweHCI89pa6elaqPNKak6BgmiY8eNlDB0+POJ86R+f1x+0cF5ba9FTod7dvWj0veaklnqkqieKH2Y8m3ICjUwcHTPVniATjwIFyl6Synni34sfCX/B6sfU1iV1TYGCymQvldq7WyaWUyUM3+Gc7lynYCH1SIGC8tMPW5qMO666qEJ7I5OVOtdJvVKgoPwe1tctmacGSAGgtYyRY0F9c6Q+KVBQfhtFJds4evtTLF+7TfXWDeqea95X1vbqXCf1SIGC8u/iik2HzKW3P8Wtj+4mNTikeusGVc6TpTrXSb1SoKD8u7imMiY+ilvXt4ehjOFEVG/dWFZ+84mi1m8209wTUvcKBgoz22BmR8zsuSzLbjEzN7NZsbJbzWyvme0xs65Y+c9C2a7wmhPKp5rZprDNDjPriG2zysxeCK9VZX/bHHq6Fp4xdEIxSsl0ySbXk43qrRvH9n3J02PTQ3e8uPZKtq++TEFC6laSJ4oHgCsyC81sHnA5cCBW9h7geuCisM3fmVn8CrzS3S8OryOh7CbguLtfAKwH7g2fNQNYAywFlgBrzGx6cV8vme7F7dxzzaLCK+ZRieqhXE82qreemDTxlTSKgoHC3R8Hst0mrQc+T3S+p10NfNfd33D3F4G9RBf5fK4Gvh3ebwY+aGYGdAFb3f2Yux8HtpIlYFVK9+L2nKN3JlGJ6qFsTzaqt564NPGVNIqS2ijM7Cog5e4DGYvagYOxnw+FsrRvhWqn20MwGLONu58EXgFmJvis+P7cbGY7zWzn0aOlZSD19qf47esnS9oWoobnL/TuLnl7OP1kozmTJwdNfCWNouhBAc1sGnAbsCLb4ixl6SeOle6eMrO3At8HPgE8mGebfJ81ttD9PuA+gM7OzpJaDNb17WG4zMaGh5+MauHig7wVS4PCTR4aOkYaRSlPFOcDC4ABM9sPzAWeMbO3E931z4utOxc4DODuqfDvq8B3OF0lNbqNmU0BziWq6sr5WdVQqQbjjTsOZi1X/wjJpCQFaRRFBwp33+3uc9y9w907iC7ol7j7r4EtwPUhk2kBcCHwczObks6MMrMW4MNAOotqC5DOaLoW2ObuDvQBK8xsemjEXhHKqqJSDcYjfuZTifpHTA7F/n8qSUEaRZL02I3AE8BCMztkZjflWtfdnwf+Afg34P8Af+XuI8BUoM/MngV2ASngm2Gz+4GZZrYX+BywOnzWMeAu4KnwujOUVUW5KbJxmRcM9Y+YHIr5/1SSgjSSgm0U7n5DgeUdGT9/GfhyRtlrwKU5tn8d+HiOZRuADYX2sRLS7QKf2bSr7M+69dHdYz5T/SMmh2L+P5WkII1EPbNjyk2RTct8WlD/iMmhmP9PBQlpJAoUGSo1U1387lL9IyYH/X/KRKU5szMYOXJwi+TAxV/6CWYweGKYc1tbOLulicETw5zX1kpP10LdVU4w3Yvb+W/ff5Y3Tp6q9a6IVJQCRYYKDdsEwODQ8Jj3rS3NrL/uYgWICezkSOEgUYnqTZHxpKqncaRMp4lvJMGdRpYMapG6pkCRodp3e8p0kleGKtMOJjJeVPWUYc1HLqpIimwu6cyY3v4Ud2x5frR6avq0FtZ85CJVSzWwpB3ulO0mjUZPFOOsp2shvf0per43MKYN4/iJYT6zaVfZAwtKbaR73xeibDdpRAoUGarZhmBEmTH5BiB85MkDGtqjAWXrfZ+NOtpJI1KgyFDNNoR0aMj3O5zqBiupjqTnjYKENCK1UWQ4r62VVJWCRXtba/S0UKCzRqWCVW9/inV9ezg8OFR0341ytp2Mkp43vf0pHUdpOHqiyFDN+uNpZzXxuU27CqZHOtBRYDjyQsOWf6F3N5/dtKukEWs12m3xkp43PZsHdByl4ShQZKjm3d4LR16jmD67uS7QhS7kvf0pHnnywBkPLZn9OHIFG412W7yk583wiOs4SsNRoMiirbV+es5mu0AXupCv69uTs2YrXa2VL9hotNvq0nGURqNAkYVlm4S1hjLrvgtdyPNdiNI5/PmCjUa7rS4dR2k0aszOolIjyFZSx+rHaA+Nym3TWrLuY7ptI1+c65jZyvK123I2vKbLM9vbDfjAu2eXuvsSo34U0mgUKDL09qcqNoJspaUGhxL1Gs+379v3JZskMPMzHPj+0yk63zlDWTtkzwpLSsdPGo2qnjLkq9+f7CZig3ah7LFc22S27/R8byDR7zOKn1tbpNYUKDKooTG/iXR8Sk0Dzta+k6unfSZ1qJRGpKqnDNXscDchWNRH46e/PHpGtUu2qph02bmtLbx5coQTw1GC8HgNgpiv42C+Bv30OuntU4NDNJsxUoExwidSsJXJQYEiQ0/XQm59dHeicXsmI3d4+MkDoz+n202am4yRcFc9WhVjUb8BGDuJE0QJAz2bo+qaagWL9BND+v8y/cSQ/p2Fsscyt69EkABlPUnjKVj1ZGYbzOyImT2XZdktZuZmNitWdquZ7TWzPWbWFSu/1Mx2h2VfM4uSUM1sqpltCuU7zKwjts0qM3shvFaV/W0T6F7czj3XLKqrvhTjqdT5OEYyql6GT/lokMil2p3PCvU3KZQGnHSgv2IYynqSxpOkjeIB4IrMQjObB1wOHIiVvQe4HrgobPN3ZtYcFn8DuBm4MLzSn3kTcNzdLwDWA/eGz5oBrAGWAkuANWY2vbivV5ruxe2cM3VyPWwZcOOy+az5yEXj+nurWQ1T6Imhp2shrS3NY5bFhwGvxr45ynqSxlPwaujuj8fv8mPWA58Hfhgruxr4rru/AbxoZnuBJWa2H3ibuz8BYGYPAt3Aj8M2d4TtNwNfD08bXcBWdz8WttlKFFw2FvcVSzPZ6pGnndXMi0d/O6ZaaTw4sHzttjFtB/F2hXNbWzCDwRPDRQ9OmKu9Kf3EEG+ryNaGUai9yqz4aU3bVe0kDaik22YzuwpIufuAje3G3A48Gfv5UCgbDu8zy9PbHARw95Nm9gowM16eZZvM/bmZ6GmF+fPnl/KVzjDZGrVfe3MkcR+LSku3aXzpH5/n+InhMf1Y4m0bmW0MhUa4zdbe1NrSzAfePZvla7cVHBm3UHuVAVOarWAVW3x9VTtJIyo6UJjZNOA2YEW2xVnKPE95qduMLXS/D7gPoLOzsyItjj1dC+n53kDitEcpz/ApH+1tnu+IDw2P8F//YYDPbNo1JqCkG9XjHRKnT2vhY5e286OBl0YDjuFseurg6MU9M/jExZ84st00nHKY2pQ8UPzn89VZURpTKf0ozgcWAAOhSmku8IyZvZ3orn9ebN25wOFQPjdLOfFtzGwKcC5wLM9njYvuxe285ezJ1U7RKNLZR4Uuz8dPDPOdHQd47c2To2Unhk+dcWHP1pEw3RHvswV6wg8NJx8PeP9vJs8TqkwsRQcKd9/t7nPcvcPdO4gu6Je4+6+BLcD1IZNpAVGj9c/d/SXgVTNbFtofPsnpto0tQDqj6Vpgm7s70AesMLPpoRF7RSgbN4N1OOaTFOeUk+iOP94m1dufomfzwJiOeJUw2dq9ZOIoeMtsZhuBPwJmmdkhYI27359tXXd/3sz+Afg34CTwV+6eruD9FFEGVStRI/aPQ/n9wEOh4fsYUdYU7n7MzO4Cngrr3Zlu2B4vuQbfk4knPaDi1ClNvHEy2VNCS5MVVTWp/hPSqJJkPd1QYHlHxs9fBr6cZb2dwHuzlL8OfDzHZ28ANhTax2ro7U/x29dPFl5RJpSkQQKK74CnhmxpVBrrKYd1fXvUkC15FXt6qCFbGpUCRQ6qTxYRiShQ5KD6ZKmkeps1UaQYChQ5ZBveQaRUFRpPUKQmFChySA8O2KxbQakAnUfSyBQo8uhe3M4p3QpKBVRqiHKRWlCgKEBtFVIJeqKQRqZAUUBP18Ksg06JFENPFNLIFCgK6F7czspllRmRVkSkESlQJHB39yJuVLAQkUlKgSKhu7sX1XoXpIGpjUIamQJFEUqdT1pk2bvGZRZfkapQoCjCeM8nLROH5qKQRqZAUQQN6ial0thh0sgUKIrUrn4VUgL1x5FGpkBRJM0pIKXQeSONTIGiSKp+kmJdOOccnTfS0BQoSqDqJynGvx89UetdECmLAkUJVI0gxdDwHdLoFChK0L24XX0qJDF1tpNGVzBQmNkGMztiZs/Fyu4ys2fNbJeZ/cTMzgvlZ5nZt8xst5kNmNkfxbb5mZntCdvsMrM5oXyqmW0ys71mtsPMOmLbrDKzF8JrVQW/d9nUp0KSumHpvFrvgkhZkjxRPABckVG2zt3f5+4XAz8CvhjK/xzA3RcBlwNfMbP471jp7heH15FQdhNw3N0vANYD9wKY2QxgDbAUWAKsMbO66d7avbidr153MS16JpM8blw2X8O/SMObUmgFd388fpcfyv5f7MdzgHQl7HuAfw7rHDGzQaAT+HmeX3E1cEd4vxn4upkZ0AVsdfdjAGa2lShgbSy0z+Ole3G7sllEZMIr+X7YzL5sZgeBlZx+ohgArjazKWa2ALgUiD93fytUO90eggFAO3AQwN1PAq8AM+PlwaFQlm1fbjaznWa28+jRo6V+JRERyaLkQOHut7n7POAR4NOheAPRBX0n8FXgX4GTYdnKUCX1B+H1iVCeraXP85Rn25f73L3T3Ttnz55dwrcREZFcKlHD/h3gYxA9Ebj7Z0MbxNVAG/BCWJYK/74atlkStj9EeOowsynAucCxeHkwFzhcgf0VEZEilBQozOzC2I9XAb8M5dPM7Jzw/nLgpLv/W6iKmhXKW4APA+ksqi1AOqPpWmCbuzvQB6wws+mhEXtFKBMRkXFUsDHbzDYCfwTMMrNDRJlIHzKzhcAp4FfAfwmrzwH6zOwUkOJ09dLUUN4CNAP/BHwzLLsfeMjM9hI9SVwP4O7HzOwu4Kmw3p3phm0RERk/5hOs16iZHSUKXqWaBbxcod2ZaHRsstNxyU3HJrd6OzbvdPesjbwTLlCUy8x2untnrfejHunYZKfjkpuOTW6NdGzUXUxERPJSoBARkbwUKM50X613oI7p2GSn45Kbjk1uDXNs1EYhIiJ56YlCRETyUqAQEZG8FCgCM7sizJex18xW13p/xouZ7Q/zh+wys52hbIaZbQ3zgGyND+9uZreGY7THzLpi5ZeGz9lrZl+LDfrYMHLMvVKxY5Fv7pV6l+PY3GFmqdgcMx+KLZsUx8bM5pnZT83sF2b2vJn9dSifWOeNu0/6F1Fv8X3Au4CziEbBfU+t92ucvvt+YFZG2f8AVof3q4F7w/v3hGMzFVgQjllzWPZz4PeIBnP8MfDHtf5uJRyLPwQuAZ6rxrEA/hL4n+H99cCmWn/nMo/NHcAtWdadNMcGeAdwSXj/VuD/hu8/oc4bPVFElgB73f3f3f1N4LtE82RMVlcD3w7vvw10x8q/6+5vuPuLwF5giZm9A3ibuz/h0dn8YGybhuHujxMNIxNXyWMR/6zNwAcb5ckrx7HJZdIcG3d/yd2fCe9fBX5BNB3ChDpvFCgiiee+mIAc+ImZPW1mN4ey33H3lyD6QyAawwtyH6f28D6zfCKo5LHINfdKI/u0RdMib4hVr0zKYxOqhBYDO5hg540CRSTx3BcT0HJ3vwT4Y+CvzOwP86xb9twhE0gpx2KiHadvAOcDFwMvAV8J5ZPu2JjZW4DvA5/xsTOAnrFqlrK6PzYKFJFJO/eFux8O/x4BfkBUDfcf4VGY8G96fvNcx+lQeJ9ZPhFU8ljkmnulIbn7f7j7iLufIhoN+ow5ZoIJfWzCqNjfBx5x90dD8YQ6bxQoIk8BF5rZAjM7i6jBaEuN96nqzOwcM3tr+j3RnB/PMXaOkFXAD8P7LcD1IQtjAXAh8PPwaP2qmS0LdaefjG3T6Cp5LHLNvdKQ0hfC4KOMnWNmUhyb8D3uB37h7n8bWzSxzptaZw3Uywv4EFHGwj7gtlrvzzh953cRZWAMAM+nvzdR/ec/E81O+M/AjNg2t4VjtIdYZhPQSXSh2Ad8ndDrv5FewEaiKpRhoru4myp5LICzge8RNWD+HHhXrb9zmcfmIWA38CzRxewdk+3YAL9PVA30LLArvD400c4bDeEhIiJ5qepJRETyUqAQEZG8FChERCQvBQoREclLgUJERPJSoBARkbwUKEREJK//DwJ5qahWwHeLAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "42 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0008, grad_fn=) , base rewards= tensor([3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367,\n", + " 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367, 3.9367,\n", + " 3.9367, 3.3591, 2.7891, 2.2247, 1.6645, 1.1075, 0.5529]) return= 142815.70844658214\n", + "probs of actions: tensor([0.9966, 0.9975, 0.9974, 0.0023, 0.9938, 0.9968, 0.9974, 0.9969, 0.9983,\n", + " 0.9976, 0.9980, 0.9966, 0.9974, 0.9975, 0.9976, 0.9963, 0.9973, 0.9959,\n", + " 0.9990, 0.9994, 0.9996, 0.9995, 1.0000, 1.0000, 0.9792],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5691, 0.5654, 0.5713, 0.5742, 0.5757, 0.5765,\n", + " 0.5768, 0.5770, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1041, 0.1045, 0.0973, 0.0845, 0.0675, 0.0473, 0.0247])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "39 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883,\n", + " 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883, 4.4883,\n", + " 3.9107, 3.3406, 2.7762, 2.2161, 1.6591, 1.1044, 0.5516]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9976, 0.9982, 0.9981, 0.9983, 0.9953, 0.9977, 0.9981, 0.9978, 0.9987,\n", + " 0.9983, 0.9986, 0.9975, 0.9981, 0.9982, 0.9983, 0.9973, 0.9981, 0.9990,\n", + " 0.9996, 0.9997, 0.9998, 0.9996, 1.0000, 1.0000, 0.9724],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1297, 0.1301, 0.1230, 0.1101, 0.0931, 0.0729, 0.0504, 0.0260])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "28 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388,\n", + " 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 5.0388, 4.4612,\n", + " 3.8912, 3.3268, 2.7667, 2.2097, 1.6550, 1.1021, 0.5506]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9970, 0.9978, 0.9977, 0.9980, 0.9942, 0.9971, 0.9976, 0.9973, 0.9984,\n", + " 0.9979, 0.9983, 0.9970, 0.9977, 0.9978, 0.9979, 0.9967, 0.9990, 0.9992,\n", + " 0.9996, 0.9996, 0.9997, 0.9994, 1.0000, 1.0000, 0.9768],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1564, 0.1568, 0.1496, 0.1368, 0.1197, 0.0995, 0.0770, 0.0527, 0.0270])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "30 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0014, grad_fn=) , base rewards= tensor([5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886,\n", + " 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.5886, 5.0110, 4.4410,\n", + " 3.8766, 3.3165, 2.7595, 2.2048, 1.6520, 1.1004, 0.5498]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9978, 0.9984, 0.9984, 0.9985, 0.9958, 0.9979, 0.9983, 0.9981, 0.9988,\n", + " 0.9985, 0.9988, 0.9978, 0.9983, 0.9984, 0.9985, 0.9990, 0.9996, 0.9996,\n", + " 0.9998, 0.9998, 0.9998, 0.9995, 1.0000, 1.0000, 0.9664],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.1838, 0.1842, 0.1770, 0.1642, 0.1471, 0.1269, 0.1044, 0.0800, 0.0544,\n", + " 0.0278])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "13 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379,\n", + " 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 6.1379, 5.5603, 4.9903, 4.4259,\n", + " 3.8658, 3.3087, 2.7541, 2.2012, 1.6497, 1.0991, 0.5493]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9979, 0.9984, 0.9985, 0.9986, 0.9960, 0.9980, 0.9983, 0.9982, 0.9989,\n", + " 0.9986, 0.9989, 0.9979, 0.9984, 0.9985, 0.9990, 0.9993, 0.9997, 0.9997,\n", + " 0.9998, 0.9998, 0.9998, 0.9995, 1.0000, 1.0000, 0.9668],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2117, 0.2121, 0.2049, 0.1921, 0.1750, 0.1549, 0.1323, 0.1080, 0.0823,\n", + " 0.0557, 0.0283])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "11 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.6867,\n", + " 6.6867, 6.6867, 6.6867, 6.6867, 6.6867, 6.1092, 5.5391, 4.9748, 4.4146,\n", + " 3.8576, 3.3029, 2.7501, 2.1985, 1.6479, 1.0981, 0.5489]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9982, 0.9986, 0.9986, 0.9988, 0.9964, 0.9983, 0.9985, 0.9984, 0.9990,\n", + " 0.9988, 0.9990, 0.9981, 0.9986, 0.9990, 0.9994, 0.9995, 0.9998, 0.9997,\n", + " 0.9998, 0.9998, 0.9999, 0.9996, 1.0000, 1.0000, 0.9626],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2400, 0.2404, 0.2333, 0.2204, 0.2034, 0.1832, 0.1606, 0.1363, 0.1107,\n", + " 0.0841, 0.0567, 0.0287])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "9 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0020, grad_fn=) , base rewards= tensor([7.2353, 7.2353, 7.2353, 7.2353, 7.2353, 7.2353, 7.2353, 7.2353, 7.2353,\n", + " 7.2353, 7.2353, 7.2353, 7.2353, 6.6577, 6.0877, 5.5233, 4.9631, 4.4061,\n", + " 3.8515, 3.2986, 2.7470, 2.1965, 1.6467, 1.0974, 0.5485]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9983, 0.9987, 0.9987, 0.9988, 0.9966, 0.9984, 0.9986, 0.9985, 0.9991,\n", + " 0.9988, 0.9991, 0.9983, 0.9990, 0.9993, 0.9996, 0.9996, 0.9998, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9996, 1.0000, 1.0000, 0.9619],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2687, 0.2691, 0.2619, 0.2491, 0.2321, 0.2119, 0.1893, 0.1650, 0.1394,\n", + " 0.1127, 0.0853, 0.0574, 0.0291])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAsqklEQVR4nO3dfZBV9Z3n8fe3myt2m4RuHpxoAzZRFyuECNoDzDIzFU0JTozaE82ogwlbZY27mUnVmKyk2nUMRs0Gl0pIpVKTXTMSYx4IiTGEhMkQZjBlDWtQtCFIElbcEOFiRhxo10grTfPdP865cPpyzn2+fZ8+r6pbdP/OObfPPdx7vvf38P39zN0RERFJ0lbrExARkfqmQCEiIjkpUIiISE4KFCIikpMChYiI5DSh1idQaVOnTvXe3t5an4aISEN59tlnX3X3aXHbmi5Q9Pb2smPHjlqfhohIQzGz3yZtU9OTiIjkpEAhIiI5KVCIiEhOeQOFma01s1fM7PmYbXeamZvZ1PD3BWa2M3zsMrM/j+x7uZntNrN9ZvYlM7OwfKKZrQ/Lt5tZb+SY5Wb2QvhYXpFXLCIiRSmkRvEIcHV2oZnNAK4CXooUPw/0ufu88Jj/ZWaZDvOvALcDF4ePzHPeBhx194uANcCD4fNPBlYCC4EFwEoz6y7itYmISAXkHfXk7k9Gv+VHrAE+Bfwwsu+xyPazAQcws/OAd7j7U+HvjwL9wE+A64F7w2MeA74c1jaWAlvc/Uh4zBaC4LKu4Fcn0gI2DKa5d+MehoZHztjWZvCXC2fyQP/cxP3bDE469HR1sGLpbPrn9yQ+Z2eqjYmpdoaOjXB+ZP/M867evJdDQ8OcnWpjeORkFV+15LN/1TUVe66Shsea2XVA2t13hS1I0W0LgbXABcBH3P2EmfUAByO7HQR6wp97gAMA4b6vAVOi5THHZP/N2wlqK8ycObOUlyTSkDYMplnxvV2MnIyfBfqkwzd/HlT6H+ifG7t/5sf00DB3Pb6bHb89wvqnD8Q+57GRkxwLA0Bm/4y7Ht/N8MgogIJEHegd2FSxYFF0Z7aZdQJ3A5+O2+7u2919DvCHwF1mdjZgcbtmnjJhW65jsv/mQ+7e5+5906bF5ouINKXVm/cmBomoddsPFLT/8Mgo67bHB4mk/Vdv3svqzXtPBQlpPqWMeroQmAXsMrP9wHTgOTN7Z3Qnd/8V8AbwHoLawPTI5unAofDng8AMgLA/YxJwJFoec4yIAIeGhgvabzRcd6aQ/UeLXKPm0NBwwechjanoQOHuu939XHfvdfdeghv6Ze7+OzOblem8NrMLgNnAfnd/GXjdzBaF/Q8f5XTfxkYgM6LpRmCrB6spbQaWmFl32Im9JCwTkdD5XR0F7dceNhEXsn+7xVXmc59DoechjamQ4bHrgKeA2WZ20Mxuy7H7HxPUNHYCPwD+2t1fDbd9DPgHYB/wIkFHNsDDwBQz2wd8EhgACDux7weeCR/3ZTq2RSSwYulsUm35b+y3LJxR0P4dqXYWvavwwYUdqXZWLJ3NiqWz6Ui1F3ycNBZrtqVQ+/r6XHM9SSup9Kinz/xoD0ePnflcGd2dqZyjntJqhqoLxXZkm9mz7t4Xt63pJgUUaTX983tO3awLdc7ECQwNj9Buxqj7mKGxd6zfmXicAYOfXpLzPHoHNhV1LuMl+8a5eNXWooKaAb8p8Oab6xpEzyPpHHq6Otg2cGXB+1SbahQiTSCaw5D9TT97v6ThtB2pdj73obk5A0W7GZ//i0vHPLdqErXT09VBemg4NuAXK1eNQoFCpEFkNxl1poIuxmN5chbOajeOjzbX51yStQFfuGle0cEiV6DQpIAiDSBTE4j2Q0ST33JRkGgtJ4G7Hv9FRZ9TgUKkARSaWCcClc+MV6AQaQBKaJNaUqAQaQBKaJNiFJBaU9zzVfbpRKQaCk2sE4Egd6aSFChEGkD//B5Wf/hSujpSp8oyo55Eom5dNDbBshKUcCfSIOIS6+o1ua3VlZPPUI+URyFSJ7KT5q64ZBpP/PqwFgKSMdoNMiOeuztTrLx2TkUCkqbwEKlzGwbTYxb+SQ8Nn1pwCLQQkJwWTYs5emyEFY/tAqhq7UWNnCJ1QAv/SKlGRp3Vm/dW9W8oUIjUAeVJSDmq/f5RoBCpA8qTkHJU+/2jPgqRGorOvGokLAovkkOq3VixdHZV/4ZqFCI1kunAzkzP7QRrHkAwvPLWRTPpUU1DcujuTLH6xkurPgxXNQqRcZZr/Qbn9Bh8rfHQero7U1zz3vP48a6XY1csBDjnrHY+++dzxzVHQ4FCZBxlD4ONkx4azruPnF5xrtILJ3V3pnIuBQuMWSiod0oH2148Mua8li2aSd8FkwtaTCpOOcdWgxLuRKosmkjXFt5gpDVNnNDGgze8l+/teGlMcIHT65v3XTD5jC8KmdUHqxksylq4yMzWmtkrZvZ8zLY7zczNbGr4+1Vm9qyZ7Q7/vTKy78/MbK+Z7Qwf54blE81svZntM7PtZtYbOWa5mb0QPpaX8NpFairaD+GgINHi3jpxkjvW7zwjSACcdPjmz1/i7h+cWZscHhmteq5ELoV0Zj8CXJ1daGYzgKuAlyLFrwLXuvtcYDnwjazDlrn7vPDxSlh2G3DU3S8C1gAPhs8/GVgJLAQWACvNrLvQFyZSD5RIJ8V643j8+6WWuTZ5A4W7PwmcGf6Cm/qniIzoc/dBdz8U/roHONvMJub5E9cDXw9/fgx4v5kZsBTY4u5H3P0osIWYgCVSz5RIJ5VSy1ybkobHmtl1QNrdd+XY7QZg0N3fipR9LWx2uicMBgA9wAEAdz8BvAZMiZaHDoZlcedzu5ntMLMdhw8fLuUliVSFEumkWEbQJxHVkWqveq5ELkUHCjPrBO4GPp1jnzkETUj/OVK8LGyS+pPw8ZHM7jFP4TnKzyx0f8jd+9y9b9q0aflfhMg4WbF09hkfepFcli2ayec+NJeerg6MYLh0tTuy8ylleOyFwCxgV1gpmA48Z2YL3P13ZjYd+AHwUXd/MXOQu6fDf183s28T9Ds8SlBTmAEcNLMJwCSCpq6DwPsif3c68LMSzlekZjIf7uhQR+VGFKcz1caxcZ49NylLvr3MUWuZHIhco54yiw7V01oWRQcKd98NnJv53cz2A33u/qqZdQGbgLvcfVtknwlAV7hPCvgg8M/h5o0EHd9PATcCW93dzWwz8N8jHdhLgLuKPV+RWstecGjOp/8pscNSxjLgl/f/Wa1Po+LqKQgUIm+gMLN1BN/sp5rZQWCluz+csPvHgYuAe8zsnrBsCfAGsDkMEu0EQeKr4faHgW+Y2T6CmsTNAO5+xMzuB54J97vP3eM61UXqXqWTwlpFmxkbBtMARSWgbRhMc+/GPYnZzXC61tBuxi0LZxS1fGjc8xeyiFD24lS1TqQrlBLuRKqskGxsSZZqM7Bg3YVo2dvOnsDQsZExN9xCAkSSxRdOZv+/D5MeGh6TeR29med7/jaDL/zFvNibf9z7YDwS6QqVK+FOgUKkyhav2qqaRJV1pNq54fIevv9suuIBOXMzBwoK+F0dKXauXHJGedL7oKerg20DV55RPt60FKpIDSmXovqGR0ZZt/1AVTLfo1nRhQShpNpG0vugEd4fmmZcpMqUSzE+qjk9yqGh4bJv6Envg0Z4fyhQiFTZiqWzg3Z2KVmqPf/1a7fqXePzuzoKvqF3d6Ziy+NyamqdSFcoBQqRKuuf38NZE/RRK8fqGy89lYDW1ZE6I3B0pNq5ZeGMkpIb2yzoyE46NnMzLyR5MtVurLx2Tuy2/vk9dZdIVyj1UYiMA+VNlK6nq+OMXJSkYaa51nHIHrGUPZw1OoQ5adQTjB2me8Ul03ji14cLHu6a/ToahUY9iYyD3oFNtT6FhlRPw0ebnUY9idTQsq8+VetTaEhx3+alNhQoRKpo2Vefil2kRvKrh9wCCaiHTaSKFCSkGShQiIhITmp6CjXqZF0izUhZJ/VFgYIzJ+tKDw1z1+O7gcabDljqS6oNxnkphaagtJP6ov8OgnHR2XO4ROd3ESnVCQWJkii41hcFCkic2VMzfkq5GmEeH5F8FChIniOmmnPHSGtohHl86lHSfEml2DCYZvGqrcwa2MTiVVtPLYQkhVOgIHnWyWrORimtQX1cpZn6trMq8jyZ/sf00DDO6f5HBYviKFAQZIAWUy5SDNVMi/fCK29U5HnU/1gZChQ09vS/Uv9UM62dRl4sqJ4oUNDY0/9KfdswmFaNooYaebGgepI3UJjZWjN7xcyej9l2p5m5mU0Nf7/KzJ41s93hv1dG9r08LN9nZl8yCz49ZjbRzNaH5dvNrDdyzHIzeyF8LK/IK07QP7+HbQNX8ptV17Bt4EoFCSlbpn1cNYriLb5wckWeR60FlVFIjeIR4OrsQjObAVwFvBQpfhW41t3nAsuBb0S2fQW4Hbg4fGSe8zbgqLtfBKwBHgyffzKwElgILABWmll3oS9MpNbi2sclv4vPPYdv/dUfVeS51FpQGXkzs939yei3/Ig1wKeAH0b2HYxs3wOcbWYTgcnAO9z9KQAzexToB34CXA/cGx7zGPDlsLaxFNji7kfCY7YQBJd1hb88kdpRO3jxvnjTvIrfxBt1saB6UtIUHmZ2HZB2912W3P56AzDo7m+ZWQ9wMLLtIJD5n+sBDgC4+wkzew2YEi2POaYqNN+TVNKkjtSp1dSkMJ/50R5Aw4rrTdGBwsw6gbuBJTn2mUPQhJTZJy6aeJ5tuY7J/nu3EzRrMXPmzKTTyknzPUmlqQ+7eEePjbDisV2APnf1pJRRTxcCs4BdZrYfmA48Z2bvBDCz6cAPgI+6+4vhMQfD/TKmA4ci22aEx04AJgFHouUxx4zh7g+5e5+7902bNq2El6Tx1lJ5Q8dUmyjFyKjrc1dnig4U7r7b3c9191537yW4oV/m7r8zsy5gE3CXu2+LHPMy8LqZLQr7Hz7K6b6NjQQd3wA3Als9WMh7M7DEzLrDTuwlYVlVJM3rpHZmKZWGYJZOn7v6Usjw2HXAU8BsMztoZrfl2P3jwEXAPWa2M3ycG277GPAPwD7gRYKObICHgSlmtg/4JDAAEHZi3w88Ez7uy3RsV9qGwXTi/Pf6sEupNASzdPrc1RfzJhvj3dfX5zt27CjqmMWrtsbWKAxYU4VRGNI6/sPd/8jx0eb6jI2Haox+ktzM7Fl374vbpsxskqu5jjrUpDwKEsW7ddFMfe7qjAIFydVcTQooMr5SbUbfBZXJypbKUaBAaf5SPZVcV6EVjJzUiKd6pECB0vylelZeO6fWp1A3Cp0cUSOe6o8ChUgVfW/HS/l3ahGL3tVNe1v+YDGpQ7WwelPSFB7NRlnZUi3bXqzKiO6G9NxLQ4yezN+5r4z2+qMaBcrKFhkPwyMnC9pPGe31R4ECrYIl1aF1mUujZLv6o0BB8huzzUwfdimZaqSndaTaKaB7QqMN65QCBXDFJfETCY66c9fjuxUspCRJ84e1mswowr9cmHtm5+7OlEYb1il1ZgObfvFy4rbhkVHu3bhHb14pWptBAX23TSt7Go7Mz+u2HxizPGyP1n6pe6pREMyBn8vQ8IhqFVKUDYPplg4SEN/09kD/XF783Af44k3zTuUtSf1ToCiQ2pulGP/t8V/U+hRqLmkwSGY4enpoGOf0cHR9GatfChQF0ggoKdSGwTTHChwK2sySBoloOHrjUaCAgkZjaMieFEo3vEDS6CUNR288ChTk73DUkD0phm54gaTO6aQvXfoyVr8UKMhfo7jh8h6NyJCCNesNr9BJ/QBSOe4smq258ShQkL9G8cSvD4/PiUhTWLF0dtON5km1G5//i0v54k3zCtr/bWcnT+yn2ZobjwJFAdSUIMXon9/DskW5k8vqVXdnilsXzaQrMoNrd2eK1TdeSv/8wmvW+eZr6p/fw7aBK1kTBp5PrN/J4lVbNfKpTinhrgDN2pQg1fNA/1y++fPaTDHe3ZnKmxvU09XBoaFhzk9Idnugf25Z51DIZ0azNjcOBQrgnLPaeeP4aOJ2tZ1KsWr5zbiQILFt4MpTv28YTLN41dacgSMqXyAyCvvM5Bomq0BRX/I2PZnZWjN7xcyej9l2p5m5mU0Nf59iZk+Y2e/N7MtZ+/7MzPaa2c7wcW5YPtHM1pvZPjPbbma9kWOWm9kL4WN52a82wUnP3UmhN60Uq56HyKaHhk8188Qlv92xfifz7/tpYrDLt2qfU9hnRsNkG0chNYpHgC8Dj0YLzWwGcBUQrV+/CdwDvCd8ZFvm7juyym4Djrr7RWZ2M/AgcJOZTQZWAn0E771nzWyjux8t4JyLUug8+SKFqvebXaaZ5+xU2xnf6iGolZTaDFTo6KjzuzpiJ05UU2/9yVujcPcngbhlutYAnyK4iWf2fcPd/5UgYBTqeuDr4c+PAe83MwOWAlvc/UgYHLYAVxfxvBWz7KtP1eLPSgNrhOU8h0dGczYhJWVL56stjeapoWdomGzjKGnUk5ldB6TdfVeRh34tbHa6JwwGAD3AAQB3PwG8BkyJlocOhmVx53O7me0wsx2HD1d+KOu2F49oNIYUpVmW84yrGeWbPt0orI9Gw2QbR9Gd2WbWCdwNLCny0GXunjaztwPfBz5C0JwV95HyHOVnFro/BDwE0NfXV5U5O9XBJsXI16FcL7o6Urx14mRs8xOU1gzkFP55KWbIrdROKTWKC4FZwC4z2w9MB54zs3fmOsjd0+G/rwPfBhaEmw4CMwDMbAIwiaCp61R5aDpwqITzrYh6b3OW+rFhMF3ThLuuApu9OlLt3HvdHD73obmxx5TTDKTPS3MpOlC4+253P9fde929l+CGfpm7/y7pGDObEBkZlQI+CGRGUW0EMiOabgS2ursDm4ElZtZtZt0ENZjNxZ5vpaiDTQq1evPe+KrvOOjuTLFz5RL2r7pmzJoPPV0d3Lpo5hnNPJnzfW14hK6OFN2dqYo0A+nz0lzyNj2Z2TrgfcBUMzsIrHT3h3Psvx94B3CWmfUT3OB/C2wOg0Q78M/AV8NDHga+YWb7CGoSNwO4+xEzux94JtzvPneP61QfF8eOn2DDYFrVZMmrlt+mf/9mcpNX3wWTxyTSZSe8DQ2PYMCyRTNzJtwZCW3AIXVIN5+8gcLdb8mzvTfX7xGXJxz/JvDhhG1rgbX5znE8lDNcUFpLVwGZ0dWSGekdl/V8x/qdfPK7O/nLhUEgiEt4c+BbP3+JvgsmJ77PcwUJLWvanJSZXQRljUohChwdWjWzBjbRZhY7TPWkc2pqkaSaT77O6J6E/IfsjG9pHpoUsEjqpJN8Xhuu7YgnJ38uw7rtB3L2I+R6nyv/ofUoUBRJnXSSTyMk242655wOPdf7XPkPrUeBogj61iSFaIRku3azU9OhZ5+u3ueSTX0UBVInnRQq31oM9eCWhUGK0gP9c+m7YDKrN+8tePZYTQ/eehQoCnTs+Ilan4I0iFqOeipEmwVDZTOKzY7W9OCtR01PBcoMj9WcT5JPrUY9dXWk6An7FnK1fp308qZB1/TgrUeBAujMtRJ8RNJsmiJRtRj1lJmOY9vAlexfdQ1rwqzsJOXc1JM6ujXQo3kpUAATs4b65aJvTZJPLW6YZ2d92cmsSZ0ULMo5Rw2PbT0KFBTX+ahvTZLPFZdMG/e/mdQ0Wo2buobHth51ZgNnTWjjrROFrXJXi5uANJYf73q5Jn83rkM583Mxo5oKoenBW4sCBRQcJCC4CeSaME1kqAJ9FKm20/M2FSOuaVQ3dSmXmp6KNDQ8opFPUnW5gkS7WVX6HkSSKFCUQCOfpJZuWThj3DuUNwymWbxqK7MGNrF41VZ9WWoxanoqgUY+SZJK3EA7Uu28dWKUkwn5GNGmz0r3PcRRJrYoUJRA1XtJ8pkf7Sn7OZLWr842Xn0PysQWNT2VQCOfJEm1p+7IlURXLcrEFgWKEjzx68O1PgVpQbVKalMmtihQlCBudS8RCOZbqoZaJrUpE1sUKIA/ePtZRe3fAMsNSI188NLzKv6cBmwbuLJm/QHKxJa8ndlmthb4IPCKu78na9udwGpgmru/amZTgMeAPwQecfePR/a9HHgE6AD+Efhbd3czmwg8ClwO/Dtwk7vvD49ZDvxd+BQPuPvXy3itiV79fXHtyjVeElnqWDWaJeuhiUdJe62tkBrFI8DV2YVmNgO4CngpUvwmcA9wZ8zzfAW4Hbg4fGSe8zbgqLtfBKwBHgyffzKwElgILABWmll3AedbtHzrC4sUqtLNkh2pdq64ZJpyGKSm8gYKd38SOBKzaQ3wKSJfsN39DXf/V4KAcYqZnQe8w92fcncnqEH0h5uvBzI1hceA95uZAUuBLe5+xN2PAluICVgizcxw1j9zgPTQMM7pHAYFCxlPJfVRmNl1QNrddxV4SA9wMPL7wbAss+0AgLufAF4DpkTLY47JPp/bzWyHme04fLj6I5IKXb9CpFzHRk4yMjq2xqt1UWS8FX3HM7NO4G7g08UcFlPmebblOmZsoftD7t7n7n3TplU/x6GY9StEqkE5DDKeSvlqfCEwC9hlZvuB6cBzZvbOHMccDPfLmA4cimybAWBmE4BJBE1dp8pjjqmo7s7ihjQWs36FSDXUQwe3tI6iA4W773b3c9291917CW7ol7n773Ic8zLwupktCvsfPgr8MNy8EVge/nwjsDXsx9gMLDGz7rATe0lYVnHXvLe4IY36kEqc8eo3UA6DjLe8gcLM1gFPAbPN7KCZ3ZZn//3AF4D/FO7/7nDTx4B/APYBLwI/CcsfBqaY2T7gk8AAgLsfAe4Hngkf94VlFVfsQjNDx46rM1HOUE6/Qb5+r+7OlHIYpGby5lG4+y15tvfm+j1SvgN4T0z5m8CHE45ZC6zNd47lKnahmTeOj7LisaAfXx9YySin3+CtE8lDtLs6Ugx+eknJzy1SLg3fKdHIqGvkiYxRTpNkrlyee6+bU/LzilSCAkUZNPJEosrpN7CEeWG6OlKqtUrNKVCQ/CHNp6vI0VLS3Prn95Q+D5hDqn3s0R2pdtUmpC4oUAClzuChmT8kW6lvCQdSbaaJ96QuKVBQ+tTQrxXZCS6Sy7GRk7U+BZFYWgqV0puelE8hUZUYMp2ZVFDrUks9UY2C0jOttSSqRFV6FJzmdJJ6oUBB6Z3SWhJVoqoxCk4j66QeKFAAb46MlnScPsQSVeoXjp6ujsT5xtS8KfVAgQIYLrET0UELycgppYyC6+pIsW3gSlZeO0frUkvdUmd2mdJDw5rOQ4DSRsFl8iQy753Vm/dyaGiY87s6WLF0tt5TUhcUKAgmXDtaxtThI6POZ360Rx/qFjepI1XUvGEdqbYx7xmtSy31Sk1PFD/NeJxyAo00h9+/daKo/Utt8hQZbwoUaPSSlG/DYJoTJ4vvpFAflzQCBQoqM3qp1OxuaQ6l5jtkEusULKSeKVBQ/hDEVJtp8rYWV86XDSXWSb1ToKD8DOubFsxQJ2SLK/fLhnJypJ4pUFB+H0Ul+zg2DKZZvGorswY2qf26gaxYOrusD5MS66SeKVBQ/re5dIW+DW4YTHPX47tJDw3jqP26kfTP72FSiZnZSqyTeqdAQfnf5tpKXq1mrNWb9zKcNZ2I2q8bRylDpLXuhDSCvIHCzNaa2Stm9nzMtjvNzM1saqTsLjPbZ2Z7zWxppPxnYdnO8HFuWD7RzNaHx2w3s97IMcvN7IXwsbzsV5tgxdLZZ0yfUIwSRkXGSqrZqP26+RjwxZvmsW3gSgUJqXuF1CgeAa7OLjSzGcBVwEuRsncDNwNzwmP+3syid+Bl7j4vfLwSlt0GHHX3i4A1wIPhc00GVgILgQXASjPrLu7lFaZ/fg+f+9Dcsp6jEs1DSTUbtV83H0dTvkjjyBso3P1J4EjMpjXApxi7+uP1wHfc/S13/w2wj+Amn8v1wNfDnx8D3m9mBiwFtrj7EXc/CmwhJmBVSv/8nsQZPAtRieahuJqN2q+bU4+CvzSQkvoozOw6IO3uu7I29QAHIr8fDMsyvhY2O90TBoMxx7j7CeA1YEoBzxU9n9vNbIeZ7Th8uLQRSBsG0/z+zeKmYIhKDw2XXavI1Gy0bnLz06JX0kiKnhTQzDqBu4ElcZtjyjI1jmXunjaztwPfBz4CPJrjmFzPNbbQ/SHgIYC+vr6SegxWb97LSJmdDZWYRVYTw7UGTRsjjaSUGsWFwCxgl5ntB6YDz5nZOwm+9c+I7DsdOATg7unw39eBb3O6SerUMWY2AZhE0NSV+FzVUIkO45FRT2yCUn5Ecyv2/1MDFKSRFB0o3H23u5/r7r3u3ktwQ7/M3X8HbARuDkcyzQIuBp42swmZkVFmlgI+CGRGUW0EMiOabgS2ursDm4ElZtYddmIvCcuqolIdxnE3AOVHNLfM/28xNEBBGkkhw2PXAU8Bs83soJndlrSvu+8Bvgv8Evgn4G/cfRSYCGw2s18AO4E08NXwsIeBKWa2D/gkMBA+1xHgfuCZ8HFfWFYVleownhQzOaDyI5pb3P9vLhqgII0mbx+Fu9+SZ3tv1u+fBT6bVfYGcHnC8W8CH07YthZYm+8cK6F/fg+f+dGesteVeP2tE2wYTI/pZ1B+RHMr9v9RAxSk0SgzO2LltXNie9CLMXryzH4K5Uc0t2L/HxUkpNEoUET0z++JH1ZVpOxvmMqPaG7lZvaL1DutmZ3FSBiDWwQHegc20dWRwgyGjo0wqSPF2ak2ho6NcH5XByuWztY3yyaR+X+8Y/3O2p6ISJUoUGSp0LRNAAwNj4z5uSPVzpqb5ilAtDBlZEsjUtPTONJIp+ZV6P+rmhulESlQZClnvqdCaKRTcyr0/1W1SWlEanrKcs17z+ObP38p/44lOr+rgw2Dae7duOdU01R3Z4qV187RTaSBdXWm8g6trvaXEJFqUY0iYsNgmu8/W91s6SsumcaK7+0a039x9NgId6zfyfz7fqps7QZU6ISSK6+dMw5nI1J5ChQRxWbYFssIJoNLmnzw6LERTe3RgAqdUFI1RmlUChQR1e4/8AL+hjq8G4/6naTZqY8i4vyuDtJV/ND3dHUwdOw4bxzPXWup1I1nw2Ca1Zv3cmhouKjcjVKPa1WFvm+yp3YRaRSqUURUO8O286y2vEECACPvdOS5pi3fMJhm3md+yh3rdxY9Y61mui1eoUNedR2lUVkwo3fz6Ovr8x07dpR8/IbBdF1l2Hak2s+YRC5zM4/2p2T2A87YFtXT1cG2gStPPU92zWH15r2x346jx8mZegc2FbSfrqPUKzN71t374rapRpGlf34PXTFThddKXJ9FrmnL83XIZ5q1kmoOSU0oaoevDF1HaUTqo4hh5U4hW2HZN+9ypi3PzHSaFGzazRiNqWVqptvK0HWURqRAEaPcNSmqoXdgEz1h81BScle+RsQ24NjxE8wa2JS4b1yQMIL8DymPZgyWRqVAkWXDYLoiM8hWQ3pouKz+k5OUFgQd+P6zafoumNzyo3bKGRF2w+U9LX/9pDEpUGRZvXlvXQaJWsv0gTTTja7Ym372IIJMv873dhQ25YuCrTQqdWZnUWdjsma6NqUMA07q19n2YmFLuSuZUhqVahRZqp1018gc+LsNu+m7YPKYb+JXXDKNJ359eMw3c+DUPpM6Uhw/McqxkZPA+E2CmKvGkGvkWGafzPHpoeHETv5iNVOwldahPIoscTkKraJSfTOpNgODkdHkZ0u1G6tvvLRqwSJXrkn//J7EDn0DfrPqmqq9D5RHIfWqrDwKM1trZq+Y2fMx2+40MzezqZGyu8xsn5ntNbOlkfLLzWx3uO1LZsEgVDObaGbrw/LtZtYbOWa5mb0QPpYX+bpL0j+/h899aG5d5VKMBwOWLZpZkRXYRk56ziABQRCpZjNMrhoDJA9TzTV8uFyGFi6SxlRIH8UjwNXZhWY2A7gKeClS9m7gZmBOeMzfm1lmToyvALcDF4ePzHPeBhx194uANcCD4XNNBlYCC4EFwEoz6y7u5ZWmf34P50xsnVa5TJB4oH/uuN7IqtkMky/XJG66lujw1Wqcm6MZZKUx5b0buvuT0W/5EWuATwE/jJRdD3zH3d8CfmNm+4AFZrYfeIe7PwVgZo8C/cBPwmPuDY9/DPhyWNtYCmxx9yPhMVsIgsu64l5iaVqpLdmBx589yPqnXyLsRhgXbWbMGth0Rv9BXN9AT5FDUZP6mjI1hmhfRVwfRr6+KjMottVW62VLoyrpa7OZXQek3X2XjU1j7gF+Hvn9YFg2Ev6cXZ455gCAu58ws9eAKdHymGOyz+d2gtoKM2fOLOUlnaHVOrWPjWeECGU6h9NDw3xi/U7uWL+Tro4Ubxw/carpKrrPXY/vBoKbfL6hrSuWzo7to7jikmksXrU175DYuOOjiu3PUbOTNLKiA4WZdQJ3A0viNseUeY7yUo8ZW+j+EPAQBJ3ZcfsUa8XS2Xxy/U7G//bZmjL/adGV/7INj4zyX7+7izvW7xxzo84kIkaTEbs7U9xweQ8/3vXyqec0nPXPHDgVhLKDT1S0xhH3haGAdYrG+I8XKn9CGlcpeRQXArOAXWGT0nTgOTN7J8G3/hmRfacDh8Ly6THlRI8xswnAJOBIjucaF/3ze5ikNY7rTqaGke8+ffTYCN/e/hJvHD+9ROmxkZNndLLH5TZkpnD/RAVnEd7/761TO5XmU3SgcPfd7n6uu/e6ey/BDf0yd/8dsBG4ORzJNIug0/ppd38ZeN3MFoX9Dx/ldN/GRiAzoulGYKsHY3Y3A0vMrDvsxF4Slo2boTqc80kKd9JzD9HNiPZH/d2G3Xwiax2PSswR2Up9XtJ88jY9mdk64H3AVDM7CKx094fj9nX3PWb2XeCXwAngb9w908j7MYIRVB0Endg/CcsfBr4RdnwfIRg1hbsfMbP7gWfC/e7LdGyPl6TJ96S5OMGki+0GcXGlEm2ZmjVWGlkho55uybO9N+v3zwKfjdlvB/CemPI3gQ8nPPdaYG2+c6yGDYNpfv/mifw7StMooPJxSrGd2erIlkamuZ4SrN68l5FieyylZRT7zlBHtjQyBYoEalMWEQkoUCRQm7JUSrdGz0mDU6BIsGLp7GByO5Eyrbx2Tq1PQaQsChQJ+uf38LazW2e+J6ke9U9Io1OgyEF5FCIiChQ5qZ9CRESBIqe4qahFipVreVWRRqBAkUOrLmIklaV1sqXRKVDk0T+/h50rl3DrospMXy6tRzk50ugUKAr0QP/cWp+CNCj1dUmjU6AoQmdKl0uKp3mepNHpzleE//6h99b6FKQBKY9CGp0CRRH0gReRVqRAUaQetTeLSItRoCiS2pulGIsvnFzrUxApmwJFkdT8JMWYNe1ttT4FkbIpUJRAzU9SqHXbD9T6FETKpkBRAjU/SaFGXaskSuNToChB//weLUYjBWk3rWkijS9voDCztWb2ipk9Hym738x+YWY7zeynZnZ+WH6WmX3NzHab2S4ze1/kmJ+Z2d7wmJ1mdm5YPtHM1pvZPjPbbma9kWOWm9kL4WN5BV932bQYjRTiloUzan0KImUrpEbxCHB1Vtlqd3+vu88Dfgx8Oiz/KwB3nwtcBXzezKJ/Y5m7zwsfr4RltwFH3f0iYA3wIICZTQZWAguBBcBKM+su8vVVTf/8Hr540zyUrC1Jbl00U1O/SFPIu4Sbuz8Z/ZYflv2/yK/nAJmG2HcD/xLu84qZDQF9wNM5/sT1wL3hz48BXzYzA5YCW9z9CICZbSEIWOvynfN46Z/fo1FQItL0Sv4+bGafNbMDwDJO1yh2Adeb2QQzmwVcDkTr3l8Lm53uCYMBQA9wAMDdTwCvAVOi5aGDYVncudxuZjvMbMfhw4dLfUkiIhKj5EDh7ne7+wzgW8DHw+K1BDf0HcAXgf8NnAi3LQubpP4kfHwkLI/r7fMc5XHn8pC797l737Rp00p4NSIikqQSLezfBm6AoEbg7p8I+yCuB7qAF8Jt6fDf18NjFoTHHySsdZjZBGAScCRaHpoOHKrA+YqISBFKChRmdnHk1+uAX4flnWZ2TvjzVcAJd/9l2BQ1NSxPAR8EMqOoNgKZEU03Alvd3YHNwBIz6w47sZeEZSIiMo7ydmab2TrgfcBUMztIMBLpA2Y2GzgJ/Bb4L+Hu5wKbzewkkOZ089LEsDwFtAP/DHw13PYw8A0z20dQk7gZwN2PmNn9wDPhfvdlOrZFRGT8mDdZ5qiZHSYIXqWaCrxaodNpJrou8XRdkunaxKvX63KBu8d28jZdoCiXme1w975an0e90XWJp+uSTNcmXiNeF6WLiYhITgoUIiKSkwLFmR6q9QnUKV2XeLouyXRt4jXcdVEfhYiI5KQahYiI5KRAISIiOSlQhMzs6nC9jH1mNlDr8xkPZrY/XDtkp5ntCMsmm9mWcA2QLdGp3c3srvD67DWzpZHyy8Pn2WdmX4pM+NgQEtZcqdh1yLXmSr1LuDb3mlk6srbMByLbWuLamNkMM3vCzH5lZnvM7G/D8uZ837h7yz8IssVfBN4FnEUwC+67a31e4/C69wNTs8r+BzAQ/jwAPBj+/O7wukwEZoXXqz3c9jTwRwQTOf4E+LNav7Yir8OfApcBz1fjOgB/DfzP8OebgfW1fs1lXpt7gTtj9m2ZawOcB1wW/vx24P+Er78p3zeqUQQWAPvc/f+6+3HgOwTrZLSi64Gvhz9/HeiPlH/H3d9y998A+4AFZnYe8A53f8qDd/SjkWMagrs/STB9TFQlr0P0uR4D3t8ota6Ea5OkZa6Nu7/s7s+FP78O/IpgGYSmfN8oUAQKXvuiyTjwUzN71sxuD8v+wN1fhuDDQDB/FyRfo57w5+zyRlfJ65C05koj+7gFyyGvjTSvtOS1CZuE5gPbadL3jQJFoOC1L5rMYne/DPgz4G/M7E9z7Fv2uiFNopTr0GzX6CvAhcA84GXg82F5y10bM3sb8H3gDh+78ucZu8aUNcy1UaAItOTaF+5+KPz3FeAHBE1w/xZWhwn/zaxtnnSNDoY/Z5c3ukpeh6Q1VxqSu/+bu4+6+0mCWaDPWFsm1NTXJpwN+/vAt9z98bC4Kd83ChSBZ4CLzWyWmZ1F0HG0scbnVFVmdo6ZvT3zM8F6H88zdn2Q5cAPw583AjeHIzFmARcDT4fV69fNbFHYfvrRyDGNrJLXIWnNlYaUuRGG/pyxa8u0xLUJX8fDwK/c/QuRTc35vqn16IF6eQAfIBi58CJwd63PZxxe77sIRmHsAvZkXjNBG+i/EKxM+C/A5Mgxd4fXZy+RkU1AH8HN4kXgy4QZ/43yANYRNKGMEHyLu62S1wE4G/geQQfm08C7av2ay7w23wB2A78guJmd12rXBvhjgmagXwA7w8cHmvV9oyk8REQkJzU9iYhITgoUIiKSkwKFiIjkpEAhIiI5KVCIiEhOChQiIpKTAoWIiOT0/wEGXXx4OnLz+gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "14 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835, 7.7835,\n", + " 7.7835, 7.7835, 7.7835, 7.2060, 6.6360, 6.0716, 5.5114, 4.9544, 4.3998,\n", + " 3.8469, 3.2954, 2.7448, 2.1950, 1.6457, 1.0968, 0.5483]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9985, 0.9989, 0.9989, 0.9990, 0.9970, 0.9986, 0.9988, 0.9987, 0.9992,\n", + " 0.9990, 0.9992, 0.9990, 0.9995, 0.9996, 0.9997, 0.9997, 0.9998, 0.9998,\n", + " 0.9999, 0.9999, 0.9999, 0.9996, 1.0000, 1.0000, 0.9598],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.2976, 0.2980, 0.2908, 0.2780, 0.2610, 0.2408, 0.2182, 0.1939, 0.1682,\n", + " 0.1416, 0.1142, 0.0863, 0.0580, 0.0293])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0024, grad_fn=) , base rewards= tensor([8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316, 8.3316,\n", + " 8.3316, 8.3316, 7.7541, 7.1841, 6.6197, 6.0596, 5.5026, 4.9479, 4.3950,\n", + " 3.8435, 3.2929, 2.7431, 2.1938, 1.6450, 1.0964, 0.5481]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9985, 0.9989, 0.9989, 0.9990, 0.9970, 0.9986, 0.9988, 0.9987, 0.9992,\n", + " 0.9990, 0.9992, 0.9991, 0.9995, 0.9996, 0.9997, 0.9997, 0.9998, 0.9998,\n", + " 0.9999, 0.9999, 0.9999, 0.9996, 1.0000, 1.0000, 0.9593],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3267, 0.3271, 0.3199, 0.3071, 0.2900, 0.2698, 0.2473, 0.2230, 0.1973,\n", + " 0.1707, 0.1433, 0.1154, 0.0870, 0.0584, 0.0295])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0028, grad_fn=) , base rewards= tensor([8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795, 8.8795,\n", + " 8.8795, 8.3020, 7.7320, 7.1677, 6.6076, 6.0506, 5.4959, 4.9430, 4.3915,\n", + " 3.8409, 3.2911, 2.7418, 2.1930, 1.6444, 1.0961, 0.5480]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9985, 0.9989, 0.9989, 0.9990, 0.9971, 0.9986, 0.9988, 0.9988, 0.9992,\n", + " 0.9990, 0.9992, 0.9991, 0.9995, 0.9996, 0.9997, 0.9997, 0.9998, 0.9998,\n", + " 0.9999, 0.9999, 0.9999, 0.9996, 1.0000, 1.0000, 0.9588],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3559, 0.3563, 0.3491, 0.3363, 0.3192, 0.2990, 0.2765, 0.2522, 0.2265,\n", + " 0.1999, 0.1725, 0.1446, 0.1162, 0.0876, 0.0587, 0.0296])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0031, grad_fn=) , base rewards= tensor([9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271, 9.4271,\n", + " 8.8498, 8.2799, 7.7156, 7.1554, 6.5984, 6.0438, 5.4909, 4.9394, 4.3888,\n", + " 3.8390, 3.2897, 2.7409, 2.1923, 1.6440, 1.0959, 0.5479]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9986, 0.9989, 0.9989, 0.9990, 0.9971, 0.9986, 0.9988, 0.9988, 0.9992,\n", + " 0.9991, 0.9992, 0.9992, 0.9995, 0.9996, 0.9997, 0.9997, 0.9999, 0.9998,\n", + " 0.9999, 0.9999, 0.9999, 0.9996, 1.0000, 1.0000, 0.9583],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.3852, 0.3856, 0.3784, 0.3656, 0.3485, 0.3283, 0.3058, 0.2815, 0.2558,\n", + " 0.2292, 0.2018, 0.1739, 0.1455, 0.1169, 0.0880, 0.0589, 0.0297])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "5 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0033, grad_fn=) , base rewards= tensor([9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.9744, 9.3973,\n", + " 8.8276, 8.2633, 7.7032, 7.1462, 6.5916, 6.0387, 5.4872, 4.9366, 4.3868,\n", + " 3.8375, 3.2887, 2.7401, 2.1918, 1.6437, 1.0957, 0.5478]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9987, 0.9990, 0.9990, 0.9991, 0.9973, 0.9987, 0.9989, 0.9990, 0.9994,\n", + " 0.9993, 0.9994, 0.9994, 0.9996, 0.9997, 0.9998, 0.9997, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9997, 1.0000, 1.0000, 0.9565],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.4145, 0.4149, 0.4078, 0.3950, 0.3779, 0.3577, 0.3352, 0.3108, 0.2852,\n", + " 0.2586, 0.2312, 0.2033, 0.1749, 0.1463, 0.1174, 0.0883, 0.0591, 0.0298])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "3 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2])\n", + "loss= tensor(0.0931, grad_fn=) , base rewards= tensor([10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 10.5211, 9.9446,\n", + " 9.3751, 8.8110, 8.2509, 7.6940, 7.1394, 6.5865, 6.0350, 5.4844,\n", + " 4.9346, 4.3853, 3.8365, 3.2879, 2.7396, 2.1915, 1.6435, 1.0956,\n", + " 0.5478]) return= 142959.00004076958\n", + "probs of actions: tensor([0.9987, 0.9990, 0.9991, 0.9992, 0.9975, 0.9988, 0.9990, 0.9992, 0.9995,\n", + " 0.9994, 0.9995, 0.9995, 0.9997, 0.9997, 0.9998, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9997, 1.0000, 1.0000, 0.0454],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772])\n", + "finalReturns: tensor([0.4436, 0.4440, 0.4368, 0.4240, 0.4069, 0.3868, 0.3642, 0.3399, 0.3142,\n", + " 0.2876, 0.2602, 0.2323, 0.2039, 0.1753, 0.1464, 0.1173, 0.0881, 0.0588,\n", + " 0.0294])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "3 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0039, grad_fn=) , base rewards= tensor([11.0667, 11.0667, 11.0667, 11.0667, 11.0667, 11.0667, 10.4912, 9.9223,\n", + " 9.3584, 8.7985, 8.2416, 7.6871, 7.1342, 6.5827, 6.0321, 5.4823,\n", + " 4.9330, 4.3842, 3.8356, 3.2873, 2.7392, 2.1912, 1.6433, 1.0955,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9990, 0.9992, 0.9992, 0.9993, 0.9979, 0.9991, 0.9993, 0.9994, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 0.9998, 0.9998, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9997, 1.0000, 1.0000, 0.9418],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.4734, 0.4738, 0.4667, 0.4539, 0.4368, 0.4166, 0.3941, 0.3698, 0.3441,\n", + " 0.3175, 0.2901, 0.2622, 0.2338, 0.2052, 0.1763, 0.1472, 0.1180, 0.0887,\n", + " 0.0593, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "11 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0045, grad_fn=) , base rewards= tensor([11.6101, 11.6101, 11.6101, 11.6101, 11.6101, 11.0368, 10.4689, 9.9056,\n", + " 9.3459, 8.7892, 8.2347, 7.6819, 7.1303, 6.5798, 6.0300, 5.4807,\n", + " 4.9319, 4.3833, 3.8350, 3.2869, 2.7389, 2.1910, 1.6432, 1.0954,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9995, 0.9990, 0.9996, 0.9997, 0.9997, 0.9998,\n", + " 0.9998, 0.9998, 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000, 0.9059],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5029, 0.5033, 0.4962, 0.4834, 0.4663, 0.4461, 0.4236, 0.3993, 0.3736,\n", + " 0.3470, 0.3196, 0.2917, 0.2633, 0.2347, 0.2058, 0.1767, 0.1475, 0.1182,\n", + " 0.0888, 0.0594, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2])\n", + "loss= tensor(0.0711, grad_fn=) , base rewards= tensor([12.1493, 12.1493, 12.1493, 12.1493, 11.5803, 11.0145, 10.4522, 9.8931,\n", + " 9.3366, 8.7822, 8.2295, 7.6780, 7.1275, 6.5776, 6.0284, 5.4795,\n", + " 4.9310, 4.3827, 3.8346, 3.2866, 2.7387, 2.1909, 1.6431, 1.0954,\n", + " 0.5477]) return= 142959.00004076958\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9995, 0.9991, 0.9996, 0.9997, 0.9998, 0.9998,\n", + " 0.9998, 0.9999, 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000, 0.0954],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772])\n", + "finalReturns: tensor([0.5320, 0.5324, 0.5253, 0.5125, 0.4954, 0.4753, 0.4527, 0.4284, 0.4027,\n", + " 0.3761, 0.3487, 0.3208, 0.2925, 0.2638, 0.2349, 0.2058, 0.1766, 0.1473,\n", + " 0.1179, 0.0885, 0.0590, 0.0295])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([12.6801, 12.6801, 12.6801, 12.1195, 11.5579, 10.9978, 10.4397, 9.8837,\n", + " 9.3296, 8.7770, 8.2256, 7.6751, 7.1253, 6.5760, 6.0272, 5.4787,\n", + " 4.9303, 4.3822, 3.8342, 3.2863, 2.7385, 2.1907, 1.6430, 1.0953,\n", + " 0.5477]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9996, 0.9991, 0.9996, 0.9997, 0.9998, 0.9998,\n", + " 0.9998, 0.9999, 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 1.0000, 1.0000, 0.9012],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5619, 0.5623, 0.5551, 0.5424, 0.5254, 0.5052, 0.4826, 0.4583, 0.4327,\n", + " 0.4061, 0.3787, 0.3508, 0.3224, 0.2937, 0.2648, 0.2358, 0.2066, 0.1773,\n", + " 0.1479, 0.1185, 0.0890, 0.0595, 0.0299])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0055, grad_fn=) , base rewards= tensor([13.1942, 13.1942, 12.6503, 12.0972, 11.5412, 10.9852, 10.4303, 9.8767,\n", + " 9.3244, 8.7731, 8.2226, 7.6729, 7.1237, 6.5748, 6.0263, 5.4780,\n", + " 4.9299, 4.3819, 3.8340, 3.2861, 2.7384, 2.1907, 1.6430, 1.0953,\n", + " 0.5476]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9995, 0.9996, 0.9992, 0.9997, 0.9997, 0.9998, 0.9999,\n", + " 0.9998, 0.9999, 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 1.0000, 1.0000, 0.8982],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.5912, 0.5916, 0.5846, 0.5719, 0.5549, 0.5347, 0.5122, 0.4879, 0.4623,\n", + " 0.4356, 0.4082, 0.3803, 0.3520, 0.3233, 0.2944, 0.2653, 0.2361, 0.2068,\n", + " 0.1775, 0.1480, 0.1185, 0.0890, 0.0595, 0.0300])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 0])\n", + "loss= tensor(0.0059, grad_fn=) , base rewards= tensor([13.6758, 13.1646, 12.6281, 12.0805, 11.5287, 10.9759, 10.4233, 9.8715,\n", + " 9.3205, 8.7701, 8.2205, 7.6712, 7.1224, 6.5739, 6.0256, 5.4775,\n", + " 4.9295, 4.3816, 3.8338, 3.2860, 2.7383, 2.1906, 1.6429, 1.0953,\n", + " 0.5476]) return= 142963.00004076958\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9996, 0.9996, 0.9992, 0.9997, 0.9997, 0.9998, 0.9999,\n", + " 0.9998, 0.9999, 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 0.9999,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 1.0000, 1.0000, 0.8956],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5435, 0.5602, 0.5687, 0.5729, 0.5751, 0.5761, 0.5767, 0.5769,\n", + " 0.5771, 0.5771, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772,\n", + " 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5772, 0.5776])\n", + "finalReturns: tensor([0.6205, 0.6209, 0.6139, 0.6013, 0.5844, 0.5643, 0.5417, 0.5174, 0.4918,\n", + " 0.4652, 0.4378, 0.4099, 0.3815, 0.3529, 0.3240, 0.2949, 0.2657, 0.2364,\n", + " 0.2070, 0.1776, 0.1481, 0.1186, 0.0891, 0.0595, 0.0300])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "codeParams=[1, 10000, 1, 1]\n", + "neuralNet2=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=3)\n", + "algorithm2 = ReinforceAlgorithm(game, neuralNet2, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm2.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm2.learn_stage(stage=stage,episodes=ep,print_step=50_000,options=codeParams,prob_break_limit_ln=-0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..363fcab --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/lr 10^-5 advs-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/lr 10^-5 advs-checkpoint.ipynb new file mode 100644 index 0000000..aed338a --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/lr 10^-5 advs-checkpoint.ipynb @@ -0,0 +1,971 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663,\n", + " 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663,\n", + " 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663]) return= 139847.7232627179\n", + "probs of actions: tensor([0.8786, 0.8836, 0.8852, 0.9041, 0.9160, 0.8963, 0.8981, 0.8989, 0.9127,\n", + " 0.9010, 0.9015, 0.9021, 0.0518, 0.8964, 0.8851, 0.9235, 0.9054, 0.0415,\n", + " 0.9164, 0.9023, 0.9071, 0.9030, 0.0111, 0.9274, 0.9877],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5624, 0.5662, 0.5644, 0.5634, 0.5630, 0.5626,\n", + " 0.5664, 0.5644, 0.5635, 0.5630, 0.5623, 0.5701, 0.5663])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 4, 8, 14, 0, 0, 1, 0, 22, 20, 0, 5, 5, 0, 0, 16, 0,\n", + " 0, 0, 1, 0, 0, 22, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279,\n", + " 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279,\n", + " 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 0.5635]) return= 145876.19064216543\n", + "probs of actions: tensor([0.4697, 0.5450, 0.0549, 0.0497, 0.0049, 0.4636, 0.4981, 0.0854, 0.5431,\n", + " 0.0618, 0.0067, 0.5533, 0.0268, 0.0303, 0.4079, 0.6228, 0.0022, 0.5265,\n", + " 0.5884, 0.4364, 0.0926, 0.5506, 0.5699, 0.7906, 0.9886],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5479, 0.5646, 0.5776, 0.6343, 0.5978, 0.5799, 0.5750,\n", + " 0.5203, 0.6114, 0.6865, 0.6204, 0.6092, 0.6062, 0.5841, 0.5477, 0.6298,\n", + " 0.5957, 0.5790, 0.5706, 0.5704, 0.5664, 0.5161, 0.6491])\n", + "finalReturns: tensor([0.0372, 0.0856])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 78431 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 0, 22, 22, 0])\n", + "loss= tensor(0.0009, grad_fn=) , base rewards= tensor([1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150,\n", + " 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150,\n", + " 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.1670, 0.5625]) return= 167444.53665689877\n", + "probs of actions: tensor([0.9807, 0.9663, 0.9871, 0.9885, 0.9861, 0.9875, 0.9866, 0.9924, 0.9865,\n", + " 0.9892, 0.9886, 0.9758, 0.9819, 0.9908, 0.9891, 0.9866, 0.9716, 0.9830,\n", + " 0.9787, 0.9912, 0.9762, 0.0128, 0.9990, 0.9996, 0.9954],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.7396, 0.5996, 0.6447, 0.7161])\n", + "finalReturns: tensor([0.1454, 0.1938, 0.1536])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 21111 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 0, 22, 22, 22, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420,\n", + " 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420,\n", + " 2.3420, 2.3420, 2.3420, 2.3420, 1.6940, 1.0895, 0.5270]) return= 167326.75936424857\n", + "probs of actions: tensor([0.9970, 0.9941, 0.9981, 0.9980, 0.9979, 0.9981, 0.9981, 0.9989, 0.9977,\n", + " 0.9984, 0.9982, 0.9962, 0.9969, 0.9986, 0.9983, 0.9977, 0.9953, 0.9971,\n", + " 0.9968, 0.9987, 0.0032, 0.9990, 0.9999, 1.0000, 0.9967],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.7396, 0.5996, 0.6447, 0.6677, 0.7278])\n", + "finalReturns: tensor([0.2978, 0.3462, 0.3061, 0.2008])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 788 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 0, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407,\n", + " 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407,\n", + " 2.8407, 2.8407, 2.8407, 2.1927, 1.5882, 1.0257, 0.4987]) return= 167267.7526299165\n", + "probs of actions: tensor([9.9804e-01, 9.9601e-01, 9.9866e-01, 9.9866e-01, 9.9858e-01, 9.9872e-01,\n", + " 9.9872e-01, 9.9925e-01, 9.9842e-01, 9.9895e-01, 9.9880e-01, 9.9754e-01,\n", + " 9.9786e-01, 9.9907e-01, 9.9890e-01, 9.9846e-01, 9.9682e-01, 9.9812e-01,\n", + " 9.9790e-01, 5.2534e-04, 9.9901e-01, 9.9924e-01, 9.9993e-01, 9.9998e-01,\n", + " 9.9636e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.7396, 0.5996, 0.6447, 0.6677, 0.6794, 0.7337])\n", + "finalReturns: tensor([0.4844, 0.5328, 0.4927, 0.3875, 0.2350])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906,\n", + " 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906,\n", + " 3.4906, 3.4906, 2.7510, 2.1030, 1.5197, 0.9827, 0.4792]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9980, 0.9960, 0.9987, 0.9987, 0.9986, 0.9987, 0.9987, 0.9992, 0.9984,\n", + " 0.9989, 0.9988, 0.9975, 0.9979, 0.9991, 0.9989, 0.9985, 0.9968, 0.9981,\n", + " 0.9979, 0.9991, 0.9989, 0.9993, 0.9999, 1.0000, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([0.7050, 0.7534, 0.7102, 0.6023, 0.4481, 0.2604])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 349 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0040, grad_fn=) , base rewards= tensor([3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776,\n", + " 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776,\n", + " 3.7776, 3.1295, 2.5250, 1.9625, 1.4355, 0.9369, 0.4601]) return= 167223.4464147788\n", + "probs of actions: tensor([0.9981, 0.9962, 0.9988, 0.9987, 0.9987, 0.9988, 0.9988, 0.9993, 0.9985,\n", + " 0.9990, 0.9989, 0.9976, 0.9980, 0.9991, 0.9990, 0.9985, 0.9970, 0.0014,\n", + " 0.9991, 0.9995, 0.9988, 0.9994, 0.9999, 1.0000, 0.9965],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396,\n", + " 0.5996, 0.6447, 0.6677, 0.6794, 0.6853, 0.6882, 0.7381])\n", + "finalReturns: tensor([0.9256, 0.9740, 0.9338, 0.8286, 0.6761, 0.4895, 0.2780])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 219 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999,\n", + " 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999,\n", + " 3.6604, 3.0123, 2.4290, 1.8920, 1.3885, 0.9093, 0.4481]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9983, 0.9966, 0.9989, 0.9989, 0.9988, 0.9989, 0.9989, 0.9994, 0.9986,\n", + " 0.9991, 0.9990, 0.9979, 0.9982, 0.9992, 0.9991, 0.9987, 0.9973, 0.9990,\n", + " 0.9992, 0.9996, 0.9990, 0.9995, 1.0000, 1.0000, 0.9965],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.1780, 1.2264, 1.1833, 1.0754, 0.9212, 0.7335, 0.5215, 0.2915])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 16 ep 5672 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630,\n", + " 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.0150,\n", + " 3.4105, 2.8480, 2.3210, 1.8223, 1.3456, 0.8855, 0.4380]) return= 167212.36521898463\n", + "probs of actions: tensor([9.9920e-01, 9.9831e-01, 9.9951e-01, 9.9950e-01, 9.9944e-01, 9.9955e-01,\n", + " 9.9955e-01, 9.9975e-01, 9.9934e-01, 9.9959e-01, 9.9954e-01, 9.9893e-01,\n", + " 9.9910e-01, 9.9968e-01, 9.9960e-01, 5.5382e-04, 9.9908e-01, 9.9982e-01,\n", + " 9.9983e-01, 9.9998e-01, 9.9956e-01, 9.9994e-01, 9.9999e-01, 1.0000e+00,\n", + " 9.9578e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.7396, 0.5996, 0.6447,\n", + " 0.6677, 0.6794, 0.6853, 0.6882, 0.6897, 0.6905, 0.7392])\n", + "finalReturns: tensor([1.4214, 1.4698, 1.4296, 1.3244, 1.1720, 0.9853, 0.7739, 0.5442, 0.3012])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0053, grad_fn=) , base rewards= tensor([5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692,\n", + " 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 4.5296, 3.8816,\n", + " 3.2983, 2.7613, 2.2577, 1.7786, 1.3173, 0.8693, 0.4310]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.6912, 1.7396, 1.6964, 1.5885, 1.4343, 1.2467, 1.0346, 0.8047, 0.5615,\n", + " 0.3086])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0066, grad_fn=) , base rewards= tensor([5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948,\n", + " 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 4.9552, 4.3072, 3.7239,\n", + " 3.1869, 2.6834, 2.2042, 1.7430, 1.2949, 0.8566, 0.4256]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.9567, 2.0051, 1.9620, 1.8541, 1.6999, 1.5122, 1.3002, 1.0702, 0.8271,\n", + " 0.5742, 0.3140])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164,\n", + " 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 5.3768, 4.7288, 4.1455, 3.6085,\n", + " 3.1049, 2.6258, 2.1645, 1.7165, 1.2782, 0.8472, 0.4216]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.2264, 2.2748, 2.2316, 2.1237, 1.9695, 1.7819, 1.5698, 1.3399, 1.0967,\n", + " 0.8438, 0.5836, 0.3180])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0105, grad_fn=) , base rewards= tensor([6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345,\n", + " 6.5345, 6.5345, 6.5345, 6.5345, 5.7952, 5.1473, 4.5640, 4.0270, 3.5235,\n", + " 3.0444, 2.5831, 2.1351, 1.6968, 1.2658, 0.8401, 0.4186]) return= 167235.25059974194\n", + "probs of actions: tensor([9.9920e-01, 9.9831e-01, 3.7954e-04, 9.9957e-01, 9.9935e-01, 9.9952e-01,\n", + " 9.9954e-01, 9.9975e-01, 9.9933e-01, 9.9959e-01, 9.9954e-01, 9.9893e-01,\n", + " 9.9910e-01, 9.9968e-01, 9.9960e-01, 9.9939e-01, 9.9896e-01, 9.9985e-01,\n", + " 9.9984e-01, 9.9998e-01, 9.9957e-01, 9.9994e-01, 9.9999e-01, 1.0000e+00,\n", + " 9.9578e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6786, 0.5708, 0.6296, 0.6601, 0.6756, 0.6834, 0.6873,\n", + " 0.6892, 0.6902, 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.4990, 2.5474, 2.5042, 2.3963, 2.2421, 2.0545, 1.8424, 1.6125, 1.3693,\n", + " 1.1164, 0.8562, 0.5907, 0.3210])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 13 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0135, grad_fn=) , base rewards= tensor([6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511,\n", + " 6.9511, 6.9511, 6.9511, 6.2116, 5.5636, 4.9804, 4.4434, 3.9398, 3.4607,\n", + " 2.9994, 2.5514, 2.1131, 1.6821, 1.2565, 0.8349, 0.4163]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.7739, 2.8223, 2.7791, 2.6712, 2.5170, 2.3294, 2.1173, 1.8874, 1.6442,\n", + " 1.3913, 1.1311, 0.8655, 0.5959, 0.3233])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0155, grad_fn=) , base rewards= tensor([7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655,\n", + " 7.3655, 7.3655, 6.6261, 5.9782, 5.3950, 4.8580, 4.3544, 3.8753, 3.4141,\n", + " 2.9660, 2.5277, 2.0967, 1.6711, 1.2495, 0.8310, 0.4146]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.0504, 3.0988, 3.0557, 2.9478, 2.7936, 2.6059, 2.3939, 2.1639, 1.9208,\n", + " 1.6679, 1.4077, 1.1421, 0.8725, 0.5998, 0.3250])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0175, grad_fn=) , base rewards= tensor([7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784,\n", + " 7.7784, 7.0393, 6.3915, 5.8083, 5.2713, 4.7678, 4.2887, 3.8274, 3.3794,\n", + " 2.9411, 2.5101, 2.0845, 1.6629, 1.2443, 0.8280, 0.4134]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.3282, 3.3766, 3.3335, 3.2256, 3.0714, 2.8838, 2.6717, 2.4418, 2.1986,\n", + " 1.9457, 1.6855, 1.4199, 1.1503, 0.8777, 0.6028, 0.3262])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0204, grad_fn=) , base rewards= tensor([8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899,\n", + " 7.4513, 6.8037, 6.2206, 5.6837, 5.1802, 4.7011, 4.2398, 3.7918, 3.3535,\n", + " 2.9225, 2.4969, 2.0753, 1.6567, 1.2404, 0.8258, 0.4124]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.6069, 3.6553, 3.6122, 3.5043, 3.3502, 3.1625, 2.9505, 2.7205, 2.4774,\n", + " 2.2245, 1.9643, 1.6987, 1.4291, 1.1565, 0.8816, 0.6050, 0.3272])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0220, grad_fn=) , base rewards= tensor([8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 7.8621,\n", + " 7.2150, 6.6321, 6.0953, 5.5919, 5.1128, 4.6515, 4.2035, 3.7652, 3.3342,\n", + " 2.9086, 2.4870, 2.0685, 1.6522, 1.2375, 0.8241, 0.4117]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.8863, 3.9347, 3.8916, 3.7838, 3.6296, 3.4420, 3.2300, 3.0000, 2.7569,\n", + " 2.5040, 2.2438, 1.9782, 1.7086, 1.4359, 1.1610, 0.8845, 0.6067, 0.3279])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0243, grad_fn=) , base rewards= tensor([9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 8.2716, 7.6254,\n", + " 7.0429, 6.5063, 6.0030, 5.5239, 5.0627, 4.6147, 4.1764, 3.7454, 3.3198,\n", + " 2.8982, 2.4797, 2.0633, 1.6487, 1.2353, 0.8229, 0.4112]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.1661, 4.2145, 4.1715, 4.0637, 3.9096, 3.7220, 3.5100, 3.2800, 3.0369,\n", + " 2.7840, 2.5238, 2.2582, 1.9886, 1.7159, 1.4411, 1.1645, 0.8867, 0.6079,\n", + " 0.3284])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0267, grad_fn=) , base rewards= tensor([9.4107, 9.4107, 9.4107, 9.4107, 9.4107, 9.4107, 8.6789, 8.0345, 7.4529,\n", + " 6.9167, 6.4136, 5.9346, 5.4735, 5.0255, 4.5872, 4.1562, 3.7306, 3.3090,\n", + " 2.8904, 2.4741, 2.0595, 1.6461, 1.2337, 0.8220, 0.4108]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.4461, 4.4945, 4.4516, 4.3440, 4.1899, 4.0023, 3.7903, 3.5604, 3.3173,\n", + " 3.0644, 2.8042, 2.5386, 2.2690, 1.9964, 1.7215, 1.4449, 1.1671, 0.8883,\n", + " 0.6088, 0.3288])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0297, grad_fn=) , base rewards= tensor([9.8065, 9.8065, 9.8065, 9.8065, 9.8065, 9.0824, 8.4416, 7.8618, 7.3264,\n", + " 6.8237, 6.3449, 5.8839, 5.4359, 4.9977, 4.5667, 4.1411, 3.7195, 3.3009,\n", + " 2.8846, 2.4700, 2.0566, 1.6442, 1.2325, 0.8213, 0.4105]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.7261, 4.7745, 4.7318, 4.6243, 4.4704, 4.2829, 4.0710, 3.8411, 3.5980,\n", + " 3.3451, 3.0849, 2.8193, 2.5497, 2.2771, 2.0022, 1.7256, 1.4478, 1.1690,\n", + " 0.8895, 0.6095, 0.3291])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0326, grad_fn=) , base rewards= tensor([10.1875, 10.1875, 10.1875, 10.1875, 9.4787, 8.8452, 8.2688, 7.7351,\n", + " 7.2332, 6.7548, 6.2939, 5.8461, 5.4079, 4.9769, 4.5513, 4.1298,\n", + " 3.7112, 3.2949, 2.8803, 2.4669, 2.0545, 1.6427, 1.2316, 0.8208,\n", + " 0.4103]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9995, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9991, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.0054, 5.0538, 5.0116, 4.9046, 4.7510, 4.5637, 4.3518, 4.1220, 3.8789,\n", + " 3.6260, 3.3658, 3.1002, 2.8306, 2.5580, 2.2831, 2.0065, 1.7287, 1.4499,\n", + " 1.1705, 0.8904, 0.6100, 0.3293])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0355, grad_fn=) , base rewards= tensor([10.5398, 10.5398, 10.5398, 9.8612, 9.2420, 8.6725, 8.1421, 7.6417,\n", + " 7.1642, 6.7037, 6.2560, 5.8179, 5.3870, 4.9614, 4.5399, 4.1213,\n", + " 3.7050, 3.2904, 2.8770, 2.4646, 2.0528, 1.6417, 1.2309, 0.8204,\n", + " 0.4101]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9984, 0.9995, 0.9995, 0.9995, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9991, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.2833, 5.3317, 5.2905, 5.1844, 5.0313, 4.8444, 4.6327, 4.4030, 4.1599,\n", + " 3.9071, 3.6469, 3.3813, 3.1117, 2.8391, 2.5642, 2.2876, 2.0098, 1.7310,\n", + " 1.4516, 1.1715, 0.8911, 0.6104, 0.3295])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 83 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0292, grad_fn=) , base rewards= tensor([10.8367, 10.8367, 10.2165, 9.6255, 9.0696, 8.5458, 8.0486, 7.5726,\n", + " 7.1129, 6.6656, 6.2277, 5.7969, 5.3713, 4.9498, 4.5313, 4.1150,\n", + " 3.7003, 3.2870, 2.8745, 2.4628, 2.0516, 1.6408, 1.2303, 0.8201,\n", + " 0.4100]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9997, 0.9997, 0.9997, 0.9997, 0.9997, 0.9999, 0.9996,\n", + " 0.9998, 0.9997, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997, 0.9992, 0.9999,\n", + " 0.9999, 1.0000, 0.9997, 1.0000, 1.0000, 1.0000, 0.9951],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.5581, 5.6065, 5.5674, 5.4630, 5.3111, 5.1248, 4.9135, 4.6840, 4.4410,\n", + " 4.1882, 3.9281, 3.6625, 3.3929, 3.1203, 2.8454, 2.5689, 2.2910, 2.0123,\n", + " 1.7328, 1.4528, 1.1724, 0.8917, 0.6107, 0.3296])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0333, grad_fn=) , base rewards= tensor([11.0309, 10.5197, 9.9832, 9.4539, 8.9431, 8.4524, 7.9795, 7.5213,\n", + " 7.0747, 6.6372, 6.2066, 5.7811, 5.3597, 4.9411, 4.5248, 4.1102,\n", + " 3.6968, 3.2844, 2.8727, 2.4615, 2.0507, 1.6402, 1.2300, 0.8199,\n", + " 0.4099]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9997, 0.9997, 0.9997, 0.9997, 0.9997, 0.9999, 0.9996,\n", + " 0.9998, 0.9997, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997, 0.9992, 0.9999,\n", + " 0.9999, 1.0000, 0.9997, 1.0000, 1.0000, 1.0000, 0.9951],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.8267, 5.8751, 5.8399, 5.7390, 5.5894, 5.4045, 5.1940, 4.9648, 4.7221,\n", + " 4.4694, 4.2093, 3.9438, 3.6742, 3.4016, 3.1267, 2.8502, 2.5723, 2.2936,\n", + " 2.0141, 1.7341, 1.4537, 1.1730, 0.8920, 0.6109, 0.3297])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682348121 saved\n", + "[346689, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 168576.33348198733, 65680.3332469066, 0.03331249579787254, 1e-05, 1, 0, 'tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\\n 22, 22, 22, 22, 22, 22, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682348121', 25, 50, 168576.3334819873, 205322.17620252006, 83998.798421993, 134475.68800000002, 131523.21866666665, 89197.96159612676, 89197.96159612676, 106340.34718300312, 106308.66365021843, 97483.02777699233, 89197.96159612676, 106308.66365021843]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139739.47699942059\n", + "probs of actions: tensor([0.8929, 0.8857, 0.9020, 0.8962, 0.8926, 0.8984, 0.0646, 0.9006, 0.8831,\n", + " 0.9026, 0.8910, 0.0521, 0.8824, 0.8858, 0.8784, 0.9028, 0.8894, 0.8959,\n", + " 0.8758, 0.9148, 0.8829, 0.8869, 0.8875, 0.8934, 0.9822],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5616, 0.5658, 0.5642,\n", + " 0.5633, 0.5629, 0.5626, 0.5664, 0.5644, 0.5635, 0.5630, 0.5627, 0.5626,\n", + " 0.5626, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 0, 11, 0, 0, 0, 16, 19, 0, 0, 0, 4, 14, 8, 0, 12, 11, 0,\n", + " 10, 4, 0, 0, 0, 14, 0])\n", + "loss= tensor(0.0716, grad_fn=) , base rewards= tensor([1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330,\n", + " 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330,\n", + " 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 0.5652]) return= 146956.28276435166\n", + "probs of actions: tensor([0.0785, 0.5092, 0.0653, 0.4961, 0.4847, 0.3295, 0.0636, 0.0042, 0.4223,\n", + " 0.5699, 0.5365, 0.0700, 0.0100, 0.0034, 0.3717, 0.0786, 0.0824, 0.3663,\n", + " 0.0485, 0.0709, 0.4142, 0.4306, 0.3190, 0.1280, 0.9781],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5402, 0.5392, 0.5987, 0.5805, 0.5714, 0.5414, 0.5903, 0.6695,\n", + " 0.6148, 0.5884, 0.5738, 0.5645, 0.6211, 0.6258, 0.5793, 0.6124, 0.6362,\n", + " 0.5888, 0.6176, 0.6060, 0.5840, 0.5732, 0.5482, 0.6190])\n", + "finalReturns: tensor([0.0342, 0.0538])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 12, 28, 1, 0, 23, 12, 16, 26, 22, 0, 27, 16, 27, 12, 19, 19, 26,\n", + " 1, 27, 22, 30, 27, 20, 0])\n", + "loss= tensor(0.9044, grad_fn=) , base rewards= tensor([2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149,\n", + " 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149,\n", + " 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 1.2464, 0.5849]) return= 162124.7477856951\n", + "probs of actions: tensor([0.0491, 0.1345, 0.0154, 0.1258, 0.1692, 0.0112, 0.1468, 0.0460, 0.0490,\n", + " 0.0374, 0.2083, 0.0527, 0.0574, 0.0611, 0.2087, 0.0473, 0.0565, 0.0554,\n", + " 0.0369, 0.0536, 0.0429, 0.0126, 0.1198, 0.1008, 0.9626],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5824, 0.5477, 0.7066, 0.6365, 0.5460, 0.6571, 0.6382, 0.6087,\n", + " 0.6761, 0.7320, 0.5716, 0.6866, 0.6276, 0.7269, 0.6619, 0.6699, 0.6424,\n", + " 0.7418, 0.5802, 0.6683, 0.6381, 0.6956, 0.7358, 0.7489])\n", + "finalReturns: tensor([0.1655, 0.2384, 0.1640])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 18, 27, 27, 26, 27, 29, 26, 27, 23, 27, 27, 19, 19, 20, 16, 25, 19,\n", + " 26, 23, 30, 27, 28, 29, 0])\n", + "loss= tensor(3.3616, grad_fn=) , base rewards= tensor([2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627,\n", + " 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627,\n", + " 2.5627, 2.5627, 2.5627, 2.5627, 1.7836, 1.1172, 0.5300]) return= 170297.27457943128\n", + "probs of actions: tensor([0.0463, 0.0392, 0.3955, 0.3738, 0.1785, 0.4352, 0.0531, 0.1506, 0.3757,\n", + " 0.0076, 0.4171, 0.4271, 0.0406, 0.0422, 0.0334, 0.0191, 0.0565, 0.0451,\n", + " 0.2052, 0.0074, 0.0165, 0.5405, 0.0105, 0.0368, 0.9833],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.6156, 0.6036, 0.6560, 0.6882, 0.6922, 0.6900, 0.7199, 0.7080,\n", + " 0.7292, 0.6922, 0.7012, 0.7426, 0.7099, 0.6899, 0.7006, 0.6449, 0.7001,\n", + " 0.6575, 0.6966, 0.6589, 0.7062, 0.7028, 0.7025, 0.7938])\n", + "finalReturns: tensor([0.3426, 0.4155, 0.3792, 0.2638])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 27, 27, 25, 27, 27, 27, 0, 26, 27, 26, 27, 27, 27, 27, 27, 26, 25,\n", + " 26, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.5544, grad_fn=) , base rewards= tensor([3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524,\n", + " 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524,\n", + " 3.0524, 3.0524, 3.0524, 2.2741, 1.6082, 1.0211, 0.4904]) return= 170770.7691723508\n", + "probs of actions: tensor([0.1380, 0.6337, 0.6868, 0.0381, 0.6601, 0.7162, 0.7106, 0.0021, 0.1416,\n", + " 0.6234, 0.1196, 0.6613, 0.6336, 0.6924, 0.6360, 0.6668, 0.1431, 0.0319,\n", + " 0.1411, 0.7074, 0.7916, 0.8418, 0.8417, 0.6480, 0.9773],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5631, 0.6348, 0.6825, 0.6824, 0.6963, 0.7033, 0.7797, 0.5991,\n", + " 0.6466, 0.6834, 0.6898, 0.7000, 0.7052, 0.7077, 0.7090, 0.7150, 0.7160,\n", + " 0.7044, 0.7003, 0.7053, 0.7078, 0.7091, 0.7097, 0.7829])\n", + "finalReturns: tensor([0.5625, 0.6354, 0.5935, 0.4715, 0.2926])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 29, 27, 27, 27, 27, 20, 27, 26, 27, 27, 27, 22, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.6967, grad_fn=) , base rewards= tensor([3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200,\n", + " 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200,\n", + " 3.5200, 3.5200, 2.7382, 2.0706, 1.4828, 0.9516, 0.4611]) return= 172225.21784845914\n", + "probs of actions: tensor([0.7112, 0.6666, 0.7444, 0.0828, 0.7037, 0.7520, 0.7450, 0.6938, 0.0091,\n", + " 0.6783, 0.1017, 0.6977, 0.6331, 0.7429, 0.0189, 0.6977, 0.6746, 0.7301,\n", + " 0.7153, 0.8062, 0.8368, 0.8887, 0.8815, 0.7302, 0.9894],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6620, 0.7004, 0.7054, 0.7078, 0.7091, 0.7426,\n", + " 0.6794, 0.7001, 0.6981, 0.7042, 0.7073, 0.7333, 0.6876, 0.6989, 0.7046,\n", + " 0.7075, 0.7089, 0.7096, 0.7100, 0.7101, 0.7102, 0.7832])\n", + "finalReturns: tensor([0.8120, 0.8849, 0.8429, 0.7208, 0.5418, 0.3221])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 29, 27, 26, 26, 27, 29, 29, 27, 27, 27, 27, 29, 27, 27, 27,\n", + " 27, 27, 27, 25, 27, 19, 0])\n", + "loss= tensor(9.2171, grad_fn=) , base rewards= tensor([3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682,\n", + " 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682,\n", + " 3.9682, 3.1839, 2.5150, 1.9267, 1.3953, 0.9046, 0.4417]) return= 172834.79357956513\n", + "probs of actions: tensor([0.7195, 0.6850, 0.7542, 0.0809, 0.7215, 0.1352, 0.1281, 0.7134, 0.0822,\n", + " 0.0737, 0.7545, 0.7188, 0.6647, 0.7534, 0.0863, 0.7126, 0.6873, 0.7424,\n", + " 0.7456, 0.8016, 0.8489, 0.0049, 0.8710, 0.0048, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6620, 0.7004, 0.7107, 0.7087, 0.7025, 0.6952,\n", + " 0.7060, 0.7227, 0.7165, 0.7134, 0.7119, 0.6999, 0.7196, 0.7149, 0.7126,\n", + " 0.7115, 0.7109, 0.7106, 0.7209, 0.7016, 0.7427, 0.7461])\n", + "finalReturns: tensor([1.0760, 1.1489, 1.1069, 0.9846, 0.7951, 0.5842, 0.3044])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 25, 27, 27, 27, 29, 27, 27, 27, 28, 26, 27, 27,\n", + " 26, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(4.8350, grad_fn=) , base rewards= tensor([4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889,\n", + " 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889,\n", + " 3.6066, 2.9388, 2.3509, 1.8188, 1.3271, 0.8650, 0.4245]) return= 172634.51909284995\n", + "probs of actions: tensor([0.7646, 0.7255, 0.7889, 0.7591, 0.7688, 0.8019, 0.0085, 0.7527, 0.7150,\n", + " 0.7432, 0.0773, 0.7542, 0.7013, 0.8001, 0.0441, 0.0799, 0.7366, 0.7465,\n", + " 0.0758, 0.8491, 0.8635, 0.9027, 0.9119, 0.8123, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6732, 0.6916, 0.7010, 0.7160, 0.6992, 0.7047,\n", + " 0.7075, 0.6977, 0.7185, 0.7144, 0.7124, 0.7058, 0.7206, 0.7084, 0.7093,\n", + " 0.7151, 0.7057, 0.7080, 0.7092, 0.7097, 0.7100, 0.7831])\n", + "finalReturns: tensor([1.3613, 1.4342, 1.3869, 1.2691, 1.0932, 0.8757, 0.6281, 0.3586])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 29, 27, 27, 29, 27, 27, 27, 29, 27, 29, 28, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(2.6017, grad_fn=) , base rewards= tensor([4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995,\n", + " 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.0157,\n", + " 3.3471, 2.7589, 2.2275, 1.7369, 1.2757, 0.8361, 0.4122]) return= 172966.5624334948\n", + "probs of actions: tensor([0.7289, 0.1692, 0.7443, 0.7138, 0.1311, 0.7670, 0.7516, 0.7013, 0.1616,\n", + " 0.7016, 0.1237, 0.0473, 0.6433, 0.7727, 0.6639, 0.7063, 0.7170, 0.6757,\n", + " 0.8066, 0.8157, 0.8129, 0.8741, 0.9036, 0.8123, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5559, 0.6454, 0.6775, 0.6826, 0.7109, 0.7106, 0.7105, 0.6992,\n", + " 0.7192, 0.7036, 0.7159, 0.7203, 0.7153, 0.7128, 0.7116, 0.7109, 0.7106,\n", + " 0.7105, 0.7104, 0.7104, 0.7103, 0.7103, 0.7103, 0.7832])\n", + "finalReturns: tensor([1.6675, 1.7404, 1.6984, 1.5761, 1.3971, 1.1774, 0.9282, 0.6575, 0.3710])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 29, 27, 27, 27, 29, 29, 27, 28, 29, 29, 27, 29, 27, 29, 27, 27, 29,\n", + " 29, 29, 27, 27, 27, 27, 0])\n", + "loss= tensor(11.3290, grad_fn=) , base rewards= tensor([5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989,\n", + " 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 4.4036, 3.7298,\n", + " 3.1391, 2.6065, 2.1171, 1.6595, 1.2254, 0.8070, 0.3996]) return= 173351.18255934515\n", + "probs of actions: tensor([0.5099, 0.3595, 0.5167, 0.4838, 0.5129, 0.3033, 0.3360, 0.4651, 0.0750,\n", + " 0.3347, 0.3011, 0.4653, 0.3972, 0.5718, 0.3602, 0.4803, 0.4625, 0.3816,\n", + " 0.2773, 0.3271, 0.6014, 0.6833, 0.7747, 0.6614, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5559, 0.6454, 0.6775, 0.6938, 0.6909, 0.7038, 0.7216, 0.7104,\n", + " 0.7064, 0.7116, 0.7255, 0.7067, 0.7230, 0.7054, 0.7224, 0.7163, 0.7021,\n", + " 0.7095, 0.7132, 0.7263, 0.7183, 0.7143, 0.7123, 0.7842])\n", + "finalReturns: tensor([2.0200, 2.0929, 2.0505, 1.9390, 1.7621, 1.5383, 1.2696, 0.9855, 0.6895,\n", + " 0.3846])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 28, 28, 29, 29, 29, 29, 30, 27, 29, 26, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 26, 29, 0])\n", + "loss= tensor(7.7630, grad_fn=) , base rewards= tensor([5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612,\n", + " 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 4.7621, 4.0865, 3.4969,\n", + " 2.9681, 2.4827, 2.0287, 1.5976, 1.1832, 0.7812, 0.3884]) return= 173825.5551842266\n", + "probs of actions: tensor([0.7370, 0.0655, 0.0614, 0.7672, 0.7414, 0.7641, 0.7839, 0.0485, 0.0853,\n", + " 0.7527, 0.0260, 0.7726, 0.7826, 0.7109, 0.7644, 0.8093, 0.8081, 0.7662,\n", + " 0.7728, 0.8169, 0.8252, 0.7849, 0.0323, 0.6756, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5696, 0.6399, 0.6706, 0.6936, 0.7052, 0.7111, 0.7081, 0.7311,\n", + " 0.7095, 0.7297, 0.7017, 0.7093, 0.7131, 0.7150, 0.7160, 0.7164, 0.7167,\n", + " 0.7168, 0.7169, 0.7169, 0.7169, 0.7334, 0.7036, 0.7943])\n", + "finalReturns: tensor([2.4016, 2.4857, 2.4454, 2.3186, 2.1307, 1.8993, 1.6364, 1.3506, 1.0481,\n", + " 0.7166, 0.4059])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 13 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 30, 29, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 27, 29, 29, 29, 0])\n", + "loss= tensor(8.1818, grad_fn=) , base rewards= tensor([5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484,\n", + " 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.1476, 4.4712, 3.8812, 3.3522,\n", + " 2.8668, 2.4127, 1.9816, 1.5672, 1.1652, 0.7708, 0.3828]) return= 174002.82550723848\n", + "probs of actions: tensor([0.7929, 0.8025, 0.8118, 0.8192, 0.7962, 0.8142, 0.0197, 0.8157, 0.0652,\n", + " 0.8068, 0.8006, 0.8221, 0.8335, 0.7760, 0.8249, 0.8528, 0.8706, 0.7983,\n", + " 0.8249, 0.8632, 0.0896, 0.8470, 0.7300, 0.7179, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7060, 0.7189, 0.7236,\n", + " 0.7129, 0.7149, 0.7159, 0.7164, 0.7167, 0.7168, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7281, 0.7080, 0.7125, 0.7147, 0.7999])\n", + "finalReturns: tensor([2.7328, 2.8169, 2.7765, 2.6496, 2.4617, 2.2302, 1.9674, 1.6816, 1.3678,\n", + " 1.0618, 0.7438, 0.4171])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 28, 29, 29, 29, 29, 29, 29, 30, 29, 27, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(12.7920, grad_fn=) , base rewards= tensor([6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411,\n", + " 6.3411, 6.3411, 6.3411, 6.3411, 5.5357, 4.8572, 4.2662, 3.7349, 3.2471,\n", + " 2.7909, 2.3581, 1.9423, 1.5393, 1.1457, 0.7590, 0.3776]) return= 173992.11630517073\n", + "probs of actions: tensor([0.8624, 0.8648, 0.8793, 0.8813, 0.0524, 0.8886, 0.8990, 0.8753, 0.8682,\n", + " 0.8730, 0.8802, 0.0325, 0.8614, 0.0400, 0.8668, 0.9117, 0.9162, 0.8509,\n", + " 0.9006, 0.9281, 0.9482, 0.9433, 0.8928, 0.8473, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.7026, 0.7024, 0.7097, 0.7133, 0.7151,\n", + " 0.7160, 0.7165, 0.7108, 0.7213, 0.7303, 0.7091, 0.7130, 0.7150, 0.7159,\n", + " 0.7164, 0.7167, 0.7168, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([3.0651, 3.1492, 3.0974, 2.9793, 2.7976, 2.5705, 2.3107, 2.0271, 1.7261,\n", + " 1.4124, 1.0892, 0.7589, 0.4235])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 30, 27, 29, 30, 30, 28, 29, 28, 29, 29, 29, 29, 29, 30,\n", + " 30, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(27.1738, grad_fn=) , base rewards= tensor([6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912,\n", + " 6.6912, 6.6912, 6.6912, 5.8911, 5.2150, 4.6242, 4.0942, 3.6077, 3.1528,\n", + " 2.7210, 2.3062, 1.9046, 1.5132, 1.1288, 0.7493, 0.3734]) return= 174079.33224464272\n", + "probs of actions: tensor([0.8209, 0.8254, 0.8419, 0.8423, 0.0719, 0.0270, 0.8679, 0.0696, 0.0810,\n", + " 0.0624, 0.8521, 0.0596, 0.7923, 0.8248, 0.8013, 0.8720, 0.8975, 0.0851,\n", + " 0.0489, 0.8874, 0.9414, 0.9314, 0.8985, 0.8402, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6910, 0.7225, 0.7052, 0.7052, 0.7126,\n", + " 0.7279, 0.7151, 0.7217, 0.7120, 0.7145, 0.7157, 0.7163, 0.7166, 0.7109,\n", + " 0.7154, 0.7236, 0.7203, 0.7186, 0.7178, 0.7173, 0.8012])\n", + "finalReturns: tensor([3.4307, 3.5091, 3.4732, 3.3495, 3.1639, 2.9340, 2.6723, 2.3932, 2.0926,\n", + " 1.7706, 1.4418, 1.1075, 0.7693, 0.4279])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 26, 29, 29, 29, 29, 29, 29, 28, 29, 29, 28, 29, 30, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(21.4632, grad_fn=) , base rewards= tensor([7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587,\n", + " 7.0587, 7.0587, 6.2626, 5.5883, 4.9994, 4.4709, 3.9847, 3.5298, 3.0985,\n", + " 2.6844, 2.2827, 1.8901, 1.5043, 1.1236, 0.7465, 0.3722]) return= 173927.67848376333\n", + "probs of actions: tensor([0.7494, 0.7613, 0.0041, 0.7772, 0.7584, 0.8050, 0.8112, 0.7614, 0.7421,\n", + " 0.0720, 0.8168, 0.7777, 0.0912, 0.7630, 0.1784, 0.7979, 0.8219, 0.7332,\n", + " 0.8220, 0.8517, 0.9236, 0.9042, 0.8870, 0.8024, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6549, 0.6641, 0.6903, 0.7036, 0.7102, 0.7136, 0.7152,\n", + " 0.7218, 0.7120, 0.7145, 0.7214, 0.7118, 0.7085, 0.7201, 0.7185, 0.7177,\n", + " 0.7173, 0.7171, 0.7170, 0.7170, 0.7170, 0.7169, 0.8010])\n", + "finalReturns: tensor([3.7693, 3.8534, 3.8131, 3.6807, 3.4974, 3.2750, 3.0098, 2.7226, 2.4190,\n", + " 2.1033, 1.7788, 1.4476, 1.1114, 0.7715, 0.4288])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 30, 30, 29, 30, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28,\n", + " 29, 29, 29, 29, 29, 28, 0])\n", + "loss= tensor(16.1739, grad_fn=) , base rewards= tensor([7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444,\n", + " 7.4444, 6.6425, 5.9655, 5.3753, 4.8462, 4.3607, 3.9066, 3.4755, 3.0611,\n", + " 2.6591, 2.2663, 1.8794, 1.4975, 1.1193, 0.7442, 0.3712]) return= 174131.5237391631\n", + "probs of actions: tensor([0.8230, 0.8277, 0.8443, 0.0909, 0.0966, 0.8673, 0.0717, 0.8321, 0.8166,\n", + " 0.8434, 0.8727, 0.8568, 0.7877, 0.8095, 0.7937, 0.8621, 0.8774, 0.0635,\n", + " 0.8763, 0.9007, 0.9587, 0.9444, 0.9358, 0.0460, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6713, 0.6954, 0.7136, 0.7093, 0.7206, 0.7187,\n", + " 0.7178, 0.7174, 0.7172, 0.7170, 0.7170, 0.7170, 0.7169, 0.7169, 0.7226,\n", + " 0.7125, 0.7147, 0.7158, 0.7164, 0.7166, 0.7225, 0.7965])\n", + "finalReturns: tensor([4.1104, 4.1945, 4.1540, 4.0271, 3.8392, 3.6077, 3.3448, 3.0590, 2.7564,\n", + " 2.4358, 2.1162, 1.7883, 1.4545, 1.1163, 0.7748, 0.4253])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(30.2489, grad_fn=) , base rewards= tensor([7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061,\n", + " 7.0063, 6.3304, 5.7406, 5.2108, 4.7243, 4.2693, 3.8374, 3.4231, 3.0216,\n", + " 2.6293, 2.2438, 1.8632, 1.4863, 1.1121, 0.7400, 0.3694]) return= 174058.37645850837\n", + "probs of actions: tensor([0.8582, 0.8629, 0.8798, 0.8764, 0.8638, 0.9002, 0.9004, 0.8670, 0.8585,\n", + " 0.0301, 0.9124, 0.8797, 0.8310, 0.0907, 0.8367, 0.8905, 0.9087, 0.8720,\n", + " 0.9059, 0.9327, 0.9686, 0.9607, 0.9600, 0.9044, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7220, 0.7121, 0.7145, 0.7157, 0.7104, 0.7211, 0.7190, 0.7180, 0.7174,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([4.4630, 4.5471, 4.5011, 4.3787, 4.1940, 3.9647, 3.7093, 3.4202, 3.1154,\n", + " 2.7989, 2.4738, 2.1422, 1.8057, 1.4656, 1.1228, 0.7779, 0.4316])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(4.4280, grad_fn=) , base rewards= tensor([8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 7.3731,\n", + " 6.6978, 6.1083, 5.5795, 5.0942, 4.6402, 4.2091, 3.7948, 3.3928, 2.9999,\n", + " 2.6139, 2.2329, 1.8557, 1.4813, 1.1089, 0.7382, 0.3687]) return= 174060.25019204617\n", + "probs of actions: tensor([0.9034, 0.9041, 0.9183, 0.9161, 0.9079, 0.9342, 0.9338, 0.9166, 0.9100,\n", + " 0.9035, 0.9549, 0.9257, 0.8960, 0.9082, 0.8750, 0.9167, 0.9458, 0.9095,\n", + " 0.9417, 0.9605, 0.9816, 0.9780, 0.9770, 0.9405, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([4.8121, 4.8962, 4.8558, 4.7290, 4.5412, 4.3098, 4.0469, 3.7611, 3.4586,\n", + " 3.1436, 2.8196, 2.4887, 2.1528, 1.8131, 1.4705, 1.1259, 0.7797, 0.4324])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 6 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 28, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(17.8648, grad_fn=) , base rewards= tensor([8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 7.7430, 7.0688,\n", + " 6.4798, 5.9513, 5.4661, 5.0122, 4.5811, 4.1668, 3.7648, 3.3719, 2.9859,\n", + " 2.6049, 2.2277, 1.8533, 1.4802, 1.1085, 0.7381, 0.3686]) return= 174029.23196541704\n", + "probs of actions: tensor([0.8938, 0.8960, 0.9100, 0.9065, 0.9003, 0.9289, 0.9158, 0.9051, 0.9186,\n", + " 0.8903, 0.9594, 0.9238, 0.8900, 0.9022, 0.8511, 0.9066, 0.9395, 0.9038,\n", + " 0.0062, 0.9561, 0.9805, 0.9749, 0.9774, 0.9416, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7226, 0.7125, 0.7147, 0.7158, 0.7164, 0.7166, 0.8009])\n", + "finalReturns: tensor([5.1535, 5.2376, 5.1974, 5.0707, 4.8829, 4.6515, 4.3887, 4.1029, 3.8004,\n", + " 3.4854, 3.1614, 2.8305, 2.4946, 2.1492, 1.8111, 1.4695, 1.1254, 0.7795,\n", + " 0.4323])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(2.6399, grad_fn=) , base rewards= tensor([8.8931, 8.8931, 8.8931, 8.8931, 8.8931, 8.8931, 8.1021, 7.4302, 6.8424,\n", + " 6.3143, 5.8294, 5.3756, 4.9445, 4.5302, 4.1283, 3.7354, 3.3494, 2.9684,\n", + " 2.5912, 2.2168, 1.8445, 1.4737, 1.1042, 0.7355, 0.3675]) return= 174060.25019204617\n", + "probs of actions: tensor([0.9462, 0.9455, 0.9555, 0.9534, 0.9488, 0.9645, 0.9683, 0.9549, 0.9581,\n", + " 0.9596, 0.9844, 0.9700, 0.9389, 0.9530, 0.9245, 0.9614, 0.9708, 0.9519,\n", + " 0.9705, 0.9807, 0.9920, 0.9906, 0.9916, 0.9737, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([5.5094, 5.5935, 5.5535, 5.4270, 5.2393, 5.0080, 4.7452, 4.4594, 4.1569,\n", + " 3.8420, 3.5179, 3.1870, 2.8511, 2.5114, 2.1689, 1.8243, 1.4781, 1.1307,\n", + " 0.7824, 0.4335])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(32.6679, grad_fn=) , base rewards= tensor([9.2297, 9.2297, 9.2297, 9.2297, 9.2297, 8.4486, 7.7814, 7.1957, 6.6687,\n", + " 6.1842, 5.7315, 5.3016, 4.8883, 4.4871, 4.0950, 3.7094, 3.3296, 2.9536,\n", + " 2.5804, 2.2090, 1.8390, 1.4701, 1.1018, 0.7342, 0.3669]) return= 174121.3274714346\n", + "probs of actions: tensor([0.9370, 0.9376, 0.9482, 0.9457, 0.9450, 0.9597, 0.9723, 0.0570, 0.9488,\n", + " 0.9538, 0.9850, 0.9677, 0.9243, 0.0438, 0.9097, 0.9542, 0.9587, 0.9397,\n", + " 0.9704, 0.9754, 0.9915, 0.9905, 0.9908, 0.9710, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7085, 0.7201,\n", + " 0.7185, 0.7177, 0.7173, 0.7171, 0.7111, 0.7215, 0.7192, 0.7181, 0.7175,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([5.8759, 5.9600, 5.9204, 5.7942, 5.6126, 5.3770, 5.1112, 4.8233, 4.5193,\n", + " 4.2033, 3.8844, 3.5484, 3.2091, 2.8670, 2.5228, 2.1769, 1.8298, 1.4818,\n", + " 1.1331, 0.7838, 0.4341])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 30, 29, 29, 29, 29, 30, 29, 29, 29, 29, 30, 29, 29, 29, 30, 29,\n", + " 30, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(41.6779, grad_fn=) , base rewards= tensor([9.5587, 9.5587, 9.5587, 9.5587, 8.7930, 8.1329, 7.5505, 7.0251, 6.5414,\n", + " 6.0882, 5.6583, 5.2451, 4.8442, 4.4522, 4.0668, 3.6871, 3.3112, 2.9380,\n", + " 2.5667, 2.1975, 1.8295, 1.4630, 1.0971, 0.7314, 0.3657]) return= 174209.913456734\n", + "probs of actions: tensor([0.8751, 0.8809, 0.1046, 0.8975, 0.8943, 0.9066, 0.9349, 0.1239, 0.8953,\n", + " 0.9055, 0.9732, 0.9129, 0.1605, 0.9055, 0.8477, 0.9023, 0.0858, 0.8891,\n", + " 0.0721, 0.9442, 0.9840, 0.9776, 0.9772, 0.9326, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6325, 0.6815, 0.6991, 0.7080, 0.7125, 0.7088, 0.7203,\n", + " 0.7186, 0.7178, 0.7173, 0.7112, 0.7215, 0.7192, 0.7181, 0.7116, 0.7217,\n", + " 0.7134, 0.7226, 0.7198, 0.7183, 0.7176, 0.7173, 0.8012])\n", + "finalReturns: tensor([6.2388, 6.3229, 6.2839, 6.1583, 5.9712, 5.7461, 5.4791, 5.1904, 4.8858,\n", + " 4.5694, 4.2501, 3.9140, 3.5745, 3.2323, 2.8939, 2.5435, 2.1993, 1.8447,\n", + " 1.4914, 1.1390, 0.7871, 0.4355])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 30, 29, 29, 30, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 30, 0])\n", + "loss= tensor(40.5944, grad_fn=) , base rewards= tensor([9.8524, 9.8524, 9.8524, 9.1299, 8.4899, 7.9170, 7.3961, 6.9146, 6.4624,\n", + " 6.0330, 5.6201, 5.2193, 4.8281, 4.4437, 4.0642, 3.6881, 3.3147, 2.9431,\n", + " 2.5729, 2.2038, 1.8354, 1.4677, 1.1003, 0.7333, 0.3666]) return= 174107.14165860406\n", + "probs of actions: tensor([0.8416, 0.8520, 0.8595, 0.8623, 0.8794, 0.8895, 0.0793, 0.8476, 0.8646,\n", + " 0.1119, 0.9667, 0.8832, 0.7889, 0.8842, 0.7762, 0.8842, 0.8902, 0.8377,\n", + " 0.9165, 0.9302, 0.9792, 0.9674, 0.9688, 0.0917, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7060, 0.7189, 0.7179,\n", + " 0.7115, 0.7217, 0.7193, 0.7181, 0.7175, 0.7172, 0.7171, 0.7170, 0.7170,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7110, 0.8055])\n", + "finalReturns: tensor([6.5673, 6.6514, 6.6142, 6.4902, 6.3042, 6.0797, 5.8130, 5.5245, 5.2259,\n", + " 4.9051, 4.5769, 4.2432, 3.9053, 3.5641, 3.2205, 2.8751, 2.5283, 2.1805,\n", + " 1.8319, 1.4827, 1.1331, 0.7832, 0.4389])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 29, 29, 29, 29, 30, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(54.3465, grad_fn=) , base rewards= tensor([10.0714, 10.0714, 9.4193, 8.8129, 8.2569, 7.7457, 7.2699, 6.8214,\n", + " 6.3935, 5.9812, 5.5814, 5.1904, 4.8059, 4.4262, 4.0499, 3.6762,\n", + " 3.3052, 2.9359, 2.5675, 2.1999, 1.8327, 1.4658, 1.0991, 0.7327,\n", + " 0.3663]) return= 174202.79502442433\n", + "probs of actions: tensor([0.2038, 0.1953, 0.1608, 0.8084, 0.8417, 0.8700, 0.8805, 0.2281, 0.8222,\n", + " 0.8522, 0.9632, 0.8519, 0.6879, 0.1521, 0.7490, 0.8204, 0.8533, 0.7903,\n", + " 0.8795, 0.8923, 0.9703, 0.9507, 0.9572, 0.8827, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6848, 0.7008, 0.7088, 0.7129, 0.7090, 0.7204,\n", + " 0.7187, 0.7178, 0.7174, 0.7171, 0.7111, 0.7215, 0.7192, 0.7181, 0.7175,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([6.9277, 7.0177, 6.9853, 6.8564, 6.6668, 6.4338, 6.1694, 5.8883, 5.5802,\n", + " 5.2614, 4.9345, 4.6017, 4.2643, 3.9294, 3.5817, 3.2335, 2.8847, 2.5356,\n", + " 2.1860, 1.8362, 1.4861, 1.1358, 0.7853, 0.4347])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 29, 29, 30, 30, 29, 29, 29, 29, 30, 29, 29, 30, 29, 29, 29, 29, 29,\n", + " 29, 30, 29, 30, 29, 29, 0])\n", + "loss= tensor(69.6359, grad_fn=) , base rewards= tensor([10.1501, 9.6388, 9.1023, 8.5803, 8.0846, 7.6157, 7.1709, 6.7459,\n", + " 6.3358, 5.9369, 5.5462, 5.1617, 4.7827, 4.4073, 4.0344, 3.6641,\n", + " 3.2953, 2.9274, 2.5601, 2.1932, 1.8265, 1.4600, 1.0944, 0.7290,\n", + " 0.3645]) return= 174253.3722751547\n", + "probs of actions: tensor([0.2702, 0.7677, 0.7977, 0.2116, 0.2319, 0.8234, 0.8262, 0.7327, 0.7965,\n", + " 0.1930, 0.9485, 0.7959, 0.3707, 0.8006, 0.6535, 0.7538, 0.8028, 0.7528,\n", + " 0.8439, 0.1603, 0.9571, 0.0712, 0.9422, 0.8500, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5680, 0.6405, 0.6723, 0.6960, 0.7139, 0.7154, 0.7162, 0.7165,\n", + " 0.7108, 0.7213, 0.7191, 0.7121, 0.7220, 0.7194, 0.7182, 0.7176, 0.7172,\n", + " 0.7171, 0.7111, 0.7214, 0.7133, 0.7225, 0.7197, 0.8024])\n", + "finalReturns: tensor([7.2753, 7.3653, 7.3339, 7.2154, 7.0387, 6.8116, 6.5426, 6.2521, 5.9461,\n", + " 5.6285, 5.3083, 4.9715, 4.6314, 4.2947, 3.9456, 3.5965, 3.2471, 2.8974,\n", + " 2.5475, 2.1973, 1.8529, 1.4980, 1.1503, 0.7931, 0.4380])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0,[1e-05,1][1, 10000, 1, 1],1682423487 saved\n", + "[3000000, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 174210.39338284553, 57605.93776875555, 65.17557525634766, 1e-05, 1, 0, 'tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 29, 29, 29, 30, 29, 29,\\n 29, 30, 29, 29, 29, 29, 0])', '[0.69 0.75 0.77 0.78 0.75 0.8 0.8 0.7 0.77 0.2 0.06 0.24 0.6 0.77\\n 0.62 0.27 0.78 0.72 0.82 0.18 0.95 0.92 0.94 0.84 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1682423487', 25, 50, 174199.95044967832, 226157.05867704182, 94851.05074168817, 131012.56797668608, 127973.03513660273, 64641.60648389723, 62848.849838023714, 78979.431849868, 79951.69168142487, 109515.23673882235, 64159.865982403535, 79875.30170982817]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 140290.89393391204\n", + "probs of actions: tensor([0.9195, 0.0062, 0.9061, 0.9295, 0.9160, 0.9197, 0.9265, 0.9012, 0.8971,\n", + " 0.9135, 0.9181, 0.9058, 0.9080, 0.9095, 0.0020, 0.9082, 0.9207, 0.9140,\n", + " 0.9216, 0.8805, 0.9001, 0.9244, 0.8986, 0.9275, 0.9888],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5350, 0.5644, 0.5634, 0.5630, 0.5627, 0.5626, 0.5626, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5589, 0.5852, 0.5738, 0.5681,\n", + " 0.5653, 0.5639, 0.5632, 0.5629, 0.5627, 0.5626, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 0, 1, 22, 8, 0, 9, 17, 19, 7, 14, 7, 0, 1, 14, 0, 7, 1,\n", + " 0, 10, 17, 0, 2, 21, 0])\n", + "loss= tensor(0.1059, grad_fn=) , base rewards= tensor([1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688,\n", + " 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688,\n", + " 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 0.5770]) return= 150673.14503249113\n", + "probs of actions: tensor([0.0195, 0.3042, 0.0644, 0.0075, 0.0056, 0.3819, 0.0345, 0.0280, 0.0135,\n", + " 0.0520, 0.0902, 0.0551, 0.2481, 0.0579, 0.0623, 0.3358, 0.0548, 0.0627,\n", + " 0.5367, 0.0444, 0.0219, 0.4604, 0.0402, 0.0654, 0.9866],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.6006, 0.5813, 0.5273, 0.6487, 0.6395, 0.5923, 0.5872, 0.6199,\n", + " 0.6798, 0.6304, 0.6563, 0.6385, 0.5998, 0.5653, 0.6279, 0.5898, 0.6053,\n", + " 0.5876, 0.5650, 0.5782, 0.6514, 0.6057, 0.5477, 0.6596])\n", + "finalReturns: tensor([0.0384, 0.0825])\n" + ] + } + ], + "source": [ + "for adv in range(len(AdversaryModes)):\n", + " adversaryProbs=torch.zeros(len(AdversaryModes))\n", + " adversaryProbs[adv]=1\n", + " game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + " neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + " algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=3_000_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + " algorithm.solver(print_step=100_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small multi adv-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small multi adv-checkpoint.ipynb new file mode 100644 index 0000000..18f30c5 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small multi adv-checkpoint.ipynb @@ -0,0 +1,955 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.0001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "24527 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 18, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968,\n", + " 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968,\n", + " 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968]) return= 140305.1458599319\n", + "probs of actions: tensor([9.7228e-01, 9.7357e-01, 9.7232e-01, 9.7705e-01, 9.6317e-01, 9.7690e-01,\n", + " 9.7655e-01, 9.7618e-01, 9.7250e-01, 9.8279e-01, 9.8160e-01, 9.7764e-01,\n", + " 9.7504e-01, 9.7618e-01, 9.6984e-01, 9.7103e-01, 9.7842e-01, 9.7346e-01,\n", + " 9.7620e-01, 9.8331e-01, 9.6818e-01, 9.7596e-01, 1.3203e-04, 9.6867e-01,\n", + " 9.9901e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5301, 0.6320, 0.5968])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "25755 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 26, 0, 26, 26, 26, 26, 0, 26, 26, 0, 26, 26, 26, 0, 26, 26, 26,\n", + " 26, 26, 26, 26, 0, 26, 0])\n", + "loss= tensor(3.7815e-05, grad_fn=) , base rewards= tensor([1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759,\n", + " 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759,\n", + " 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 0.6121]) return= 163403.48619982437\n", + "probs of actions: tensor([0.2713, 0.9437, 0.2477, 0.9074, 0.7945, 0.9064, 0.8652, 0.1833, 0.8615,\n", + " 0.8040, 0.3010, 0.8593, 0.8648, 0.7408, 0.1000, 0.8775, 0.6739, 0.8823,\n", + " 0.8630, 0.7801, 0.8445, 0.8598, 0.1583, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4690, 0.6500, 0.5379, 0.6197, 0.6626, 0.6845, 0.7632, 0.5914,\n", + " 0.6480, 0.7447, 0.5828, 0.6435, 0.6748, 0.7583, 0.5892, 0.6468, 0.6765,\n", + " 0.6916, 0.6992, 0.7030, 0.7049, 0.7734, 0.5962, 0.7180])\n", + "finalReturns: tensor([0.0383, 0.1059])\n", + "----------------------------------------\n", + "614 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 0, 26, 26, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390,\n", + " 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390,\n", + " 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.1748, 0.5625]) return= 170660.4533652142\n", + "probs of actions: tensor([0.9908, 0.9982, 0.9919, 0.9974, 0.9944, 0.9979, 0.9970, 0.9954, 0.9965,\n", + " 0.9951, 0.9921, 0.9969, 0.9968, 0.9932, 0.9974, 0.9966, 0.9910, 0.9972,\n", + " 0.9969, 0.9943, 0.9961, 0.0026, 0.9991, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7744, 0.5966, 0.6507, 0.7461])\n", + "finalReturns: tensor([0.1543, 0.2219, 0.1836])\n", + "----------------------------------------\n", + "26 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582,\n", + " 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582,\n", + " 2.5582, 2.5582, 2.5582, 2.5582, 1.7838, 1.1196, 0.5324]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9934, 0.9986, 0.9940, 0.9980, 0.9958, 0.9984, 0.9977, 0.9967, 0.9974,\n", + " 0.9964, 0.9942, 0.9978, 0.9976, 0.9951, 0.9981, 0.9975, 0.9933, 0.9979,\n", + " 0.9977, 0.9958, 0.9971, 0.9990, 0.9992, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.3366, 0.4042, 0.3616, 0.2420])\n", + "----------------------------------------\n", + "21 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0012, grad_fn=) , base rewards= tensor([3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514,\n", + " 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514,\n", + " 3.0514, 3.0514, 3.0514, 2.2770, 1.6128, 1.0256, 0.4932]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9955, 0.9990, 0.9959, 0.9986, 0.9971, 0.9990, 0.9985, 0.9978, 0.9982,\n", + " 0.9976, 0.9961, 0.9985, 0.9984, 0.9968, 0.9987, 0.9983, 0.9954, 0.9986,\n", + " 0.9985, 0.9972, 0.9990, 0.9996, 0.9994, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.5502, 0.6178, 0.5752, 0.4556, 0.2812])\n", + "----------------------------------------\n", + "16 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161,\n", + " 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161,\n", + " 3.5161, 3.5161, 2.7417, 2.0775, 1.4903, 0.9579, 0.4647]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9972, 0.9993, 0.9974, 0.9991, 0.9981, 0.9993, 0.9990, 0.9986, 0.9988,\n", + " 0.9985, 0.9975, 0.9991, 0.9989, 0.9980, 0.9991, 0.9989, 0.9970, 0.9991,\n", + " 0.9990, 0.9990, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.7923, 0.8599, 0.8173, 0.6977, 0.5233, 0.3097])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0031, grad_fn=) , base rewards= tensor([3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600,\n", + " 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600,\n", + " 3.9600, 3.1856, 2.5214, 1.9343, 1.4018, 0.9086, 0.4439]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9972, 0.9994, 0.9975, 0.9991, 0.9981, 0.9994, 0.9990, 0.9986, 0.9989,\n", + " 0.9985, 0.9976, 0.9991, 0.9990, 0.9980, 0.9992, 0.9989, 0.9971, 0.9991,\n", + " 0.9990, 0.9991, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.0552, 1.1228, 1.0802, 0.9605, 0.7862, 0.5726, 0.3305])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0047, grad_fn=) , base rewards= tensor([4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887,\n", + " 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887,\n", + " 3.6143, 2.9500, 2.3629, 1.8305, 1.3373, 0.8726, 0.4286]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9973, 0.9994, 0.9975, 0.9991, 0.9982, 0.9994, 0.9991, 0.9987, 0.9989,\n", + " 0.9985, 0.9977, 0.9991, 0.9990, 0.9981, 0.9992, 0.9989, 0.9972, 0.9991,\n", + " 0.9991, 0.9991, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.3333, 1.4009, 1.3584, 1.2387, 1.0643, 0.8507, 0.6086, 0.3458])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "12 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060,\n", + " 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.0316,\n", + " 3.3674, 2.7802, 2.2478, 1.7546, 1.2899, 0.8460, 0.4174]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9985, 0.9996, 0.9987, 0.9995, 0.9990, 0.9997, 0.9995, 0.9993, 0.9994,\n", + " 0.9992, 0.9988, 0.9995, 0.9995, 0.9990, 0.9996, 0.9994, 0.9991, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.6228, 1.6904, 1.6478, 1.5281, 1.3538, 1.1402, 0.8981, 0.6352, 0.3570])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150,\n", + " 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 4.4406, 3.7764,\n", + " 3.1892, 2.6568, 2.1636, 1.6989, 1.2550, 0.8263, 0.4090]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9986, 0.9997, 0.9987, 0.9995, 0.9990, 0.9997, 0.9995, 0.9993, 0.9994,\n", + " 0.9993, 0.9988, 0.9996, 0.9995, 0.9990, 0.9996, 0.9994, 0.9991, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.9206, 1.9882, 1.9456, 1.8260, 1.6516, 1.4380, 1.1959, 0.9330, 0.6549,\n", + " 0.3654])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177,\n", + " 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 4.8434, 4.1791, 3.5920,\n", + " 3.0596, 2.5664, 2.1017, 1.6578, 1.2291, 0.8118, 0.4028]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9987, 0.9997, 0.9988, 0.9996, 0.9991, 0.9997, 0.9996, 0.9993, 0.9995,\n", + " 0.9993, 0.9989, 0.9996, 0.9995, 0.9991, 0.9996, 0.9995, 0.9992, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.2246, 2.2922, 2.2497, 2.1300, 1.9556, 1.7420, 1.4999, 1.2370, 0.9589,\n", + " 0.6694, 0.3716])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0084, grad_fn=) , base rewards= tensor([6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158,\n", + " 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 5.2415, 4.5773, 3.9901, 3.4577,\n", + " 2.9645, 2.4998, 2.0559, 1.6272, 1.2099, 0.8009, 0.3981]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9987, 0.9997, 0.9989, 0.9996, 0.9991, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9993, 0.9990, 0.9996, 0.9995, 0.9991, 0.9996, 0.9995, 0.9993, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.5333, 2.6009, 2.5583, 2.4387, 2.2643, 2.0507, 1.8086, 1.5457, 1.2676,\n", + " 0.9781, 0.6803, 0.3763])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105,\n", + " 6.4105, 6.4105, 6.4105, 6.4105, 5.6361, 4.9719, 4.3848, 3.8524, 3.3592,\n", + " 2.8945, 2.4506, 2.0219, 1.6046, 1.1956, 0.7928, 0.3947]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9988, 0.9997, 0.9989, 0.9996, 0.9992, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9994, 0.9990, 0.9996, 0.9996, 0.9992, 0.9997, 0.9995, 0.9993, 0.9998,\n", + " 0.9998, 0.9998, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.8454, 2.9130, 2.8704, 2.7508, 2.5764, 2.3628, 2.1207, 1.8578, 1.5797,\n", + " 1.2902, 0.9924, 0.6884, 0.3797])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0106, grad_fn=) , base rewards= tensor([6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024,\n", + " 6.8024, 6.8024, 6.8024, 6.0282, 5.3640, 4.7769, 4.2445, 3.7513, 3.2866,\n", + " 2.8427, 2.4140, 1.9967, 1.5877, 1.1849, 0.7868, 0.3921]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9989, 0.9997, 0.9990, 0.9996, 0.9992, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9994, 0.9991, 0.9996, 0.9996, 0.9993, 0.9997, 0.9996, 0.9994, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.1601, 3.2277, 3.1851, 3.0655, 2.8911, 2.6775, 2.4354, 2.1725, 1.8944,\n", + " 1.6049, 1.3071, 1.0031, 0.6944, 0.3823])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923,\n", + " 7.1923, 7.1923, 6.4182, 5.7541, 5.1670, 4.6346, 4.1415, 3.6767, 3.2328,\n", + " 2.8042, 2.3868, 1.9779, 1.5751, 1.1769, 0.7823, 0.3902]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9989, 0.9997, 0.9990, 0.9996, 0.9993, 0.9998, 0.9996, 0.9995, 0.9996,\n", + " 0.9994, 0.9991, 0.9997, 0.9996, 0.9993, 0.9997, 0.9996, 0.9994, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.4767, 3.5443, 3.5017, 3.3821, 3.2077, 2.9941, 2.7520, 2.4892, 2.2110,\n", + " 1.9216, 1.6237, 1.3197, 1.0111, 0.6989, 0.3842])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0147, grad_fn=) , base rewards= tensor([7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805,\n", + " 7.5805, 6.8067, 6.1427, 5.5557, 5.0233, 4.5302, 4.0655, 3.6215, 3.1929,\n", + " 2.7756, 2.3666, 1.9638, 1.5657, 1.1710, 0.7789, 0.3887]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9990, 0.9997, 0.9991, 0.9997, 0.9993, 0.9998, 0.9997, 0.9995, 0.9996,\n", + " 0.9995, 0.9992, 0.9997, 0.9997, 0.9994, 0.9997, 0.9997, 0.9995, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.7948, 3.8624, 3.8198, 3.7002, 3.5258, 3.3122, 3.0701, 2.8072, 2.5291,\n", + " 2.2396, 1.9418, 1.6378, 1.3291, 1.0170, 0.7023, 0.3857])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0154, grad_fn=) , base rewards= tensor([7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671,\n", + " 7.1938, 6.5301, 5.9432, 5.4109, 4.9178, 4.4531, 4.0092, 3.5805, 3.1632,\n", + " 2.7542, 2.3514, 1.9533, 1.5586, 1.1665, 0.7764, 0.3876]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9991, 0.9998, 0.9992, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9996,\n", + " 0.9995, 0.9993, 0.9997, 0.9997, 0.9995, 0.9998, 0.9997, 0.9995, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.1139, 4.1815, 4.1389, 4.0193, 3.8450, 3.6314, 3.3893, 3.1264, 2.8482,\n", + " 2.5588, 2.2610, 1.9570, 1.6483, 1.3362, 1.0215, 0.7048, 0.3868])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0162, grad_fn=) , base rewards= tensor([8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 7.5796,\n", + " 6.9165, 6.3298, 5.7976, 5.3045, 4.8399, 4.3960, 3.9674, 3.5500, 3.1410,\n", + " 2.7383, 2.3401, 1.9454, 1.5534, 1.1632, 0.7745, 0.3868]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9991, 0.9998, 0.9992, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9997,\n", + " 0.9996, 0.9994, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9996, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.4337, 4.5013, 4.4588, 4.3392, 4.1649, 3.9513, 3.7092, 3.4464, 3.1682,\n", + " 2.8788, 2.5810, 2.2769, 1.9683, 1.6562, 1.3414, 1.0248, 0.7067, 0.3876])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0162, grad_fn=) , base rewards= tensor([8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 7.9639, 7.3017,\n", + " 6.7156, 6.1836, 5.6907, 5.2261, 4.7822, 4.3536, 3.9362, 3.5273, 3.1245,\n", + " 2.7263, 2.3317, 1.9396, 1.5494, 1.1607, 0.7730, 0.3862]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9992, 0.9998, 0.9993, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9997,\n", + " 0.9996, 0.9994, 0.9998, 0.9998, 0.9996, 0.9998, 0.9997, 0.9996, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.7540, 4.8216, 4.7792, 4.6597, 4.4854, 4.2719, 4.0298, 3.7669, 3.4888,\n", + " 3.1993, 2.9015, 2.5975, 2.2889, 1.9767, 1.6620, 1.3454, 1.0273, 0.7082,\n", + " 0.3882])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0156, grad_fn=) , base rewards= tensor([9.1110, 9.1110, 9.1110, 9.1110, 9.1110, 9.1110, 8.3456, 7.6856, 7.1004,\n", + " 6.5689, 6.0762, 5.6117, 5.1679, 4.7393, 4.3220, 3.9130, 3.5102, 3.1121,\n", + " 2.7174, 2.3253, 1.9352, 1.5464, 1.1588, 0.7720, 0.3858]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9993, 0.9998, 0.9994, 0.9997, 0.9995, 0.9998, 0.9998, 0.9997, 0.9997,\n", + " 0.9997, 0.9995, 0.9998, 0.9998, 0.9996, 0.9998, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.0745, 5.1421, 5.0999, 4.9805, 4.8063, 4.5928, 4.3508, 4.0880, 3.8098,\n", + " 3.5204, 3.2226, 2.9185, 2.6099, 2.2978, 1.9831, 1.6664, 1.3484, 1.0292,\n", + " 0.7092, 0.3886])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0166, grad_fn=) , base rewards= tensor([9.4794, 9.4794, 9.4794, 9.4794, 9.4794, 8.7231, 8.0672, 7.4840, 6.9535,\n", + " 6.4612, 5.9969, 5.5532, 5.1247, 4.7074, 4.2984, 3.8957, 3.4975, 3.1029,\n", + " 2.7108, 2.3206, 1.9319, 1.5442, 1.1574, 0.7712, 0.3854]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9993, 0.9998, 0.9994, 0.9998, 0.9995, 0.9998, 0.9998, 0.9997, 0.9998,\n", + " 0.9997, 0.9996, 0.9998, 0.9998, 0.9997, 0.9999, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.3948, 5.4624, 5.4205, 5.3014, 5.1275, 4.9141, 4.6721, 4.4093, 4.1312,\n", + " 3.8417, 3.5439, 3.2399, 2.9313, 2.6191, 2.3044, 1.9878, 1.6697, 1.3506,\n", + " 1.0306, 0.7100, 0.3890])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0163, grad_fn=) , base rewards= tensor([9.8309, 9.8309, 9.8309, 9.8309, 9.0923, 8.4448, 7.8656, 7.3369, 6.8455,\n", + " 6.3817, 5.9382, 5.5097, 5.0925, 4.6836, 4.2808, 3.8827, 3.4880, 3.0959,\n", + " 2.7058, 2.3170, 1.9294, 1.5426, 1.1564, 0.7706, 0.3852]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9994, 0.9998, 0.9995, 0.9998, 0.9996, 0.9999, 0.9998, 0.9997, 0.9998,\n", + " 0.9997, 0.9996, 0.9999, 0.9998, 0.9997, 0.9999, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.7143, 5.7819, 5.7407, 5.6222, 5.4486, 5.2354, 4.9936, 4.7309, 4.4528,\n", + " 4.1634, 3.8656, 3.5615, 3.2529, 2.9408, 2.6261, 2.3094, 1.9914, 1.6722,\n", + " 1.3522, 1.0316, 0.7106, 0.3892])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0176, grad_fn=) , base rewards= tensor([10.1492, 10.1492, 10.1492, 9.4457, 8.8147, 8.2433, 7.7183, 7.2288,\n", + " 6.7658, 6.3227, 5.8945, 5.4774, 5.0685, 4.6658, 4.2677, 3.8730,\n", + " 3.4809, 3.0907, 2.7020, 2.3144, 1.9275, 1.5413, 1.1556, 0.7701,\n", + " 0.3850]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9995, 0.9999, 0.9995, 0.9998, 0.9996, 0.9999, 0.9998, 0.9998, 0.9998,\n", + " 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999, 0.9998, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.0318, 6.0994, 6.0595, 5.9422, 5.7694, 5.5567, 5.3151, 5.0525, 4.7745,\n", + " 4.4851, 4.1874, 3.8834, 3.5747, 3.2626, 2.9479, 2.6313, 2.3132, 1.9940,\n", + " 1.6741, 1.3535, 1.0324, 0.7111, 0.3894])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0167, grad_fn=) , base rewards= tensor([10.4043, 10.4043, 9.7682, 9.1696, 8.6136, 8.0961, 7.6101, 7.1489,\n", + " 6.7067, 6.2789, 5.8620, 5.4532, 5.0505, 4.6525, 4.2578, 3.8657,\n", + " 3.4756, 3.0868, 2.6992, 2.3124, 1.9262, 1.5404, 1.1550, 0.7698,\n", + " 0.3848]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9995, 0.9999, 0.9996, 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9998,\n", + " 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.3452, 6.4128, 6.3756, 6.2606, 6.0894, 5.8776, 5.6365, 5.3742, 5.0963,\n", + " 4.8070, 4.5093, 4.2053, 3.8967, 3.5846, 3.2699, 2.9532, 2.6352, 2.3160,\n", + " 1.9960, 1.6754, 1.3544, 1.0330, 0.7114, 0.3896])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([10.5430, 10.0317, 9.4952, 8.9696, 8.4668, 7.9880, 7.5303, 7.0898,\n", + " 6.6628, 6.2463, 5.8377, 5.4352, 5.0371, 4.6425, 4.2504, 3.8603,\n", + " 3.4716, 3.0839, 2.6971, 2.3109, 1.9251, 1.5397, 1.1545, 0.7696,\n", + " 0.3847]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9996, 0.9999, 0.9996, 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.6501, 6.7177, 6.6859, 6.5756, 6.4075, 6.1975, 5.9575, 5.6957, 5.4181,\n", + " 5.1290, 4.8313, 4.5273, 4.2187, 3.9066, 3.5919, 3.2753, 2.9572, 2.6381,\n", + " 2.3181, 1.9975, 1.6765, 1.3551, 1.0335, 0.7116, 0.3897])\n", + "0,[0.0001,1][1, 10000, 1, 1],1682338032 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[50996, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 171931.00017309192, 61130.999905586235, 0.01784641481935978, 0.0001, 1, 0, 'tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\\n 26, 26, 26, 26, 26, 26, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[0.0001,1][1, 10000, 1, 1],1682338032', 25, 50, 171931.00017309192, 216972.079356517, 90141.68158887929, 132851.47466666668, 129867.688, 75586.00175631171, 75586.00175631171, 91712.14211264676, 91712.14211264676, 103918.78070576812, 75586.00175631171, 91712.14211264676]\n", + "policy reset\n", + "----------------------------------------\n", + "20196 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9829, 0.9817, 0.9833, 0.9813, 0.9814, 0.9830, 0.9766, 0.9877, 0.9829,\n", + " 0.9777, 0.9770, 0.9807, 0.9820, 0.9828, 0.9853, 0.9854, 0.9831, 0.9799,\n", + " 0.9780, 0.9840, 0.9796, 0.9798, 0.9782, 0.9862, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "29231 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 4, 0, 0, 0, 0, 0, 0, 0, 18, 18, 0, 18, 0, 0, 2, 0, 0,\n", + " 2, 0, 18, 18, 0, 18, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033,\n", + " 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033,\n", + " 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 0.5884]) return= 145639.90478618248\n", + "probs of actions: tensor([0.8123, 0.0217, 0.8376, 0.8246, 0.8538, 0.8365, 0.6731, 0.8068, 0.8012,\n", + " 0.5065, 0.1790, 0.7986, 0.3048, 0.8478, 0.8667, 0.0651, 0.7699, 0.7195,\n", + " 0.0874, 0.7782, 0.1389, 0.1057, 0.7413, 0.9990, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5350, 0.5644, 0.5634, 0.5630, 0.5627, 0.5626, 0.5626, 0.5625,\n", + " 0.5301, 0.5996, 0.6683, 0.5819, 0.6591, 0.6099, 0.5855, 0.5818, 0.5721,\n", + " 0.5669, 0.5724, 0.5351, 0.6022, 0.6697, 0.5825, 0.6595])\n", + "finalReturns: tensor([0.0387, 0.0711])\n", + "----------------------------------------\n", + "5854 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 18, 18, 18,\n", + " 18, 18, 18, 0, 18, 18, 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903,\n", + " 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903,\n", + " 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.1589, 0.5624]) return= 162500.80801629333\n", + "probs of actions: tensor([0.9176, 0.9049, 0.8263, 0.8896, 0.8708, 0.9044, 0.9630, 0.9452, 0.9347,\n", + " 0.9912, 0.9645, 0.9213, 0.9762, 0.8875, 0.1613, 0.8918, 0.9604, 0.9668,\n", + " 0.9129, 0.9288, 0.9479, 0.0403, 0.9990, 0.9999, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.7056, 0.5996, 0.6359, 0.6544,\n", + " 0.6638, 0.6685, 0.6708, 0.7044, 0.5991, 0.6356, 0.6867])\n", + "finalReturns: tensor([0.1310, 0.1634, 0.1243])\n", + "----------------------------------------\n", + "225 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0006, grad_fn=) , base rewards= tensor([2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587,\n", + " 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587,\n", + " 2.4587, 2.4587, 2.4587, 2.4587, 1.7531, 1.1211, 0.5416]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9828, 0.9791, 0.9639, 0.9793, 0.9724, 0.9812, 0.9923, 0.9902, 0.9876,\n", + " 0.9981, 0.9930, 0.9858, 0.9954, 0.9777, 0.9626, 0.9789, 0.9934, 0.9941,\n", + " 0.9832, 0.9868, 0.9900, 0.9990, 0.9996, 1.0000, 0.9989],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.2665, 0.2989, 0.2577, 0.1640])\n", + "----------------------------------------\n", + "61 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728,\n", + " 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728,\n", + " 2.9728, 2.9728, 2.9728, 2.2672, 1.6351, 1.0556, 0.5140]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9912, 0.9893, 0.9827, 0.9902, 0.9873, 0.9906, 0.9962, 0.9955, 0.9940,\n", + " 0.9990, 0.9965, 0.9933, 0.9976, 0.9892, 0.9819, 0.9897, 0.9967, 0.9971,\n", + " 0.9915, 0.9931, 0.9990, 0.9995, 0.9998, 1.0000, 0.9988],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.4256, 0.4580, 0.4169, 0.3232, 0.1916])\n", + "----------------------------------------\n", + "41 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0014, grad_fn=) , base rewards= tensor([3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666,\n", + " 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666,\n", + " 3.4666, 3.4666, 2.7610, 2.1289, 1.5494, 1.0078, 0.4938]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9953, 0.9943, 0.9912, 0.9949, 0.9935, 0.9952, 0.9979, 0.9978, 0.9969,\n", + " 0.9995, 0.9981, 0.9966, 0.9987, 0.9945, 0.9906, 0.9946, 0.9983, 0.9985,\n", + " 0.9955, 0.9990, 0.9996, 0.9997, 0.9998, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.6050, 0.6374, 0.5963, 0.5026, 0.3710, 0.2118])\n", + "----------------------------------------\n", + "26 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455,\n", + " 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455,\n", + " 3.9455, 3.2399, 2.6078, 2.0283, 1.4867, 0.9727, 0.4789]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9972, 0.9965, 0.9948, 0.9969, 0.9961, 0.9970, 0.9987, 0.9987, 0.9981,\n", + " 0.9996, 0.9989, 0.9980, 0.9991, 0.9967, 0.9943, 0.9967, 0.9989, 0.9991,\n", + " 0.9990, 0.9995, 0.9998, 0.9998, 0.9999, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.7993, 0.8317, 0.7906, 0.6969, 0.5653, 0.4061, 0.2267])\n", + "----------------------------------------\n", + "1 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134,\n", + " 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134,\n", + " 3.7078, 3.0757, 2.4962, 1.9546, 1.4406, 0.9468, 0.4679]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9972, 0.9966, 0.9950, 0.9970, 0.9963, 0.9971, 0.9987, 0.9987, 0.9982,\n", + " 0.9997, 0.9989, 0.9980, 0.9992, 0.9968, 0.9945, 0.9968, 0.9989, 0.9991,\n", + " 0.9991, 0.9996, 0.9998, 0.9998, 0.9999, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.0046, 1.0370, 0.9959, 0.9022, 0.7706, 0.6114, 0.4320, 0.2377])\n", + "----------------------------------------\n", + "1 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731,\n", + " 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.1675,\n", + " 3.5355, 2.9560, 2.4143, 1.9003, 1.4065, 0.9276, 0.4597]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9973, 0.9967, 0.9951, 0.9971, 0.9964, 0.9972, 0.9988, 0.9988, 0.9983,\n", + " 0.9997, 0.9989, 0.9981, 0.9992, 0.9969, 0.9946, 0.9969, 0.9990, 0.9992,\n", + " 0.9992, 0.9996, 0.9998, 0.9998, 0.9999, 1.0000, 0.9986],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.2181, 1.2505, 1.2093, 1.1156, 0.9841, 0.8249, 0.6455, 0.4512, 0.2459])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "15 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267,\n", + " 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 4.6211, 3.9891,\n", + " 3.4096, 2.8680, 2.3539, 1.8601, 1.3812, 0.9133, 0.4536]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9984, 0.9980, 0.9971, 0.9982, 0.9979, 0.9983, 0.9992, 0.9993, 0.9990,\n", + " 0.9998, 0.9993, 0.9989, 0.9995, 0.9982, 0.9968, 0.9991, 0.9997, 0.9997,\n", + " 0.9996, 0.9998, 0.9999, 0.9999, 0.9999, 1.0000, 0.9985],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.4377, 1.4701, 1.4289, 1.3352, 1.2036, 1.0445, 0.8651, 0.6708, 0.4655,\n", + " 0.2520])\n", + "----------------------------------------\n", + "14 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758,\n", + " 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.0702, 4.4382, 3.8587,\n", + " 3.3171, 2.8030, 2.3092, 1.8303, 1.3624, 0.9027, 0.4491]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9988, 0.9984, 0.9990, 0.9988, 0.9990, 0.9995, 0.9996, 0.9994,\n", + " 0.9999, 0.9996, 0.9993, 0.9997, 0.9990, 0.9990, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.6618, 1.6942, 1.6530, 1.5593, 1.4277, 1.2686, 1.0892, 0.8949, 0.6896,\n", + " 0.4761, 0.2565])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0056, grad_fn=) , base rewards= tensor([6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209,\n", + " 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 5.5156, 4.8837, 4.3043, 3.7627,\n", + " 3.2487, 2.7549, 2.2760, 1.8081, 1.3484, 0.8948, 0.4457]) return= 163476.0224004586\n", + "probs of actions: tensor([9.9908e-01, 9.9883e-01, 9.9843e-01, 9.9899e-01, 7.8089e-04, 9.9918e-01,\n", + " 9.9949e-01, 9.9957e-01, 9.9941e-01, 9.9986e-01, 9.9962e-01, 9.9937e-01,\n", + " 9.9969e-01, 9.9901e-01, 9.9912e-01, 9.9968e-01, 9.9988e-01, 9.9989e-01,\n", + " 9.9982e-01, 9.9987e-01, 9.9993e-01, 9.9994e-01, 9.9993e-01, 9.9999e-01,\n", + " 9.9840e-01], grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6925, 0.5934, 0.6327, 0.6528, 0.6630,\n", + " 0.6681, 0.6706, 0.6719, 0.6726, 0.6729, 0.6730, 0.6731, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.8893, 1.9217, 1.8805, 1.7868, 1.6552, 1.4961, 1.3167, 1.1224, 0.9171,\n", + " 0.7036, 0.4840, 0.2599])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645,\n", + " 6.6645, 6.6645, 6.6645, 6.6645, 5.9590, 5.3270, 4.7475, 4.2059, 3.6919,\n", + " 3.1981, 2.7192, 2.2513, 1.7916, 1.3379, 0.8889, 0.4432]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9990, 0.9989, 0.9991, 0.9996, 0.9996, 0.9994,\n", + " 0.9999, 0.9996, 0.9994, 0.9997, 0.9991, 0.9992, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.1194, 2.1518, 2.1106, 2.0169, 1.8853, 1.7261, 1.5467, 1.3524, 1.1471,\n", + " 0.9336, 0.7141, 0.4899, 0.2624])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0079, grad_fn=) , base rewards= tensor([7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057,\n", + " 7.1057, 7.1057, 7.1057, 6.4002, 5.7682, 5.1888, 4.6472, 4.1331, 3.6393,\n", + " 3.1604, 2.6925, 2.2328, 1.7792, 1.3301, 0.8844, 0.4413]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9991, 0.9989, 0.9991, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9996, 0.9994, 0.9997, 0.9991, 0.9992, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.3513, 2.3837, 2.3425, 2.2488, 2.1172, 1.9581, 1.7787, 1.5844, 1.3791,\n", + " 1.1656, 0.9460, 0.7219, 0.4944, 0.2643])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0087, grad_fn=) , base rewards= tensor([7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454,\n", + " 7.5454, 7.5454, 6.8400, 6.2080, 5.6286, 5.0870, 4.5730, 4.0792, 3.6003,\n", + " 3.1324, 2.6727, 2.2190, 1.7700, 1.3243, 0.8811, 0.4398]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9989, 0.9986, 0.9991, 0.9990, 0.9991, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9997, 0.9994, 0.9997, 0.9992, 0.9993, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.5846, 2.6170, 2.5759, 2.4822, 2.3506, 2.1914, 2.0120, 1.8177, 1.6124,\n", + " 1.3989, 1.1794, 0.9552, 0.7277, 0.4977, 0.2658])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0089, grad_fn=) , base rewards= tensor([7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837,\n", + " 7.9837, 7.2786, 6.6467, 6.0673, 5.5258, 5.0118, 4.5180, 4.0390, 3.5712,\n", + " 3.1114, 2.6578, 2.2087, 1.7630, 1.3199, 0.8786, 0.4388]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9990, 0.9986, 0.9991, 0.9990, 0.9992, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9997, 0.9995, 0.9997, 0.9993, 0.9993, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.8190, 2.8514, 2.8103, 2.7166, 2.5850, 2.4258, 2.2464, 2.0521, 1.8468,\n", + " 1.6334, 1.4138, 1.1897, 0.9622, 0.7321, 0.5002, 0.2668])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0101, grad_fn=) , base rewards= tensor([8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209,\n", + " 7.7162, 7.0845, 6.5052, 5.9637, 5.4497, 4.9559, 4.4770, 4.0091, 3.5494,\n", + " 3.0958, 2.6467, 2.2010, 1.7579, 1.3166, 0.8768, 0.4380]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9990, 0.9987, 0.9992, 0.9991, 0.9992, 0.9996, 0.9997, 0.9995,\n", + " 0.9999, 0.9997, 0.9995, 0.9998, 0.9993, 0.9994, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.0542, 3.0866, 3.0455, 2.9518, 2.8202, 2.6610, 2.4816, 2.2874, 2.0821,\n", + " 1.8686, 1.6490, 1.4249, 1.1974, 0.9673, 0.7354, 0.5020, 0.2676])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0108, grad_fn=) , base rewards= tensor([8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.1528,\n", + " 7.5215, 6.9424, 6.4010, 5.8871, 5.3933, 4.9144, 4.4465, 3.9868, 3.5332,\n", + " 3.0841, 2.6384, 2.1953, 1.7540, 1.3142, 0.8754, 0.4374]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9987, 0.9992, 0.9991, 0.9992, 0.9996, 0.9997, 0.9996,\n", + " 0.9999, 0.9997, 0.9996, 0.9998, 0.9994, 0.9994, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.2900, 3.3224, 3.2812, 3.1876, 3.0560, 2.8968, 2.7175, 2.5232, 2.3179,\n", + " 2.1044, 1.8848, 1.6607, 1.4332, 1.2031, 0.9712, 0.7378, 0.5034, 0.2682])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0117, grad_fn=) , base rewards= tensor([9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 8.5882, 7.9578,\n", + " 7.3790, 6.8378, 6.3239, 5.8302, 5.3513, 4.8834, 4.4237, 3.9701, 3.5210,\n", + " 3.0754, 2.6322, 2.1909, 1.7511, 1.3123, 0.8743, 0.4369]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9991, 0.9988, 0.9992, 0.9991, 0.9993, 0.9996, 0.9997, 0.9996,\n", + " 0.9999, 0.9997, 0.9996, 0.9998, 0.9994, 0.9995, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.5261, 3.5585, 3.5174, 3.4238, 3.2922, 3.1331, 2.9537, 2.7594, 2.5541,\n", + " 2.3406, 2.1211, 1.8969, 1.6694, 1.4394, 1.2075, 0.9741, 0.7397, 0.5045,\n", + " 0.2687])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0138, grad_fn=) , base rewards= tensor([9.7209, 9.7209, 9.7209, 9.7209, 9.7209, 9.7209, 9.0218, 8.3929, 7.8149,\n", + " 7.2740, 6.7604, 6.2667, 5.7879, 5.3200, 4.8603, 4.4067, 3.9577, 3.5120,\n", + " 3.0688, 2.6275, 2.1877, 1.7489, 1.3109, 0.8735, 0.4366]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9991, 0.9989, 0.9993, 0.9992, 0.9993, 0.9997, 0.9997, 0.9996,\n", + " 0.9999, 0.9998, 0.9996, 0.9998, 0.9995, 0.9995, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.7624, 3.7948, 3.7538, 3.6602, 3.5288, 3.3696, 3.1903, 2.9960, 2.7907,\n", + " 2.5772, 2.3577, 2.1335, 1.9060, 1.6760, 1.4441, 1.2107, 0.9763, 0.7411,\n", + " 0.5053, 0.2690])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0163, grad_fn=) , base rewards= tensor([10.1448, 10.1448, 10.1448, 10.1448, 10.1448, 9.4522, 8.8264, 8.2499,\n", + " 7.7097, 7.1964, 6.7029, 6.2242, 5.7563, 5.2967, 4.8431, 4.3940,\n", + " 3.9483, 3.5052, 3.0639, 2.6241, 2.1853, 1.7473, 1.3099, 0.8730,\n", + " 0.4364]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9992, 0.9989, 0.9993, 0.9992, 0.9993, 0.9997, 0.9997, 0.9996,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9995, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.9987, 4.0311, 3.9903, 3.8969, 3.7655, 3.6064, 3.4271, 3.2328, 3.0276,\n", + " 2.8141, 2.5945, 2.3704, 2.1429, 1.9128, 1.6809, 1.4475, 1.2131, 0.9779,\n", + " 0.7421, 0.5058, 0.2692])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0183, grad_fn=) , base rewards= tensor([10.5560, 10.5560, 10.5560, 10.5560, 9.8764, 9.2568, 8.6832, 8.1445,\n", + " 7.6319, 7.1387, 6.6602, 6.1924, 5.7328, 5.2792, 4.8302, 4.3845,\n", + " 3.9413, 3.5001, 3.0602, 2.6214, 2.1835, 1.7461, 1.3091, 0.8725,\n", + " 0.4362]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9992, 0.9990, 0.9993, 0.9993, 0.9994, 0.9997, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.2346, 4.2670, 4.2265, 4.1334, 4.0022, 3.8433, 3.6640, 3.4698, 3.2646,\n", + " 3.0511, 2.8315, 2.6074, 2.3799, 2.1499, 1.9179, 1.6846, 1.4502, 1.2149,\n", + " 0.9791, 0.7429, 0.5063, 0.2694])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0216, grad_fn=) , base rewards= tensor([10.9428, 10.9428, 10.9428, 10.2887, 9.6813, 9.1136, 8.5777, 8.0665,\n", + " 7.5741, 7.0958, 6.6283, 6.1687, 5.7152, 5.2662, 4.8205, 4.3773,\n", + " 3.9361, 3.4962, 3.0575, 2.6195, 2.1821, 1.7451, 1.3085, 0.8722,\n", + " 0.4360]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9990, 0.9994, 0.9993, 0.9995, 0.9997, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.4695, 4.5019, 4.4621, 4.3697, 4.2389, 4.0802, 3.9011, 3.7069, 3.5017,\n", + " 3.2883, 3.0687, 2.8446, 2.6171, 2.3870, 2.1551, 1.9218, 1.6873, 1.4521,\n", + " 1.2163, 0.9801, 0.7435, 0.5066, 0.2696])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0235, grad_fn=) , base rewards= tensor([11.2821, 11.2821, 10.6776, 10.0943, 9.5383, 9.0082, 8.4997, 8.0087,\n", + " 7.5311, 7.0639, 6.6045, 6.1510, 5.7020, 5.2564, 4.8132, 4.3720,\n", + " 3.9322, 3.4934, 3.0554, 2.6180, 2.1811, 1.7445, 1.3081, 0.8719,\n", + " 0.4359]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9991, 0.9994, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9999, 0.9997, 0.9997, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.7023, 4.7347, 4.6963, 4.6051, 4.4751, 4.3169, 4.1381, 3.9441, 3.7389,\n", + " 3.5255, 3.3060, 3.0819, 2.8544, 2.6243, 2.3924, 2.1590, 1.9246, 1.6894,\n", + " 1.4536, 1.2173, 0.9807, 0.7439, 0.5069, 0.2697])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0243, grad_fn=) , base rewards= tensor([11.5326, 11.0213, 10.4848, 9.9519, 9.4330, 8.9302, 8.4418, 7.9656,\n", + " 7.4991, 7.0400, 6.5867, 6.1378, 5.6922, 5.2491, 4.8078, 4.3680,\n", + " 3.9292, 3.4912, 3.0538, 2.6169, 2.1803, 1.7439, 1.3078, 0.8718,\n", + " 0.4358]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9995, 0.9994, 0.9992, 0.9995, 0.9995, 0.9996, 0.9998, 0.9998, 0.9998,\n", + " 0.9999, 0.9998, 0.9998, 0.9999, 0.9997, 0.9997, 0.9999, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.9307, 4.9631, 4.9275, 4.8387, 4.7104, 4.5531, 4.3748, 4.1811, 3.9761,\n", + " 3.7628, 3.5433, 3.3192, 3.0917, 2.8617, 2.6298, 2.3964, 2.1620, 1.9268,\n", + " 1.6910, 1.4547, 1.2181, 0.9813, 0.7442, 0.5070, 0.2698])\n", + "0,[0.0001,1][1, 10000, 1, 1],1682339633 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[55690, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 164632.33345850307, 70408.33325584729, 0.024329129606485367, 0.0001, 1, 0, 'tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\\n 18, 18, 18, 18, 18, 18, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[0.0001,1][1, 10000, 1, 1],1682339633', 25, 50, 164632.33345850307, 193521.20851536895, 78111.91688437786, 135363.21866666665, 132442.06666666665, 102604.52812037412, 102604.52812037412, 120699.79187222247, 120699.79187222247, 90621.14382460734, 102604.52812037412, 120699.79187222247]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=3_000_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm.solver(print_step=100_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small-checkpoint.ipynb new file mode 100644 index 0000000..ddca4e0 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/.ipynb_checkpoints/small-checkpoint.ipynb @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "import environmentModelBase as model\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "const95= model.Strategy(model.StrategyType.static, model.const,name=\"const95\", firstPrice=95 )\n", + "actionStep=3\n", + "adv= model.Adversary()\n", + "adv._strategies.append(const95)\n", + "adv._strategyProbs=torch.ones(1)\n", + "game = model.Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 4, adversary=adv, stateAdvHistory=1, actionStep=actionStep)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.0001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'Model' object has no attribute 'adversaryMode'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m neuralNet\u001b[38;5;241m=\u001b[39mNNBase(num_input\u001b[38;5;241m=\u001b[39mgame\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m+\u001b[39mgame\u001b[38;5;241m.\u001b[39mstateAdvHistory, lr\u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m0\u001b[39m],num_actions\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m18\u001b[39m,action_step\u001b[38;5;241m=\u001b[39mactionStep)\n\u001b[0;32m 2\u001b[0m algorithm \u001b[38;5;241m=\u001b[39m ReinforceAlgorithm(game, neuralNet, numberIterations\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, numberEpisodes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3_000_000\u001b[39m, discountFactor \u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m----> 5\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolver\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m,\u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:104\u001b[0m, in \u001b[0;36mReinforceAlgorithm.solver\u001b[1;34m(self, print_step, options, converge_break)\u001b[0m\n\u001b[0;32m 101\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss\u001b[38;5;241m.\u001b[39mappend([])\n\u001b[0;32m 103\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m--> 104\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage_onwards\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43miter\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnumberEpisodes\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprint_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 105\u001b[0m \u001b[43m \u001b[49m\u001b[43mprob_break_limit_ln\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprobBreakLn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwrite_save\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m 107\u001b[0m axs[\u001b[38;5;28miter\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])\n\u001b[0;32m 108\u001b[0m axs[\u001b[38;5;28miter\u001b[39m][\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:188\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage_onwards\u001b[1;34m(self, iter, stage, episodes, print_step, prob_break_limit_ln, options, lr, just_stage, write_save)\u001b[0m\n\u001b[0;32m 184\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (episode \u001b[38;5;241m%\u001b[39m print_step \u001b[38;5;241m==\u001b[39m (print_step\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)) \u001b[38;5;129;01mor\u001b[39;00m shouldBreak:\n\u001b[0;32m 185\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m40\u001b[39m)\n\u001b[1;32m--> 188\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124miter \u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;28miter\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m stage \u001b[39m\u001b[38;5;124m\"\u001b[39m,stage,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m ep \u001b[39m\u001b[38;5;124m\"\u001b[39m,episode, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m adversary: \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madversaryMode\u001b[49m)\n\u001b[0;32m 189\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m actions: \u001b[39m\u001b[38;5;124m\"\u001b[39m, actions)\n\u001b[0;32m 191\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mloss= \u001b[39m\u001b[38;5;124m\"\u001b[39m, loss, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m , base rewards=\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 192\u001b[0m baseRewards, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreturn= \u001b[39m\u001b[38;5;124m\"\u001b[39m, returns)\n", + "\u001b[1;31mAttributeError\u001b[0m: 'Model' object has no attribute 'adversaryMode'" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.stateAdvHistory, lr=hyperParams[0],num_actions=18,action_step=actionStep)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=3_000_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm.solver(print_step=100_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a=[0]*0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/BimatrixGame.py b/learningAgents/naive_policy_gradient/PGM_base/BimatrixGame.py new file mode 100644 index 0000000..909cfca --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/BimatrixGame.py @@ -0,0 +1,249 @@ +from enum import Enum +import globals as gl +import torch +from torch.distributions import Categorical +import torch.nn as nn +import numpy as np +from environmentModelBase import Model, MixedStrategy, Strategy, StrategyType +import environmentModelBase as em +from learningBase import ReinforceAlgorithm +from neuralNetworkSimple import NNBase +from fractions import Fraction +import bimatrix + +# totalDemand = 400 +# lowCost = 57 +# highCost = 71 +# totalStages = 25 +# adversaryHistroy = 3 +# lr = 0.000005 +# gamma = 1 +# numActions = 3 +# actionStep = 3 +# numStochasticIter = 10 + +# # episodes for learning the last stage, then for 2nd to last stage 2*numEpisodes. In total:300*numEpisodes +# numEpisodes = 3000 +# numEpisodesReset = numEpisodes +# # increase in num of episodes for each adv in support +# episodeIncreaseAdv = 1000 + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + _strategies_low = [] + _strategies_high = [] + _matrix_A = None + _matrix_B = None + + def __init__(self, lowCostStrategies, highCostStrategies) -> None: + # globals.initialize() + self._strategies_low = lowCostStrategies + self._strategies_high = highCostStrategies + + def reset_matrix(self): + self._matrix_A = np.zeros( + (len(self._strategies_low), len(self._strategies_high))) + self._matrix_B = np.zeros( + (len(self._strategies_low), len(self._strategies_high))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self._strategies_low)): + for high in range(len(self._strategies_high)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, lowIndex, highIndex): + stratL = self._strategies_low[lowIndex] + stratH = self._strategies_high[highIndex] + stratL.reset() + stratH.reset() + + env = Model(totalDemand=gl.totalDemand, tupleCosts=(gl.lowCost, gl.highCost), + totalStages=gl.totalStages, advMixedStrategy=stratH.to_mixed_strategy()) + [self._matrix_A[lowIndex][highIndex], self._matrix_B[lowIndex] + [highIndex]] = stratL.play_against(env, stratH) + pass + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self._matrix_A)} {len(self._matrix_A[0])}\n\n" + + for matrix in [self._matrix_A, self._matrix_B]: + for i in range(len(self._matrix_A)): + for j in range(len(self._matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f".\games\game{len(self._matrix_A)}x{len(self._matrix_A[0])}.txt", "w") as out: + out.write(output) + with open("game.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, rowA, rowB): + self._matrix_A = np.append(self._matrix_A, [rowA], axis=0) + self._matrix_B = np.append(self._matrix_B, [rowB], axis=0) + + def add_high_cost_col(self, colA, colB): + self._matrix_A = np.hstack((self._matrix_A, np.atleast_2d(colA).T)) + self._matrix_B = np.hstack((self._matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibrium = game.tracing(100) + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self._strategies_low), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self._strategies_high), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self._matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self._matrix_B, np.transpose(high_cost_probabilities))) + + low_prob_str = ", ".join(map("{0:.2f}".format, low_cost_probabilities)) + high_prob_str = ", ".join(map("{0:.2f}".format, high_cost_probabilities)) + print( + f"equi: [{low_prob_str}], [{high_prob_str}], {low_cost_payoff:.2f}, {high_cost_payoff:.2f}") + return low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff + + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + + +def training(costs, advMixedStrategy, targetPayoff): + """ + trains a neuralnet against adversaries. if the expected payoff of new agent is greater than payoff, returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + acceptable = False + + game = Model(gl.totalDemand, costs, gl.totalStages, + advMixedStrategy=advMixedStrategy, stateAdvHistory=gl.adversaryHistroy) + neuralNet = NNBase(num_input=game.T+2+game.stateAdvHistory, + lr=gl.lr, num_actions=gl.numActions, action_step=gl.actionStep, adv_hist=game.stateAdvHistory) + + numberEpisodes = gl.numEpisodes+gl.episodeIncreaseAdv * \ + (support_count(advMixedStrategy._strategyProbs)) + algorithm = ReinforceAlgorithm( + game, neuralNet, numberIterations=1, numberEpisodes=numberEpisodes, discountFactor=gl.gamma) + algorithm.solver(print_step=None, options=[ + 1, 10000, 1, 1], converge_break=True) + a = algorithm.returns[0][-1] + print(f"{neuralNet.nn_name} is trained against {str(advMixedStrategy)}") + + agentPayoffs = np.zeros(len(advMixedStrategy._strategies)) + advPayoffs = np.zeros(len(advMixedStrategy._strategies)) + expectedPayoff = 0 + for strategyIndex in range(len(advMixedStrategy._strategies)): + if advMixedStrategy._strategyProbs[strategyIndex] > 0: + returns = algorithm.playTrainedAgent(adversary=( + (advMixedStrategy._strategies[strategyIndex]).to_mixed_strategy()), iterNum=gl.numStochasticIter) + agentPayoffs[strategyIndex] = torch.mean(returns[0]) + advPayoffs[strategyIndex] = torch.mean(returns[1]) + expectedPayoff += (agentPayoffs[strategyIndex]) * \ + (advMixedStrategy._strategyProbs[strategyIndex]) + if expectedPayoff > targetPayoff: + acceptable = True + algorithm.write_nn_data(("low" if costs[0] 0: + counter += 1 + return counter + + +def run_tournament_random(number_rounds): + equilibria = [] + neuralNet = NNBase(num_input=gl.totalStages+2+gl.adversaryHistroy, + lr=gl.lr, num_actions=gl.numActions, action_step=gl.actionStep, adv_hist=gl.adversaryHistroy) + neuralNet.reset() + randStrategy = Strategy(StrategyType.neural_net, + NNorFunc=neuralNet, name="nnRandom") + low_cost_players = [randStrategy] + high_cost_players = [randStrategy] + bimatrixGame = BimatrixGame(low_cost_players, high_cost_players) + # bimatrixGame.reset_matrix() + bimatrixGame.fill_matrix() + low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + for round in range(number_rounds): + print("Round", round, " of ", number_rounds) + + update = False + + + acceptable, agentPayoffs, advPayoffs, low_cost_player = training([gl.lowCost, gl.highCost], advMixedStrategy=MixedStrategy( + strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), targetPayoff=low_cost_payoff) + if acceptable: + update = True + low_cost_players.append(low_cost_player) + bimatrixGame.add_low_cost_row(agentPayoffs, advPayoffs) + equilibria.append( + [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) + print(f"low cost player {low_cost_player._name} added") + + low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + + acceptable, agentPayoffs, advPayoffs, high_cost_player = training( + [gl.highCost, gl.lowCost], advMixedStrategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), targetPayoff=high_cost_payoff) + + if acceptable: + update = True + high_cost_players.append(high_cost_player) + bimatrixGame.add_high_cost_col(advPayoffs, agentPayoffs) + equilibria.append( + [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) + print(f"high cost player {high_cost_player._name} added") + + low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + if update: + gl.numEpisodes = gl.numEpisodesReset + else: + gl.numEpisodes += 1000 + return equilibria, bimatrixGame diff --git a/learningAgents/naive_policy_gradient/PGM_base/Deep_Q-Learning.ipynb b/learningAgents/naive_policy_gradient/PGM_base/Deep_Q-Learning.ipynb new file mode 100644 index 0000000..1ac8fcc --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/Deep_Q-Learning.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "authorized-valve", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from collections import deque, namedtuple\n", + "from environment import Model, AdversaryModes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f30716d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_demand = 400\n", + "agent_cost = 57\n", + "adversary_cost = 71 \n", + "costs = [agent_cost,adversary_cost]\n", + "total_stages = 25\n", + "adversary_probabilities=[0]*len(AdversaryModes)\n", + "adversary_probabilities[0]=1\n", + "\n", + "env = Model(total_demand, costs, total_stages, adversary_probabilities)\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d3611c5", + "metadata": {}, + "outputs": [], + "source": [ + "class QNetwork(nn.Module):\n", + "\n", + " def __init__(self, state_size, action_size):\n", + " super().__init__() \n", + " self.input_layer = nn.Linear(state_size, 200)\n", + " self.hidden_layer = nn.Linear(200, 200)\n", + " self.output_layer = nn.Linear(200, action_size)\n", + " \n", + " def forward(self, state):\n", + " x = self.input_layer(state)\n", + " x = F.relu(x)\n", + " x = self.hidden_layer(x)\n", + " x = F.relu(x)\n", + " x = self.output_layer(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2a6a493", + "metadata": {}, + "outputs": [], + "source": [ + "BUFFER_SIZE = int(10_000) # replay buffer size\n", + "BATCH_SIZE = 64 # minibatch size\n", + "GAMMA = 1 # discount factor\n", + "TAU = 0.001 # for soft update of target parameters\n", + "LR = 0.0005 # learning rate \n", + "UPDATE_EVERY = 8 # how often to update the network" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b0612b47", + "metadata": {}, + "outputs": [], + "source": [ + "class Agent():\n", + "\n", + " def __init__(self, state_size, action_size):\n", + "\n", + " self.state_size = state_size\n", + " self.action_size = action_size\n", + "\n", + " # Q-Network\n", + " self.qnetwork_local = QNetwork(state_size, action_size)\n", + " self.qnetwork_target = QNetwork(state_size, action_size)\n", + " self.optimiser = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n", + "\n", + " # Replay memory\n", + " self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE)\n", + " # Initialise time step (for updating every UPDATE_EVERY steps)\n", + " self.t_step = 0\n", + " \n", + " def step(self, state, action, reward, next_state, done):\n", + " # Save experience in replay memory\n", + " self.memory.add(state, action, reward, next_state, done)\n", + " \n", + " # Learn every UPDATE_EVERY time steps.\n", + " self.t_step = (self.t_step + 1) % UPDATE_EVERY\n", + " if self.t_step == 0:\n", + " # If enough samples are available in memory, get random subset and learn\n", + " if len(self.memory) > BATCH_SIZE:\n", + " experiences = self.memory.sample()\n", + " self.learn(experiences, GAMMA)\n", + "\n", + " def act(self, state, eps):\n", + "\n", + " state = state.float().unsqueeze(0)\n", + " self.qnetwork_local.eval()\n", + " with torch.no_grad():\n", + " action_values = self.qnetwork_local(state)\n", + " self.qnetwork_local.train()\n", + "\n", + " # Epsilon-greedy action selection\n", + " if random.random() > eps:\n", + " return np.argmax(action_values.data.numpy())\n", + " else:\n", + " return random.choice(np.arange(self.action_size))\n", + "\n", + " def learn(self, experiences, gamma):\n", + "\n", + " states, actions, rewards, next_states, dones = experiences\n", + " q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n", + " q_targets = rewards + gamma * q_targets_next * (1 - dones)\n", + " q_expected = self.qnetwork_local(states).gather(1, actions)\n", + " \n", + " loss = F.mse_loss(q_expected, q_targets)\n", + " self.optimiser.zero_grad()\n", + " loss.backward()\n", + " self.optimiser.step()\n", + "\n", + " self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \n", + "\n", + " def soft_update(self, local_model, target_model, tau):\n", + " \n", + " for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n", + " target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e60fdc3", + "metadata": {}, + "outputs": [], + "source": [ + "class ReplayBuffer:\n", + "\n", + " def __init__(self, action_size, buffer_size, batch_size):\n", + "\n", + " self.action_size = action_size\n", + " self.memory = deque(maxlen=buffer_size) \n", + " self.batch_size = batch_size\n", + " self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n", + " \n", + " def add(self, state, action, reward, next_state, done):\n", + " \"\"\"Add a new experience to memory.\"\"\"\n", + " experience = self.experience(state, action, reward, next_state, done)\n", + " self.memory.append(experience)\n", + " \n", + " def sample(self):\n", + " \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n", + " experiences = random.sample(self.memory, k=self.batch_size)\n", + "\n", + " states = torch.from_numpy(np.vstack([experience.state for experience in experiences if experience is not None])).float()\n", + " actions = torch.from_numpy(np.vstack([experience.action for experience in experiences if experience is not None])).long()\n", + " rewards = torch.from_numpy(np.vstack([experience.reward for experience in experiences if experience is not None])).float()\n", + " next_states = torch.from_numpy(np.vstack([experience.next_state for experience in experiences if experience is not None])).float()\n", + " dones = torch.from_numpy(np.vstack([experience.done for experience in experiences if experience is not None]).astype(np.uint8)).float()\n", + " \n", + " return (states, actions, rewards, next_states, dones)\n", + "\n", + " def __len__(self):\n", + " \"\"\"Return the current size of internal memory.\"\"\"\n", + " return len(self.memory)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7bff3bfd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0\tAverage Score: 169671.00\n", + "Episode 5000\tAverage Score: 165271.83\n", + "Episode 10000\tAverage Score: 165782.55\n", + "Episode 15000\tAverage Score: 166931.08\n", + "Episode 20000\tAverage Score: 167496.04\n", + "Episode 25000\tAverage Score: 169142.78\n", + "Episode 30000\tAverage Score: 171067.50\n", + "Episode 35000\tAverage Score: 171962.95\n", + "Episode 40000\tAverage Score: 172211.15\n", + "Episode 45000\tAverage Score: 172176.92\n", + "Episode 50000\tAverage Score: 173292.13\n", + "Episode 55000\tAverage Score: 174271.68\n", + "Episode 60000\tAverage Score: 176350.42\n", + "Episode 65000\tAverage Score: 177105.63\n", + "Episode 70000\tAverage Score: 178208.86\n", + "Episode 75000\tAverage Score: 177706.84\n", + "Episode 80000\tAverage Score: 177841.97\n", + "Episode 85000\tAverage Score: 176620.66\n", + "Episode 90000\tAverage Score: 177956.96\n", + "Episode 95000\tAverage Score: 177746.00\n", + "Episode 100000\tAverage Score: 178210.52\n", + "Episode 105000\tAverage Score: 177339.47\n", + "Episode 110000\tAverage Score: 177947.92\n", + "Episode 115000\tAverage Score: 177841.17\n", + "Episode 120000\tAverage Score: 177980.15\n", + "Episode 125000\tAverage Score: 177477.03\n", + "Episode 130000\tAverage Score: 178026.23\n", + "Episode 135000\tAverage Score: 178510.44\n", + "Episode 140000\tAverage Score: 178235.72\n", + "Episode 145000\tAverage Score: 178676.76\n", + "Episode 150000\tAverage Score: 177196.13\n", + "Episode 155000\tAverage Score: 176133.93\n", + "Episode 160000\tAverage Score: 178601.00\n", + "Episode 165000\tAverage Score: 178233.33\n", + "Episode 170000\tAverage Score: 177109.69\n", + "Episode 175000\tAverage Score: 178397.17\n", + "Episode 180000\tAverage Score: 178324.12\n", + "Episode 185000\tAverage Score: 178026.06\n", + "Episode 190000\tAverage Score: 178197.18\n", + "Episode 195000\tAverage Score: 177351.39\n", + "Episode 199999\tAverage Score: 178157.79" + ] + } + ], + "source": [ + "def dqn(number_episodes, eps_start=1.0, eps_end=0.0001, eps_decay=0.99995):\n", + "\n", + " scores = [] # list containing scores from each episode\n", + " scores_window = deque(maxlen=100) # last 100 scores\n", + " eps = eps_start # initialise epsilon\n", + " best_payoff = 0\n", + " best_actions = list()\n", + " for episode in range(number_episodes):\n", + " state, reward, done = env.reset()\n", + " score = 0\n", + " actions = list()\n", + " while not done:\n", + " action = agent.act(state, eps)\n", + " actions.append(action)\n", + " next_state, reward, done = env.step(action)\n", + " agent.step(state, action, reward, next_state, done)\n", + " state = next_state\n", + " score += reward\n", + " scores_window.append(score) # save most recent score\n", + " scores.append(score) # save most recent score\n", + " eps = max(eps_end, eps_decay*eps) # decrease epsilon\n", + " if score >= best_payoff:\n", + " best_payoff = score\n", + " best_actions = actions\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)), end=\"\")\n", + " if episode % 5000 == 0:\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)))\n", + " return scores, best_payoff, best_actions\n", + "\n", + "agent = Agent(state_size=2, action_size=60)\n", + "scores, best_payoff, best_actions = dqn(200_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "empirical-friday", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the scores\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(np.arange(len(scores)), scores)\n", + "plt.ylabel('Score')\n", + "plt.xlabel('Episode #')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c8a33b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "180121" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_payoff" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7d0864cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([48, 52, 52, 52, 52, 50, 50, 50, 50, 50, 50, 50, 50, 50, 46, 46, 46,\n", + " 46, 46, 46, 46, 46, 46, 20, 4])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.transpose(best_actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c75ca275", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "177990.99859985997" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e9ffcee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "925.9989800259722" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29f8804a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682348121.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682348121.pt new file mode 100644 index 0000000..4b522ce Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682348121.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682423487.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682423487.pt new file mode 100644 index 0000000..c5f7bb4 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682423487.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682452608.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682452608.pt new file mode 100644 index 0000000..6e0ccfc Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682452608.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682476508.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682476508.pt new file mode 100644 index 0000000..34041e8 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682476508.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682506150.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682506150.pt new file mode 100644 index 0000000..86f4c3e Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682506150.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682631035.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682631035.pt new file mode 100644 index 0000000..abe7c67 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682631035.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682652460.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682652460.pt new file mode 100644 index 0000000..a740ec8 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682652460.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682661769.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682661769.pt new file mode 100644 index 0000000..ac99d5f Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682661769.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682682010.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682682010.pt new file mode 100644 index 0000000..a8ab80f Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682682010.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682701103.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682701103.pt new file mode 100644 index 0000000..47ce68d Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682701103.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682740769.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682740769.pt new file mode 100644 index 0000000..5e2d479 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682740769.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682794213.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682794213.pt new file mode 100644 index 0000000..f634a94 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682794213.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682835632.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682835632.pt new file mode 100644 index 0000000..3c577d2 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682835632.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682849652.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682849652.pt new file mode 100644 index 0000000..00d49ab Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682849652.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682912335.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682912335.pt new file mode 100644 index 0000000..3ec3782 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682912335.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682929682.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682929682.pt new file mode 100644 index 0000000..ab7d174 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682929682.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682974149.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682974149.pt new file mode 100644 index 0000000..a9ec90e Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682974149.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682983428.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682983428.pt new file mode 100644 index 0000000..7f97dec Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682983428.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682999908.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682999908.pt new file mode 100644 index 0000000..8f5d901 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1682999908.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683019988.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683019988.pt new file mode 100644 index 0000000..1134d6a Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683019988.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683049303.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683049303.pt new file mode 100644 index 0000000..9bcf726 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683049303.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683106228.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683106228.pt new file mode 100644 index 0000000..f2c314b Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683106228.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683118086.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683118086.pt new file mode 100644 index 0000000..8a5feec Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/0,[1e-05,1][1, 10000, 1, 1],1683118086.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683134990.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683134990.pt new file mode 100644 index 0000000..f77f30d Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683134990.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683135117.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683135117.pt new file mode 100644 index 0000000..85c9a9b Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[1e-05,1][1, 10000, 1, 1],1683135117.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683165834.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683165834.pt new file mode 100644 index 0000000..c2d7f02 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683165834.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683196677.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683196677.pt new file mode 100644 index 0000000..89d404c Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/1,3,[5e-06,1][1, 10000, 1, 1],1683196677.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/1684237162.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/1684237162.pt new file mode 100644 index 0000000..af8226f Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/1684237162.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682342855.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682342855.pt new file mode 100644 index 0000000..a950780 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682342855.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682344279.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682344279.pt new file mode 100644 index 0000000..32a5dce Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682344279.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682353168.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682353168.pt new file mode 100644 index 0000000..072ea8d Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682353168.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682355025.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682355025.pt new file mode 100644 index 0000000..5bdaea3 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682355025.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682430557.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682430557.pt new file mode 100644 index 0000000..4c057e6 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682430557.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682431321.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682431321.pt new file mode 100644 index 0000000..c207cbc Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682431321.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432060.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432060.pt new file mode 100644 index 0000000..929393c Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432060.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432800.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432800.pt new file mode 100644 index 0000000..d96e20f Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682432800.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682433760.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682433760.pt new file mode 100644 index 0000000..c64ade4 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/3,[1e-05,1][1, 10000, 1, 1],1682433760.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684424924.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684424924.pt new file mode 100644 index 0000000..f1effd5 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684424924.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684821735.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684821735.pt new file mode 100644 index 0000000..8faf086 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/high,1684821735.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684386202.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684386202.pt new file mode 100644 index 0000000..a6491b9 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684386202.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684484716.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684484716.pt new file mode 100644 index 0000000..2a4790e Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684484716.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684557152.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684557152.pt new file mode 100644 index 0000000..e987095 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684557152.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684856358.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684856358.pt new file mode 100644 index 0000000..724e10b Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1684856358.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1685028503.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1685028503.pt new file mode 100644 index 0000000..fc37669 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/low,1685028503.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684153476.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684153476.pt new file mode 100644 index 0000000..3b42315 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684153476.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684181280.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684181280.pt new file mode 100644 index 0000000..91702df Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-0,guess-1.0,,1684181280.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-1.0,guess-0,,1684120927.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-1.0,guess-0,,1684120927.pt new file mode 100644 index 0000000..af6babf Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-0,const-1.0,guess-0,,1684120927.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684144394.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684144394.pt new file mode 100644 index 0000000..3812021 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684144394.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684173528.pt b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684173528.pt new file mode 100644 index 0000000..36f4f42 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/NNs/myopic-1.0,const-0,guess-0,,1684173528.pt differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/Play.ipynb b/learningAgents/naive_policy_gradient/PGM_base/Play.ipynb new file mode 100644 index 0000000..2567400 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/Play.ipynb @@ -0,0 +1,311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame as BG\n", + "import globals as gl\n", + "import torch\n", + "import numpy as np\n", + "from environmentModelBase import Model, MixedStrategy, Strategy, StrategyType\n", + "import environmentModelBase as em\n", + "from learningBase import ReinforceAlgorithm\n", + "from neuralNetworkSimple import NNBase\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sjaha\\Documents\\EquiLearn\\PGM_base\\environmentModelBase.py:344: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " adversaryDist = Categorical(torch.tensor(self._strategyProbs))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "equi: [0.00, 0.00, 1.00], [1.00, 0.00, 0.00], 154997.58, 79665.90\n", + "Round 0 of 50\n", + "1684386202 is trained against myopic-1.00,\n", + "low,1684386202 saved\n", + "low cost player low,1684386202 added\n", + "equi: [0.00, 0.00, 0.00, 1.00], [1.00, 0.00, 0.00], 178432.78, 35256.60\n", + "1684424924 is trained against low,1684386202-1.00,\n", + "high,1684424924 saved\n", + "high cost player high,1684424924 added\n", + "equi: [0.00, 0.00, 0.49, 0.51], [0.06, 0.00, 0.00, 0.94], 125951.71, 57157.89\n", + "Round 1 of 50\n", + "1684484716 is trained against myopic-0.06,high,1684424924-0.94,\n", + "low,1684484716 saved\n", + "low cost player low,1684484716 added\n", + "equi: [0.00, 0.00, 0.86, 0.00, 0.14], [0.61, 0.00, 0.39, 0.00], 149731.40, 74148.84\n", + "1684520477 is trained against guess-0.86,low,1684484716-0.14,\n", + "Round 2 of 50\n", + "1684557152 is trained against myopic-0.61,guess-0.39,\n", + "low,1684557152 saved\n", + "low cost player low,1684557152 added\n", + "equi: [0.00, 0.00, 0.00, 0.00, 1.00, 0.00], [0.00, 0.00, 0.00, 1.00], 125382.90, 51182.05\n", + "1684604536 is trained against low,1684484716-1.00,\n", + "Round 3 of 50\n", + "1684660196 is trained against high,1684424924-1.00,\n", + "1684712683 is trained against low,1684484716-1.00,\n", + "Round 4 of 50\n", + "1684767756 is trained against high,1684424924-1.00,\n", + "1684821735 is trained against low,1684484716-1.00,\n", + "high,1684821735 saved\n", + "high cost player high,1684821735 added\n", + "equi: [0.00, 0.00, 0.91, 0.00, 0.00, 0.09], [0.59, 0.00, 0.41, 0.00, 0.00], 149467.34, 76108.83\n", + "Round 5 of 50\n", + "1684856358 is trained against myopic-0.59,guess-0.41,\n", + "low,1684856358 saved\n", + "low cost player low,1684856358 added\n", + "equi: [0.00, 0.00, 0.91, 0.00, 0.00, 0.00, 0.09], [0.58, 0.00, 0.42, 0.00, 0.00], 149349.14, 76358.19\n", + "1684917192 is trained against guess-0.91,low,1684856358-0.09,\n", + "Round 6 of 50\n", + "1685028503 is trained against myopic-0.58,guess-0.42,\n", + "low,1685028503 saved\n", + "low cost player low,1685028503 added\n", + "equi: [0.00, 0.00, 0.94, 0.00, 0.00, 0.00, 0.00, 0.06], [0.51, 0.00, 0.49, 0.00, 0.00], 148434.17, 77473.34\n", + "1685065319 is trained against guess-0.94,low,1685028503-0.06,\n", + "Round 7 of 50\n", + "1685102633 is trained against myopic-0.51,guess-0.49,\n", + "1685138981 is trained against guess-0.94,low,1685028503-0.06,\n", + "Round 8 of 50\n", + "1685191942 is trained against myopic-0.51,guess-0.49,\n", + "1685257951 is trained against guess-0.94,low,1685028503-0.06,\n", + "Round 9 of 50\n", + "1685352041 is trained against myopic-0.51,guess-0.49,\n", + "1685452188 is trained against guess-0.94,low,1685028503-0.06,\n", + "Round 10 of 50\n", + "1685508532 is trained against myopic-0.51,guess-0.49,\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [3]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 38\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlow cost player \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlow_cost_player\u001b[38;5;241m.\u001b[39m_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m added\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 40\u001b[0m low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff \u001b[38;5;241m=\u001b[39m bimatrixGame\u001b[38;5;241m.\u001b[39mcompute_equilibria()\n\u001b[1;32m---> 43\u001b[0m acceptable, agentPayoffs, advPayoffs, high_cost_player \u001b[38;5;241m=\u001b[39m \u001b[43mBG\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mgl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhighCost\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlowCost\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43madvMixedStrategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mMixedStrategy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprobablitiesArray\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlow_cost_probabilities\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrategiesList\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlow_cost_players\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtargetPayoff\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhigh_cost_payoff\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 46\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m acceptable:\n\u001b[0;32m 47\u001b[0m update \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\BimatrixGame.py:159\u001b[0m, in \u001b[0;36mtraining\u001b[1;34m(costs, advMixedStrategy, targetPayoff)\u001b[0m\n\u001b[0;32m 155\u001b[0m numberEpisodes \u001b[38;5;241m=\u001b[39m gl\u001b[38;5;241m.\u001b[39mnumEpisodes\u001b[38;5;241m+\u001b[39mgl\u001b[38;5;241m.\u001b[39mepisodeIncreaseAdv \u001b[38;5;241m*\u001b[39m \\\n\u001b[0;32m 156\u001b[0m (support_count(advMixedStrategy\u001b[38;5;241m.\u001b[39m_strategyProbs))\n\u001b[0;32m 157\u001b[0m algorithm \u001b[38;5;241m=\u001b[39m ReinforceAlgorithm(\n\u001b[0;32m 158\u001b[0m game, neuralNet, numberIterations\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, numberEpisodes\u001b[38;5;241m=\u001b[39mnumberEpisodes, discountFactor\u001b[38;5;241m=\u001b[39mgl\u001b[38;5;241m.\u001b[39mgamma)\n\u001b[1;32m--> 159\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolver\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\n\u001b[0;32m 160\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m 161\u001b[0m a \u001b[38;5;241m=\u001b[39m algorithm\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m 162\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mneuralNet\u001b[38;5;241m.\u001b[39mnn_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is trained against \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mstr\u001b[39m(advMixedStrategy)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:118\u001b[0m, in \u001b[0;36mReinforceAlgorithm.solver\u001b[1;34m(self, print_step, options, converge_break)\u001b[0m\n\u001b[0;32m 115\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss\u001b[38;5;241m.\u001b[39mappend([])\n\u001b[0;32m 117\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m--> 118\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage_onwards\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43miter\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnumberEpisodes\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprint_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 119\u001b[0m \u001b[43m \u001b[49m\u001b[43mprob_break_limit_ln\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprobBreakLn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwrite_save\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:149\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage_onwards\u001b[1;34m(self, iter, stage, episodes, print_step, prob_break_limit_ln, options, lr, just_stage, write_save)\u001b[0m\n\u001b[0;32m 147\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m done:\n\u001b[0;32m 148\u001b[0m prevState \u001b[38;5;241m=\u001b[39m state\n\u001b[1;32m--> 149\u001b[0m normPrevState \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalizeState\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprevState\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 150\u001b[0m probs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolicy(normPrevState)\n\u001b[0;32m 151\u001b[0m distAction \u001b[38;5;241m=\u001b[39m Categorical(probs)\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "number_rounds=50\n", + "\n", + "# l1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# l1.load(\"low,1684212411\")\n", + "# l2=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# l2.load(\"low,1684332617\")\n", + "# h1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep)\n", + "# h1.load(\"high,1684261807\")\n", + "equilibria = []\n", + "low_cost_players = [\n", + " Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)\n", + " ]\n", + "high_cost_players = [\n", + " Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)\n", + " ]\n", + "bimatrixGame = BG.BimatrixGame(low_cost_players, high_cost_players)\n", + " # bimatrixGame.reset_matrix()\n", + "bimatrixGame.fill_matrix()\n", + "low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "for round in range(number_rounds):\n", + " print(\"Round\", round, \" of \", number_rounds)\n", + "\n", + " update = False\n", + "\n", + "\n", + " acceptable, agentPayoffs, advPayoffs, low_cost_player = BG.training([gl.lowCost, gl.highCost], advMixedStrategy=MixedStrategy(\n", + " strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), targetPayoff=low_cost_payoff)\n", + " if acceptable:\n", + " update = True\n", + " low_cost_players.append(low_cost_player)\n", + " bimatrixGame.add_low_cost_row(agentPayoffs, advPayoffs)\n", + " equilibria.append(\n", + " [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(f\"low cost player {low_cost_player._name} added\")\n", + "\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "\n", + "\n", + " acceptable, agentPayoffs, advPayoffs, high_cost_player = BG.training(\n", + " [gl.highCost, gl.lowCost], advMixedStrategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), targetPayoff=high_cost_payoff)\n", + "\n", + " if acceptable:\n", + " update = True\n", + " high_cost_players.append(high_cost_player)\n", + " bimatrixGame.add_high_cost_col(advPayoffs, agentPayoffs)\n", + " equilibria.append(\n", + " [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(f\"high cost player {high_cost_player._name} added\")\n", + "\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria()\n", + "\n", + " if update:\n", + " gl.numEpisodes = gl.numEpisodesReset\n", + " else:\n", + " gl.numEpisodes += 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "myopic\n", + "const\n", + "guess\n", + "low,1684386202\n", + "low,1684484716\n", + "low,1684557152\n", + "low,1684856358\n", + "low,1685028503\n" + ] + } + ], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "myopic\n", + "const\n", + "guess\n", + "high,1684424924\n", + "high,1684821735\n" + ] + } + ], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "sum=0\n", + "for i in range(26):\n", + " sum+=3000*(i**1.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1694226.0901287887" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1300000" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum2=0\n", + "for i in range(26):\n", + " sum2+=4000*i\n", + "sum2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/Untitled.ipynb b/learningAgents/naive_policy_gradient/PGM_base/Untitled.ipynb new file mode 100644 index 0000000..5c7ca57 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/Untitled.ipynb @@ -0,0 +1,63 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "46f2921b", + "metadata": {}, + "outputs": [], + "source": [ + "from mp_check import f\n", + "import multiprocessing as mp" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c7d455b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 4, 9]\n" + ] + } + ], + "source": [ + "with mp.Pool(5) as p:\n", + " print(p.map(f, [1, 2, 3]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd57718a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/bimatrix.py b/learningAgents/naive_policy_gradient/PGM_base/bimatrix.py new file mode 100644 index 0000000..1a1f5a6 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/bimatrix.py @@ -0,0 +1,364 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace): + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + equilibrium = None + times_found = 0 + for eq in trset: + if trset[eq] > times_found: + equilibrium = eq +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return str_eq(equilibrium, m,n) + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/naive_policy_gradient/PGM_base/check.py b/learningAgents/naive_policy_gradient/PGM_base/check.py new file mode 100644 index 0000000..01b3509 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/check.py @@ -0,0 +1,82 @@ +import BimatrixGame as BG +import globals as gl +import torch +import numpy as np +from environmentModelBase import Model, MixedStrategy, Strategy, StrategyType +import environmentModelBase as em +from learningBase import ReinforceAlgorithm +from neuralNetworkSimple import NNBase + +# def myopic19(env, player, firstprice=0): +# """ +# Adversary follows Myopic strategy +# """ +# return env.monopolyPrice(player)-19 + +np.random.seed(0) +gl.initialize() + +number_rounds=50 + +l1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep) +l1.load("low,1684386202") +# l2=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep) +# l2.load("low,1684332617") +# h1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep) +# h1.load("high,1684261807") +equilibria = [] +low_cost_players = [ + # Strategy(StrategyType.static, NNorFunc=myopic19, name="myopic19") + # Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), + # Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132), + Strategy(StrategyType.neural_net, NNorFunc=l1, name=l1.nn_name) + # Strategy(StrategyType.neural_net, NNorFunc=l2, name=l2.nn_name) + ] +high_cost_players = [ + Strategy(StrategyType.static, NNorFunc=em.myopic, name="myopic") , + Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), + Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132), + # Strategy(StrategyType.neural_net, NNorFunc=h1, name=h1.nn_name), + ] +bimatrixGame = BG.BimatrixGame(low_cost_players, high_cost_players) + # bimatrixGame.reset_matrix() +bimatrixGame.fill_matrix() +print(bimatrixGame._matrix_A) +print(bimatrixGame._matrix_B) +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() +# for round in range(number_rounds): +# print("Round", round, " of ", number_rounds) + +# update = False + + +# acceptable, agentPayoffs, advPayoffs, low_cost_player = BG.training([gl.lowCost, gl.highCost], advMixedStrategy=MixedStrategy( +# strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), targetPayoff=low_cost_payoff) +# if acceptable: +# update = True +# low_cost_players.append(low_cost_player) +# bimatrixGame.add_low_cost_row(agentPayoffs, advPayoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"low cost player {low_cost_player._name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + +# acceptable, agentPayoffs, advPayoffs, high_cost_player = BG.training( +# [gl.highCost, gl.lowCost], advMixedStrategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), targetPayoff=high_cost_payoff) + +# if acceptable: +# update = True +# high_cost_players.append(high_cost_player) +# bimatrixGame.add_high_cost_col(advPayoffs, agentPayoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"high cost player {high_cost_player._name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + # if update: + # gl.numEpisodes = gl.numEpisodesReset + # else: + # gl.numEpisodes += 1000 \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/PGM_base/columnprint.py b/learningAgents/naive_policy_gradient/PGM_base/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/naive_policy_gradient/PGM_base/environmentModelBase.py b/learningAgents/naive_policy_gradient/PGM_base/environmentModelBase.py new file mode 100644 index 0000000..0b5b776 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/environmentModelBase.py @@ -0,0 +1,462 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopicPrices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + self.our_target_demand = ( + (self.totalDemand + self.costs[1]-self.costs[0])/2) # target demand + self.target_price = (self.our_target_demand+self.costs[0])/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + self.myopicPrices[player][self.stage]=myopic(self,player) + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player) + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, advMixedStrategy,stateAdvHistory=0) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + """ adversary is a MixedStrategy""" + self.rewardFunction = self.profits + + self.episodesMemory = list() + self.done = False + + # number of previous adversary's action we consider in the state + self.stateAdvHistory = stateAdvHistory + self.advMixedStrategy = advMixedStrategy + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return self.getState(0), reward, self.done + + def resetAdversary(self): + self.adversaryStrategy = self.advMixedStrategy.set_adversary_strategy() + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + return self.adversaryStrategy.play(environment=self, player=1) + + # if self.adversaryStrategy == AdversaryModes.constant_132: + # return self.const(player=1, price=132) + # elif self.adversaryStrategy == AdversaryModes.constant_95: + # return self.const(player=1, price=95) + # elif self.adversaryStrategy == AdversaryModes.imitation_128: + # return self.imit(player=1, firstprice=128) + # elif self.adversaryStrategy == AdversaryModes.imitation_132: + # return self.imit(player=1, firstprice=132) + # elif self.adversaryStrategy == AdversaryModes.fight_100: + # return self.fight(player=1, firstprice=100) + # elif self.adversaryStrategy == AdversaryModes.fight_125: + # return self.fight(player=1, firstprice=125) + # elif self.adversaryStrategy == AdversaryModes.fight_lb_125: + # return self.fight_lb(player=1, firstprice=125) + # elif self.adversaryStrategy == AdversaryModes.fight_132: + # return self.fight(player=1, firstprice=132) + # elif self.adversaryStrategy == AdversaryModes.fight_lb_132: + # return self.fight_lb(player=1, firstprice=132) + # elif self.adversaryStrategy == AdversaryModes.guess_125: + # return self.fight(player=1, firstprice=125) + # elif self.adversaryStrategy == AdversaryModes.guess_132: + # return self.fight(player=1, firstprice=132) + # else: + # return self.myopic(player=1) + + def step(self, price, mode=1): + """ + Transition Function. + Parameters: + - action: Price + - state: list in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + + adversaryPrice = self.adversaryChoosePrice() + p = self.myopic() + # myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [price, adversaryPrice]) + + done = (self.stage == self.T-1) + + reward = self.rewardFunction() + self.stage += 1 + + return self.getState(self.stage), reward, done + + def getState(self, stage, player=0, advHist=None): + # [one-hote encoding of stage, our demand, our price, adversary's price history] + + stageEncode = [0]*self.T + if stage < self.T: + stageEncode[stage] = 1 + + hist = advHist if (advHist is not None) else self.stateAdvHistory + if stage == 0: + state = stageEncode + \ + [self.totalDemand/2, + ((self.totalDemand/2) + self.costs[player])/2] + ([0]*hist) + + else: + # check last stageeee demand + state = stageEncode+[self.demandPotential[player] + [stage], self.prices[player][stage-1]] + if (hist > 0): + advHistory = [0]*hist + j = hist-1 + for i in range(stage-1, max(-1, stage-1-hist), -1): + advHistory[j] = self.prices[1-player][i] + j -= 1 + state += advHistory + # elif(player==1 and self.advNN.adv_hist>0): + # advHistory = [0]*self.advNN.adv_hist + # j = self.advNN.adv_hist-1 + # for i in range(stage-1, max(-1, stage-1-self.advNN.adv_hist), -1): + # advHistory[j] = self.prices[1-player][i] + # j -= 1 + # state+=advHistory + + return torch.tensor(state, dtype=torch.float32) + + def normalizeState(self, state, mode=1): + # [stage one-hot encoded, agent's demand potential, agent's last price, history of adversary's prices] + + if mode == 1: + normalized = [0]*len(state) + for i in range(self.T): + normalized[i] = state[i] + for i in range(self.T, len(state)): + normalized[i] = state[i]/(self.totalDemand) + return torch.tensor(normalized) + elif mode == 2: + + normalized = torch.zeros(len(state)) + for i in range(self.T): + normalized[i] = state[i] + + normalized[self.T] = -self.our_target_demand + \ + state[self.T] # demand + + for i in range(self.T+1, len(state)): + normalized[i] = -(self.target_price) + \ + state[i] # both players' prices + return normalized + elif mode == 3: + return nn.functional.normalize(state, p=2.0, dim=0) + elif mode == 4: + normalized = [0]*len(state) + for i in range(self.T): + normalized[i] = state[i] + for i in range(self.T, len(state)): + normalized[i] = (state[i]-self.costs[0]) / \ + (self.totalDemand) + return torch.tensor(normalized) + + def compute_price(self,action,actionStep,player=0): + return self.myopic(player=player) - (actionStep* action) + +# class AdversaryModes(Enum): +# myopic = 0 +# constant_132 = 1 +# constant_95 = 2 +# imitation_132 = 3 +# imitation_128 = 4 +# fight_132 = 5 +# fight_lb_132 = 6 +# fight_125 = 7 +# fight_lb_125 = 8 +# fight_100 = 9 +# guess_132 = 10 +# guess_125 = 11 + +class StrategyType(Enum): + static = 0 + neural_net = 1 + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + _type = None + _env = None + _name = None + _nn = None + _nnHist = None + _policy = None + + def __init__(self, strategyType, NNorFunc, name, firstPrice=132) -> None: + """ + Based on the type of strategy, the neuralnet or the Strategy Function should be given as input. FirstPrice just applies to static strategies + """ + self._type = strategyType + self._name = name + # self._env = environment + + if strategyType == StrategyType.neural_net: + self._nn = NNorFunc + self._policy = NNorFunc.policy + self._nnHist = NNorFunc.adv_hist + else: + self._policy = NNorFunc + self._firstPrice = firstPrice + + def reset(self): + pass + + def play(self, environment, player=0): + """ + Computes the action to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + self._env = environment + if self._type == StrategyType.neural_net: + state = self._env.getState( + self._env.stage, player, advHist=self._nnHist) + normState = self._env.normalizeState(state=state) + probs = self._policy(normState) + distAction = Categorical(probs) + action = distAction.sample() + return self._env.compute_price(action=action.item(),actionStep=self._nn.action_step, player=player) + + else: + return self._policy(self._env, player, self._firstPrice) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self._env=env + + state, reward, done = env.reset() + while env.stage<(env.T): + prices=[0,0] + prices[0],prices[1]=self.play(env,0),adversary.play(env,1) + env.updatePricesProfitDemand(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix=MixedStrategy(probablitiesArray=torch.ones(1),strategiesList=[self]) + + return mix + + + + + + +class MixedStrategy(): + _strategies = [] + _strategyProbs = None + + def __init__(self,strategiesList=[], probablitiesArray=None) -> None: + self._strategies=strategiesList + self._strategyProbs=probablitiesArray + + def set_adversary_strategy(self): + if len(self._strategies) > 0: + adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + strategyInd = (adversaryDist.sample()).item() + return self._strategies[strategyInd] + else: + print("adversary's strategy can not be set!") + return None + + def __str__(self) -> str: + s = "" + for i in range(len(self._strategies)): + if self._strategyProbs[i]>0: + s += f"{self._strategies[i]._name}-{self._strategyProbs[i]:.2f}," + return s + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.monopolyPrice(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.monopolyPrice(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.monopolyPrice(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.monopolyPrice(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.totalDemand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demandPotential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.totalDemand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.totalDemand/2 + env.costs[1]-env.costs[0]), + (env.totalDemand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.totalDemand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.monopolyPrice(player) + + D = env.demandPotential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.monopolyPrice(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demandPotential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P diff --git a/learningAgents/naive_policy_gradient/PGM_base/game - Copy.txt b/learningAgents/naive_policy_gradient/PGM_base/game - Copy.txt new file mode 100644 index 0000000..7e68096 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/game - Copy.txt @@ -0,0 +1,14 @@ +5 4 + + 139591 138555 138555 59540 + 138527 127512 127512 -37806 + 154998 168709 141639 52175 + 174699 298901 81143 58366 + 177912 299234 84392 61804 + + 93895 94732 94732 114164 + 94760 103712 103712 226200 + 79666 68729 79091 13211 + 31932 -48081 25663 15919 + 31932 -48081 25663 16069 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/game.txt b/learningAgents/naive_policy_gradient/PGM_base/game.txt new file mode 100644 index 0000000..8b64c87 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/game.txt @@ -0,0 +1,20 @@ +8 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + 179200 271077 108604 125874 123156 + 179353 261888 116425 126715 124336 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + 41349 -19699 47435 52067 53243 + 44815 -11059 53380 56485 56184 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game1x1.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game1x1.txt new file mode 100644 index 0000000..d33efdc --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game1x1.txt @@ -0,0 +1,6 @@ +1 1 + + 165313 + + 69210 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game1x2.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game1x2.txt new file mode 100644 index 0000000..78040dc --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game1x2.txt @@ -0,0 +1,6 @@ +1 2 + + 165313 122093 + + 69210 86662 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game2x2.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game2x2.txt new file mode 100644 index 0000000..e8d758c --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game2x2.txt @@ -0,0 +1,8 @@ +2 2 + + 165313 122093 + 171949 126585 + + 69210 86662 + 60022 75330 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game3x2.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game3x2.txt new file mode 100644 index 0000000..4a94967 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game3x2.txt @@ -0,0 +1,10 @@ +3 2 + + 165313 122093 + 171949 126585 + 177243 128663 + + 69210 86662 + 60022 75330 + 47580 59672 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game3x3 - Copy.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game3x3 - Copy.txt new file mode 100644 index 0000000..f7c19c4 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game3x3 - Copy.txt @@ -0,0 +1,10 @@ +3 3 + + 139591 138555 138555 + 138527 127512 127512 + 154998 168709 141639 + + 93895 94732 94732 + 94760 103712 103712 + 79666 68729 79091 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game3x3.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game3x3.txt new file mode 100644 index 0000000..f7c19c4 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game3x3.txt @@ -0,0 +1,10 @@ +3 3 + + 139591 138555 138555 + 138527 127512 127512 + 154998 168709 141639 + + 93895 94732 94732 + 94760 103712 103712 + 79666 68729 79091 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game3x4.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game3x4.txt new file mode 100644 index 0000000..5a2db63 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game3x4.txt @@ -0,0 +1,10 @@ +3 4 + + 139591 138555 138555 136168 + 138527 127512 127512 132230 + 154998 168709 141639 152571 + + 93895 94732 94732 96628 + 94760 103712 103712 99886 + 79666 68729 79091 80866 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game4x3.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game4x3.txt new file mode 100644 index 0000000..a07d5b9 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game4x3.txt @@ -0,0 +1,12 @@ +4 3 + + 139591 138555 138555 + 138527 127512 127512 + 154998 168709 141639 + 178433 294260 91786 + + 93895 94732 94732 + 94760 103712 103712 + 79666 68729 79091 + 35257 -40901 32920 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game4x4.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game4x4.txt new file mode 100644 index 0000000..8b387d3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game4x4.txt @@ -0,0 +1,12 @@ +4 4 + + 139591 138555 138555 98440 + 138527 127512 127512 56140 + 154998 168709 141639 124168 + 178433 294260 91786 122729 + + 93895 94732 94732 117874 + 94760 103712 103712 159265 + 79666 68729 79091 70510 + 35257 -40901 32920 44166 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy (2).txt b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy (2).txt new file mode 100644 index 0000000..7e68096 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy (2).txt @@ -0,0 +1,14 @@ +5 4 + + 139591 138555 138555 59540 + 138527 127512 127512 -37806 + 154998 168709 141639 52175 + 174699 298901 81143 58366 + 177912 299234 84392 61804 + + 93895 94732 94732 114164 + 94760 103712 103712 226200 + 79666 68729 79091 13211 + 31932 -48081 25663 15919 + 31932 -48081 25663 16069 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy.txt new file mode 100644 index 0000000..e5c8e24 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4 - Copy.txt @@ -0,0 +1,14 @@ +5 4 + + 139591 138555 138555 108883 + 138527 127512 127512 79058 + 154998 168709 141639 133664 + 165308 196081 146171 130566 + 165670 196482 146514 130934 + + 93895 94732 94732 113907 + 94760 103712 103712 141912 + 79666 68729 79091 77293 + 69215 46444 79019 85237 + 69210 46407 79020 85193 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game5x4.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4.txt new file mode 100644 index 0000000..156d30f --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game5x4.txt @@ -0,0 +1,14 @@ +5 4 + + 139591 138555 138555 98440 + 138527 127512 127512 56140 + 154998 168709 141639 124168 + 178433 294260 91786 122729 + 179169 272487 104497 125383 + + 93895 94732 94732 117874 + 94760 103712 103712 159265 + 79666 68729 79091 70510 + 35257 -40901 32920 44166 + 40500 -21026 44007 51182 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game6x4.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game6x4.txt new file mode 100644 index 0000000..7540f88 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game6x4.txt @@ -0,0 +1,16 @@ +6 4 + + 139591 138555 138555 98440 + 138527 127512 127512 56140 + 154998 168709 141639 124168 + 178433 294260 91786 122729 + 179169 272487 104497 125383 + 179003 271526 107660 124716 + + 93895 94732 94732 117874 + 94760 103712 103712 159265 + 79666 68729 79091 70510 + 35257 -40901 32920 44166 + 40500 -21026 44007 51182 + 40916 -20436 46605 52011 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game6x5.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game6x5.txt new file mode 100644 index 0000000..530320e --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game6x5.txt @@ -0,0 +1,16 @@ +6 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game7x5 - Copy.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game7x5 - Copy.txt new file mode 100644 index 0000000..6638a56 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game7x5 - Copy.txt @@ -0,0 +1,18 @@ +7 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + 179200 271077 108604 125874 123156 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + 41349 -19699 47435 52067 53243 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game7x5.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game7x5.txt new file mode 100644 index 0000000..6638a56 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game7x5.txt @@ -0,0 +1,18 @@ +7 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + 179200 271077 108604 125874 123156 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + 41349 -19699 47435 52067 53243 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/games/game8x5.txt b/learningAgents/naive_policy_gradient/PGM_base/games/game8x5.txt new file mode 100644 index 0000000..8b64c87 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/games/game8x5.txt @@ -0,0 +1,20 @@ +8 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + 179200 271077 108604 125874 123156 + 179353 261888 116425 126715 124336 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + 41349 -19699 47435 52067 53243 + 44815 -11059 53380 56485 56184 + diff --git a/learningAgents/naive_policy_gradient/PGM_base/globals.py b/learningAgents/naive_policy_gradient/PGM_base/globals.py new file mode 100644 index 0000000..56f43c3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/globals.py @@ -0,0 +1,18 @@ +def initialize(): + global totalDemand,lowCost,highCost,totalStages,adversaryHistroy,lr,gamma,numActions,actionStep,numStochasticIter,numEpisodes,numEpisodesReset, episodeIncreaseAdv + totalDemand = 400 + lowCost = 57 + highCost = 71 + totalStages = 25 + adversaryHistroy = 3 + lr = 0.000005 + gamma = 1 + numActions = 20 + actionStep = 3 + numStochasticIter = 10 + + # episodes for learning the last stage, then for 2nd to last stage 2*numEpisodes. In total:300*numEpisodes + numEpisodes = 2000 + numEpisodesReset = numEpisodes + # increase in num of episodes for each adv in support + episodeIncreaseAdv = 1000 \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/PGM_base/learningBase.py b/learningAgents/naive_policy_gradient/PGM_base/learningBase.py new file mode 100644 index 0000000..2e3dc20 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/learningBase.py @@ -0,0 +1,328 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModelBase as model +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +from openpyxl import load_workbook +import time +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + self.probBreakLn = -0.001 + + + + def write_to_excel(self, new_row): + """ + row includes: # ep adversary return advReturn loss actor critic lr gamma hist clc actions probs nn_name total_stages action_step num_actions return_against_adversaries + """ + + path = 'results.xlsx' + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + # print(new_row) + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + + self.returns = [] + self.loss = [] + + # self.returns = np.zeros((numberIterations, numberEpisodes)) + # self.loss = np.zeros((numberIterations, numberEpisodes)) + + self.dataRow=[] + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + def loadPolicyNet(self, name): + """ + Load Policy Neural Network. + """ + self.resetPolicyNet() + self.neuralNetwork.load(name) + + + # def saveResult(self): + # pass + + def returnsComputation(self, rewards, episodeMemory=None): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + output:tensor + + """ + + discRewards = torch.zeros(len(rewards)) + discRewards[-1] = rewards[-1] + for i in range(len(rewards)-2, -1, -1): + discRewards[i] = rewards[i] + self.gamma*discRewards[i+1] + return discRewards + + # return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + + + def solver(self, print_step=50_000, options=[1, 10000, 1, 1], converge_break=False): + """ + print_step=None means no printing + """ + self.returns = [] + self.loss = [] + + # fig, axs = plt.subplots(max(self.numberIterations,2), 2, figsize=(15, 6*self.numberIterations)) + + for iter in range(self.numberIterations): + + self.resetPolicyNet() + self.returns.append([]) + self.loss.append([]) + + for stage in range(self.env.T-1, -1, -1): + self.learn_stage_onwards(iter,stage=stage, episodes=int(self.numberEpisodes*(self.env.T-stage)), print_step=print_step, options=options, + prob_break_limit_ln=(self.probBreakLn if converge_break else None), write_save=True if stage==0 else False) + + # axs[iter][0].scatter(range(len(self.returns[iter])), self.returns[iter]) + # axs[iter][1].scatter(range(len(self.loss[iter])), self.loss[iter]) + + # plt.show() + + + + + def learn_stage_onwards(self,iter,stage, episodes, print_step=10_000, prob_break_limit_ln=None, options=[1, 10000, 1, 2], lr=None, just_stage=False, write_save=False): + """ + Method that just learns the actions of stages after the input stage. + + """ + if self.policy == None: + self.resetPolicyNet() + + if lr is not None: + self.optim.lr = lr + + + for episode in range(episodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst = [] + while not done: + prevState = state + normPrevState = self.env.normalizeState(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*60) + # print("probs= ", probs) + + state, reward, done = self.env.step( + self.env.compute_price(action=action.item(),actionStep=self.neuralNetwork.action_step)) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + if episode == 0: + probs_lst_pre = probs_lst + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] + for item in episodeMemory])/options[1] + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + + + actionsLogProbs = action_logprobs[stage:] + discRewards = self.returnsComputation(rewards=rewards) + baseRewards = self.computeBase( + self.env.prices[1], initDemand=self.env.demandPotential[0][stage], startStage=stage)/options[1] + baseDiscReturns = discRewards-baseRewards + finalReturns = baseDiscReturns[stage:] + + if just_stage: + loss = -baseDiscReturns[stage]*action_logprobs[stage] + else: + loss = -(torch.sum(finalReturns*actionsLogProbs)) + + + shouldBreak = False + + if prob_break_limit_ln is not None and torch.all(action_logprobs[stage:] > prob_break_limit_ln): + shouldBreak = True + + if (print_step is not None) and ((episode % print_step == (print_step-1)) or shouldBreak): + print("-"*20) + + + print("iter ",iter," stage ",stage," ep ",episode, " adversary: ", self.env.adversary) + print(" actions: ", actions* self.actionStep) + + print("loss= ", loss,"return= ", returns) + # print("states= ", states) + print("probs of actions: ", torch.exp( + action_logprobs)) + # print("action_logprobs: ", action_logprobs) + # print("probs=", probs_lst) + # print("discounted returns: ", baseDiscReturns) + # print("rewards: ", rewards) + # print("finalReturns: ", finalReturns) + + # print("nn 1st layer",self.policy[0].weight) + # print("nn 2nd layer",self.policy[2].weight) + # print("shouldBreak:", shouldBreak.item()) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + + probs_lst_pre = probs_lst + + self.policy.zero_grad() + loss.backward() + self.optim.step() + + # if episode != 0: + # self.meanStageValue = ( + # (self.meanStageValue*episode)+rewards)/(episode+1) + + # sum of the our player's rewards rounds 0-25 + # self.returns[iteration][episode] = returns + # self.loss[iteration][episode] = loss + self.returns[iter].append(returns) + self.loss[iter].append(loss.item()) + + # all probs >0.999 means coverged? break + if shouldBreak: + # self.returns[iteration] = self.returns[iteration][0:episode] + # self.loss[iteration] = self.loss[iteration][0:episode] + break + + + name = f"{int(time.time())}" + # ep adversary return advReturn loss lr gamma hist actions probs nn_name total_stages action_step num_actions return_against_adversaries + self.dataRow= [len(self.returns[iter]), str(self.env.advMixedStrategy), returns, sum(self.env.profit[1]), loss.item(), self.neuralNetwork.lr, self.gamma, self.env.stateAdvHistory, str(actions*self.neuralNetwork.action_step), str((torch.exp(action_logprobs)).detach().numpy()), name, self.env.T, self.neuralNetwork.action_step, self.neuralNetwork.num_actions] + + self.neuralNetwork.nn_name=name + # for advmode in model.AdversaryModes: + # new_row.append(np.array((self.playTrainedAgent(advmode,10))[0]).mean()) + + + + def write_nn_data(self,prefix=""): + """ + writes the data in excel and saves nn + """ + + + # self.name = f"{[self.neuralNetwork.lr, self.gamma,clc]}-stage {stage}-{int(time.time())}" + self.neuralNetwork.save(f"{prefix},{self.neuralNetwork.nn_name}") + print(self.neuralNetwork.nn_name, "saved") + # ep adversary return advReturn loss lr gamma hist actions probs nn_name total_stages action_step num_actions return_against_adversaries + + self.write_to_excel(self.dataRow) + + + + def computeBase(self, advPrices, startStage=0, initDemand=None): + """ + discounted rewards when we play myopic against the adversary + + """ + if initDemand is None: + initDemand = (self.env.getState(stage=0))[self.env.T] + profit = torch.zeros(self.env.T) + demand = initDemand + for i in range(startStage, self.env.T): + price = (demand + self.env.costs[0])/2 + + profit[i] = (demand-price)*(price-self.env.costs[0]) + demand += (advPrices[i]-price)/2 + return self.returnsComputation(rewards=profit) + + # def myopic_price(demand,cost): + # return (demand + cost)/2 + + def playTrainedAgent(self, adversary, iterNum): + """ + Current trained NN will plays against the adversary's strategy, without learning. + """ + + game = model.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advMixedStrategy=adversary ,stateAdvHistory=self.neuralNetwork.adv_hist) + returns = torch.zeros(2,iterNum) + for episode in range(iterNum): + + # episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.env.normalizeState(prevState) + probs= self.policy(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + game.compute_price(action=action.item(),actionStep=self.neuralNetwork.action_step)) + retu = retu + reward + # episodeMemory.append((normPrevState, action, reward)) + + # states = torch.stack([item[0] for item in episodeMemory]) + # actions = torch.tensor([item[1] for item in episodeMemory]) + # rewards = torch.tensor([item[2] for item in episodeMemory]) + + # print(f"iteration {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[0][episode], returns[1][episode] = sum(game.profit[0]), sum(game.profit[1]) + + return returns + + # plt.plot(returns) + # plt.show() diff --git a/learningAgents/naive_policy_gradient/PGM_base/lemke.py b/learningAgents/naive_policy_gradient/PGM_base/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0] None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + self.nn_dim = nn_dim + self.adv_hist = adv_hist + self.action_step= action_step + + self.nn_name = f"nn, lr={self.lr}, actions={self.num_actions}" + + def reset(self): + + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_dim), + nn.ReLU(), + # nn.Linear(self.nn_dim, self.nn_dim), + # nn.ReLU(), + nn.Linear(self.nn_dim, self.num_actions), + nn.Softmax(dim=0)) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + # print(self.policy[0].weight) + # print(self.policy[2].weight) + # print("policy reset") + return self.policy, self.optim + + def save(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + # print("policy saved!") + return torch.save(self.policy.state_dict(), self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + if self.policy is None: + self.reset() + self.nn_name = (self.nn_name if name is None else name) + self.policy.load_state_dict( + torch.load(self.save_path_format.format(name=self.nn_name))) + # print("policy loaded!") + + +# class PlicyGradient(): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# return + + +# class ActorCritic(nn.Module): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# super(ActorCritic, self).__init__() +# self.l1 = nn.Linear(num_input,nn_dim) +# self.l2 = nn.Linear(nn_dim,nn_dim) +# self.actor_lin1 = nn.Linear(nn_dim,num_actions) +# self.l3 = nn.Linear(nn_dim,nn_dim) +# self.critic_lin1 = nn.Linear(nn_dim,1) +# def forward(self,x): +# # print("nn state",x) +# #x = F.normalize(x,dim=0) +# y = F.relu(self.l1(x)) +# y = F.relu(self.l2(y)) +# actor = F.softmax(self.actor_lin1(y),dim=0) #C +# c = F.elu(self.l3(y.detach())) +# critic = F.elu(self.critic_lin1(c)) #D +# return actor, critic #E + +# class NeuralNetwork(NNBase): +# def __init__(self,lr=.00001, num_input=3, num_actions=50, nn_dim=100): +# super().__init__(lr=lr, num_input=num_input, num_actions=num_actions, nn_dim=nn_dim) + +# def reset(self): +# self.policy = ActorCritic(num_input=self.num_input, num_actions=self.num_actions, nn_dim=self.nn_dim) + +# self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + +# return self.policy, self.optim + + # def optimizer(self,parameter): + \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/PGM_base/pdfs/const95.pdf b/learningAgents/naive_policy_gradient/PGM_base/pdfs/const95.pdf new file mode 100644 index 0000000..8cb3af1 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/pdfs/const95.pdf differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/pdfs/lr 10^-5 advs.pdf b/learningAgents/naive_policy_gradient/PGM_base/pdfs/lr 10^-5 advs.pdf new file mode 100644 index 0000000..bcd157a Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/pdfs/lr 10^-5 advs.pdf differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/play.py b/learningAgents/naive_policy_gradient/PGM_base/play.py new file mode 100644 index 0000000..7de9668 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/play.py @@ -0,0 +1,40 @@ +import BimatrixGame +import globals +from environmentModelBase import Model, Strategy, StrategyType,MixedStrategy +from neuralNetworkSimple import NNBase +import environmentModelBase as em +import numpy as np + +np.random.seed(0) + +# const132=Strategy(StrategyType.static,name="const132",staticIndex=1) +# const95=Strategy(StrategyType.static,"const95",staticIndex=2) + +# mainGame._strategies.append(const132) +# mainGame._strategies.append(const95) +# mainGame._strategies.append(myopic) +# mainGame.fill_matrix() +# mainGame.write_all_matrix() + +# nnMyopic=NNBase(num_input=27, num_actions=50, adv_hist=0) +# nnMyopic.reset() +# nnMyopic.load("0,[1e-05,1][1, 10000, 1, 1],1682423487") +# nn1st=Strategy(StrategyType.neural_net,nnMyopic,"nnMyopic" ) +# mainGame._strategies.append(nn1st) + + +# nnConst=NNBase(num_input=27, num_actions=50, adv_hist=0) +# nnConst.reset() +# nnConst.load("0,[1e-05,1][1, 10000, 1, 1],1682506150") +# mainGame._strategies.append(Strategy(StrategyType.neural_net,nnConst,"nnConst132" )) + +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.const,name="staticConst132",firstPrice=132)) +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.myopic,name="staticMyopic")) + + +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.guess,name="staticGuess132",firstPrice=132)) +# mainGame.fill_matrix() + +# mainGame.write_all_matrix() +globals.initialize() +equilibria, bimatrixGame=BimatrixGame.run_tournament(50) \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/.ipynb_checkpoints/learn_stage-lr 10^-5-checkpoint.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/.ipynb_checkpoints/learn_stage-lr 10^-5-checkpoint.ipynb new file mode 100644 index 0000000..21348a2 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/.ipynb_checkpoints/learn_stage-lr 10^-5-checkpoint.ipynb @@ -0,0 +1,1070 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# from learningBase import ReinforceAlgorithm\n", + "# from environmentModelBase import Model, AdversaryModes\n", + "# from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 0, 1, 0, 14, 7, 0, 37, 2, 1, 0, 1, 0, 2, 2, 8, 2, 9,\n", + " 0, 0, 0, 0, 1, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651,\n", + " 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651,\n", + " 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651]) return= 144580.61713032398\n", + "probs of actions: tensor([0.2677, 0.4146, 0.2616, 0.4348, 0.0020, 0.0073, 0.4527, 0.0008, 0.1499,\n", + " 0.2899, 0.4434, 0.2722, 0.4143, 0.1398, 0.1448, 0.0067, 0.1560, 0.0057,\n", + " 0.4129, 0.4321, 0.4380, 0.4079, 0.2701, 0.4400, 0.5927],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5402, 0.5512, 0.5606, 0.5420, 0.6108, 0.6160, 0.4520, 0.7242,\n", + " 0.6489, 0.6089, 0.5854, 0.5777, 0.5697, 0.5734, 0.5693, 0.5993, 0.5805,\n", + " 0.6101, 0.5861, 0.5742, 0.5683, 0.5653, 0.5677, 0.5651])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626,\n", + " 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626,\n", + " 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626]) return= 139887.0028572126\n", + "probs of actions: tensor([0.9056, 0.8891, 0.9016, 0.9011, 0.8871, 0.9035, 0.9155, 0.8796, 0.8922,\n", + " 0.0511, 0.9077, 0.9154, 0.0488, 0.9052, 0.9122, 0.0468, 0.8849, 0.0445,\n", + " 0.8796, 0.9043, 0.8997, 0.8847, 0.9058, 0.9048, 0.9894],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5623, 0.5662, 0.5644, 0.5633, 0.5667, 0.5646, 0.5635, 0.5668, 0.5645,\n", + " 0.5673, 0.5649, 0.5637, 0.5631, 0.5628, 0.5627, 0.5626])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([19, 0, 0, 16, 4, 33, 0, 19, 2, 12, 9, 9, 38, 6, 29, 9, 5, 12,\n", + " 21, 0, 0, 3, 2, 19, 0])\n", + "loss= tensor(0.1083, grad_fn=) , base rewards= tensor([1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562,\n", + " 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562,\n", + " 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 0.5729]) return= 153868.923096965\n", + "probs of actions: tensor([6.7453e-03, 2.4359e-01, 2.6405e-01, 4.5853e-02, 3.9187e-02, 1.2979e-03,\n", + " 3.2029e-01, 9.7528e-03, 6.1041e-02, 5.3805e-02, 4.1503e-02, 4.2067e-02,\n", + " 3.5512e-04, 3.3125e-02, 6.7532e-03, 4.8530e-02, 4.1285e-02, 5.2882e-02,\n", + " 1.2649e-02, 2.6483e-01, 1.9902e-01, 3.4315e-02, 6.3572e-02, 6.5753e-02,\n", + " 9.3820e-01], grad_fn=)\n", + "rewards: tensor([0.4751, 0.6084, 0.5852, 0.5482, 0.6284, 0.5024, 0.7198, 0.6027, 0.6755,\n", + " 0.6114, 0.6327, 0.6283, 0.4898, 0.7502, 0.5950, 0.7307, 0.6819, 0.6274,\n", + " 0.6048, 0.6894, 0.6243, 0.5921, 0.5887, 0.5472, 0.6470])\n", + "finalReturns: tensor([0.0381, 0.0742])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 1, 0, 1, 2, 13, 0, 0, 0, 0, 0, 2, 5, 8, 0, 12, 2, 0,\n", + " 12, 9, 9, 3, 13, 13, 0])\n", + "loss= tensor(0.1193, grad_fn=) , base rewards= tensor([1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333,\n", + " 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333,\n", + " 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 0.5982]) return= 145716.00627726328\n", + "probs of actions: tensor([0.4924, 0.1025, 0.4052, 0.0878, 0.0785, 0.0348, 0.4575, 0.3375, 0.4167,\n", + " 0.3210, 0.4148, 0.0771, 0.0259, 0.0369, 0.4270, 0.0963, 0.0827, 0.4002,\n", + " 0.0799, 0.0318, 0.0487, 0.0243, 0.0317, 0.0330, 0.9646],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5365, 0.5532, 0.5577, 0.5635, 0.5538, 0.6166, 0.5892, 0.5758,\n", + " 0.5691, 0.5658, 0.5638, 0.5684, 0.5792, 0.6047, 0.5690, 0.6188, 0.5982,\n", + " 0.5658, 0.6095, 0.6167, 0.6275, 0.5897, 0.6182, 0.6496])\n", + "finalReturns: tensor([0.0344, 0.0513])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 9, 0, 13, 12, 16, 21, 8, 9, 13, 8, 19, 24, 20, 13, 20, 8, 10,\n", + " 12, 8, 2, 8, 16, 19, 0])\n", + "loss= tensor(0.6110, grad_fn=) , base rewards= tensor([1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655,\n", + " 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655,\n", + " 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.1495, 0.5606]) return= 157299.7684477885\n", + "probs of actions: tensor([0.1744, 0.0296, 0.0580, 0.1062, 0.2211, 0.0429, 0.0415, 0.0336, 0.0397,\n", + " 0.1072, 0.0398, 0.0347, 0.0191, 0.0228, 0.1049, 0.0267, 0.0370, 0.0374,\n", + " 0.1450, 0.0329, 0.0180, 0.0358, 0.0987, 0.1237, 0.8915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5733, 0.6065, 0.5674, 0.6092, 0.6141, 0.6200, 0.6908, 0.6520,\n", + " 0.6291, 0.6487, 0.6034, 0.6186, 0.6760, 0.7023, 0.6515, 0.7005, 0.6549,\n", + " 0.6380, 0.6478, 0.6387, 0.6016, 0.5904, 0.6158, 0.6826])\n", + "finalReturns: tensor([0.1234, 0.1490, 0.1221])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 19, 13, 0, 8, 12, 21, 12, 27, 16, 15, 30, 19, 19, 31, 0, 11,\n", + " 18, 1, 0, 8, 21, 16, 0])\n", + "loss= tensor(0.6755, grad_fn=) , base rewards= tensor([1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476,\n", + " 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476,\n", + " 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.1393, 0.5541]) return= 157154.5783200927\n", + "probs of actions: tensor([0.1052, 0.0519, 0.0165, 0.1318, 0.0639, 0.0443, 0.1467, 0.1016, 0.1574,\n", + " 0.0110, 0.0250, 0.0116, 0.0035, 0.0361, 0.0422, 0.0094, 0.0466, 0.0638,\n", + " 0.0599, 0.0416, 0.0299, 0.0410, 0.2827, 0.0667, 0.9334],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5134, 0.6121, 0.6465, 0.5974, 0.5995, 0.5907, 0.6677,\n", + " 0.5961, 0.6994, 0.6843, 0.6037, 0.7146, 0.6962, 0.6270, 0.7703, 0.6502,\n", + " 0.6228, 0.6800, 0.6239, 0.5864, 0.5642, 0.6427, 0.6785])\n", + "finalReturns: tensor([0.1378, 0.1819, 0.1245])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAppUlEQVR4nO3df5BV5Z3n8feXpiWNM9qNkhltJI2/sGJ06NBRZtmk/LFDO3ESe4wzkkpKdscaNm5mdjQOUzCxAlFnxTApUm5qTJmRUqNj8AfTITEuYRczTrmCNmkQyciKSrAbJpBAO07oQNP93T/Oc+H05f7u+/t+XlW3uP3cc849h3vv+Z7n+T7Pc8zdERERydWkSu+AiIjUFgUOERHJiwKHiIjkRYFDRETyosAhIiJ5mVzpHSi2s88+2zs6Oiq9GyIiNWXr1q2/cPfpuSxbd4Gjo6ODvr6+Su+GiEhNMbOf5bqsmqpERCQvChwiIpIXBQ4REcmLAoeIiORFgUNERPJSd72qCtXbP8iqDbvYNzTMua0tLOmeTU9ne6V3S0Sk6ihwEAWNZet2MDwyCsDg0DDL1u0AUPAQEUmipipg1YZdJ4JGwvDIKKs27KrQHomIVC8FDmDf0HDK8sE05SIijUyBAzi3tSVluRE1Y4mIyEkKHEDHWakDh4Oaq0REkihwAJvfPpz2NTVXiYiMp8ABjGa477qaq0RExlPgyELNVSIi4ylw5CBdrysRkUakwJGDdL2uREQakQIH8Fu/eVrG16++JKebYomINAQFDuDA+8cyvv6D7fvLtCciItVPgYMoAZ7J0PBIWfZDRKQWKHDkSF1yRUQiChw5UpdcEZFI1sBhZmvM7ICZvR4rW2tm28Jjj5lti722zMx2m9kuM+uOlc81sx3htQfMzEL5lLC93Wa2xcw6YussMrM3w2NRsQ66EOqSKyISyaXG8QhwXbzA3W929znuPgd4FlgHYGYfBhYCl4Z1/s7MmsJqDwKLgYvCI7HNW4HD7n4hsBq4P2xrGrAcuBK4AlhuZm0FHWURtE5trtRbi4hUlayBw91fBA6lei3UGv4YeDIU3QB8192Puvs7wG7gCjM7BzjD3V92dwceA3pi6zwanj8DXBu22w1sdPdD7n4Y2EhSACunDLOSiIg0lInmOD4O/Nzd3wx/twPvxl4fCGXt4Xly+bh13P048B5wVoZtncLMFptZn5n1HTx4cEIHlM576lklIgJMPHB8lpO1DYjmBEzmGcoLXWd8oftD7t7l7l3Tp5dmsJ5Gj4uIRAoOHGY2GbgRWBsrHgDOi/09A9gXymekKB+3TtjmmURNY+m2VREaPS4iEplIjeM/AW+4e7wJaj2wMPSUmkWUBH/F3fcD75vZvJC/uAX4XmydRI+pm4BNIQ+yAVhgZm0hKb4glFXE2lfe1VgOERFy6477JPAyMNvMBszs1vDSQsY3U+HuO4GngJ8C/wv4oruPhpdvA/6eKGH+FvB8KH8YOMvMdgNfApaGbR0C7gFeDY+7Q1lFjIw5K9bvrNTbi4hUjcnZFnD3z6Yp/89pyv8G+JsU5X3AR1KU/xr4ozTbWgOsybaP5aKpR0RENHJcRETypMCRh1TdvEREGo0CRx40BlBERIFDRETypMCRJ3XJFZFGp8CRJ02vLiKNToEjT4NDw6p1iEhDU+AowLJ1OxQ8RKRhKXAUYHhkVE1WItKwFDgKpDsCikijUuAokKZZF5FGpcBRgOYmY0n37ErvhohIRShwFOD00ybT05nyZoQiInVPgaMAuo2siDQyBY4CKL8hIo1MgaMAym+ISCNT4CiA8hsi0siy3gFQTtXbP6jgIVInevsHWbVhF/uGhjm3tYUl3bP1+85CNY4CaNS4SH3o7R9k2bodDA4N40Rz0WlKoeyyBg4zW2NmB8zs9aTyPzezXWa208y+Fso6zGzYzLaFx7diy881sx1mttvMHjAzC+VTzGxtKN9iZh2xdRaZ2ZvhsahoRz1Bgxo1LlIXVm3YxfDI6LgyTSmUXS5NVY8A3wQeSxSY2dXADcDl7n7UzD4YW/4td5+TYjsPAouBzcAPgeuA54FbgcPufqGZLQTuB242s2nAcqCL6OZ7W81svbsfzu8QRURSSzd1kKYUyixrjcPdXwQOJRXfBqx096NhmQOZtmFm5wBnuPvL7u5EQagnvHwD8Gh4/gxwbaiNdAMb3f1QCBYbiYKNiEhRpOtary73mRWa47gY+HhoWvonM/tY7LVZZtYfyj8eytqBgdgyA6Es8dq7AO5+HHgPOCtenmKdccxssZn1mVnfwYMHCzwkEWk0S7pn09xk48pymVKot3+Q+Ss3MWvpc8xfuankOZFyv182hfaqmgy0AfOAjwFPmdn5wH5gprv/0szmAr1mdilgKbbh4d90r2VaZ3yh+0PAQwBdXV0plxERSSn5jBH7O1WPK4juyZPIjSQS6pC9q/5dvTt4csu7jLrTZMZnrzyPe3suS/tePZ3tJxL48fdb8vR2vvr9nQwdGeHc1hauvmQ6L7xxsGw9wwoNHAPAutDs9IqZjQFnu/tBINF8tdXM3iKqnQwAM2LrzwD2xbZ1HjBgZpOBM4maxgaAq5LW+XGB+ysidSrTCTdTN9ve/kHufGo7oz4+coyM+YnkeKoA8YHmSWkT6plO1nf17uDxzXtP/D3qfuLvrg9NSxuMUiXwR8acw0dGTiwb324isEDpxpwVGjh6gWuAH5vZxcBpwC/MbDpwyN1HQw3kIuBtdz9kZu+b2TxgC3AL8D/DttYDi4CXgZuATe7uZrYB+B9m1haWWwAsK3B/i05jOUQqL9XV+LJ1O+j72SGe3TqYtlaQWC85aCTsGxpO2+MquSy+Tqr9SwSvdE0hj2/ee6IWkvxeqzbsKqgX58iYs2L9zsoFDjN7kujK/2wzGyDq6bQGWBO66B4DFoWT/SeAu83sODAKfMHdE4n124h6aLUQ9aZ6PpQ/DHzHzHYT1TQWAoRgcw/walju7ti2Km7ZutcUOEQqLN3J/Ykte0mOCcMjo9z51Pa068Wd29qS9wk7OaGeHNQySRfAJtL1f6iEk7FmDRzu/tk0L30+xbLPAs+m2U4f8JEU5b8G/ijNOmuIglTVGR4Zq/QuiDS8dN1m05yHGXVnyTPbGRlNnwptbjKuvmQ6T2zem7KW0NrSzNHjY+MCQktz0ykJ9WzBqZZpypEJUHOVSGUVUjPIFDQgut/OP/5kMGXQMGDFpy8FSJk0n79yE4NDwxhpevKU0aRU3YuKte3Sbbr+3b52G3f17qj0bog0rFLMVD00PMKvjqWuKTjR7/72tds4cuw4q2+ew0tLrwE4MXVJYrlKGyvhTihwTNATm/dWvE+1SKPq6WynbWpzRd778JERbl+7jY6lz3HnU9vrtlkqFTVVTZBD1m54IpKfdOMnUnWvXf6pS7l97baK7m+65Ha9UuAoAs1rI1I86Qa8YSfzE4myv173GkfUUaXsFDiKQPPaiBTPV7+/M+WAt2QjY56yXEpPOY4JMnQrWZFi6e0fPDEiWqqXAscEfW7eTOU3RIpE98GoDQocE5SYoExEJqa3f1A3SasRynGISEUkek5Vy4A5yZ0Ch4iUXXLPKQWN2qKmqgnS4D+R/NXzPE6NQIFjgu5Yu03BQyRPGvtU29RUNUEO/NUz29WzSiSLXO5NIbVBgaMIjmWZbVOk0eVzbwqpfmqqKhI1V4mkl2o0uNQu1TiKRBMdipykrrb1TYGjSDRwSSSirrb1T01VRaTmKhF1tW0EWQOHma0xswNm9npS+Z+b2S4z22lmX4uVLzOz3eG17lj5XDPbEV57wMwslE8xs7WhfIuZdcTWWWRmb4bHoqIccQlpnh0RdbVtBLnUOB4BrosXmNnVwA3A5e5+KfC3ofzDwELg0rDO35lZU1jtQWAxcFF4JLZ5K3DY3S8EVgP3h21NA5YDVwJXAMvNrK2goywT/WBEdJuBRpA1cLj7i8ChpOLbgJXufjQscyCU3wB8192Puvs7wG7gCjM7BzjD3V92dwceA3pi6zwanj8DXBtqI93ARnc/5O6HgY0kBbBqox+MCFx9yXSs0jshJVVojuNi4OOhaemfzOxjobwdeDe23EAoaw/Pk8vHrePux4H3gLMybKtq6b4c0uh6+wd5duugEuJ1rtBeVZOBNmAe8DHgKTM7H1JeaHiGcgpcZxwzW0zUDMbMmTMz7riIlI4S442h0BrHALDOI68AY8DZofy82HIzgH2hfEaKcuLrmNlk4EyiprF02zqFuz/k7l3u3jV9+vQCD2niVqzfWbH3FqkGyvM1hkIDRy9wDYCZXQycBvwCWA8sDD2lZhElwV9x9/3A+2Y2L+QvbgG+F7a1Hkj0mLoJ2BTyIBuABWbWFpLiC0JZ1Roa1i0vpbG1Tm2u9C5IGWRtqjKzJ4GrgLPNbICop9MaYE3oonsMWBRO9jvN7Cngp8Bx4Ivunqi33kbUQ6sFeD48AB4GvmNmu4lqGgsB3P2Qmd0DvBqWu9vdk5P0Vae3f1AjyKWhxEeJS2Ow6HxfP7q6uryvry+vdTqWPle0929vbeGlpdcUbXsi1UyTF1a3PSuvz3lZM9vq7l25LKspR4pMV11SqPi04+e2trCke3bV116VDG9MChwloOaqxlXoyT/5yn1waJhl63YAVPV3ScnwxqS5qkpAU480psTJfzDcqChx8s9lDrNUV+7DI6NV/13SoNfGpMBRAroKa0wTOfmn+85U+3dpSfdsWpqbsi8odUVNVcAkg7Ei9hHQVVjjyOV2qLmc/M9tbUmZH6v271KiGe32tdsquyNSVqpxUNygAXDk2HFNsd4Akpum0snl5J9qfqeW5qaamMbm6b69ld4FKTPVOErg8JGRmkhsynj5JrZz6VHU3GRZT/6p5ncy4DNz22vi+/PSW1U/vEqKTDUOYGpz8f8baiGxKScVktjOpQnq+Jhzx9ptzF+5Ke22UgUgB15442A+hyBSNqpxULpbW1Z7YrPRxWsYk8wYTRoMmwj+6a760+Ul4hKbzNS9tlYT46C7XjYq1TiA4ZGxkmy32hObjSy5hpEcNBIynbzz7VGUrhaa7ntSC98f1aobk2ocJVQLic1GleuI5w80T+KCZT9k1J0mM+ad38aeXw6fyIN8Zm47P9i+P+cJLgeHhpm/ctO4/MmS7tmnTNtRK4lxzZTQmBQ4gLapzRw+UvyZbWshsdmocm0GitdGR93HJYIHh4Z5fHP+PYqSm60S35Nam25EzVSNS4EDWP6pS9UPvcHkkp8opeT8STyAxMXzMGe2NGMGQ0dGKh5cEk190piU4yiRUvTUkuKphmagwaHhjFftyXmYoeERDh8ZyXs6k1LQ5IaNTTUOSpPgOzIyxl29O7i357Kib1vyk2p8BoDZyV5PlbLk6e189fs7U9Yisp2ch0dGWbF+Z0VqHbXQ40tKR4GD0v0IEu3fCh6Vk2rW2SVPb4cqCBoAI2N+Ir+WnPvIpSltaHikIrMxTz2tiV8dU42jUak9hdJ2e3x8814lESso1VX7yJgzMloFUSOF4ZFRbl+7jQuW5X5zsYnWmHv7B5m/chOzlj6XcaBi3BEFjYamwEE0T1Apqa975dRqk0o+cS3RxTefE39CoVPBV2fYlXJR4KD0UzvU6smrHtTCILpiKOQeIFD4VPCWPCOjNBQFDkp/Ym+d2lzS7Ut6S7pnnzLrbL3LZ560fKY7iTdpVUN+SCona+AwszVmdsDMXo+VrTCzQTPbFh6fDOUdZjYcK/9WbJ25ZrbDzHab2QNm0TWLmU0xs7WhfIuZdcTWWWRmb4bHoqIeeUypr0qPqttixfR0tjdks0qi+SpbzSPX6U5ynUJeGkMuNY5HgOtSlK929znh8cNY+Vux8i/Eyh8EFgMXhUdim7cCh939QmA1cD+AmU0DlgNXAlcAy82sLfdDy12p+/QfKdFcWJKbtgat8eXSbJVqvq1U051o3IbEZQ0c7v4iMKEJ983sHOAMd3/Z3R14DOgJL98APBqePwNcG2oj3cBGdz/k7oeBjaQOYBNWjq6M6llVeql6B/X2D/Lvvz5e6V2rmOGRUe58anvaxHlPZzv33XgZ7a0tGNDe2sJ9N16W8wy+0pgmMo7jz8zsFqAPuDOc3AFmmVk/8G/AXe7+z0A7MBBbdyCUEf59F8Ddj5vZe8BZ8fIU64xjZouJajPMnDmzoIMxSttT5K/XvVb1cw/VslTjNZat28Eki7rfNrLEzL+J/5O+nx3ihTcOjhsQ+dLSazJuo9JTtEh1KTQ5/iBwATAH2A98PZTvB2a6eyfwJeAfzOwMSJmfTPya072WaZ3xhe4PuXuXu3dNn15Y19pSn1qOjIyp1lFC6XoHaZDaeMMjozyxeW/evbDynUJe6ltBNQ53/3niuZl9G/hBKD8KHA3Pt5rZW8DFRLWFGbFNzAD2hecDwHnAgJlNBs4kahobAK5KWufHhexvLppS3Min2DLdFEgmRk0puUv+lidPuJiYomVwaPjE76I9TCH/5JZ3S/47kepXUI0j5CwS/hB4PZRPN7Om8Px8oiT42+6+H3jfzOaF/MUtwPfC+uuBRI+pm4BNIQ+yAVhgZm0hKb4glJVEOX4MExmoJZk1yniNUkk0Q8V7T8H4Zq4nNu9l3vkl6Z8iNSaX7rhPAi8Ds81swMxuBb4Wuta+BlwN3BEW/wTwmpltJ0p0f8HdE4n124C/B3YDbwHPh/KHgbPMbDdR89ZSgLDePcCr4XF3bFtF116mE0+hA7UkMzWlTFyippGu95TDuPuRSOMyr7NqZ1dXl/f19eW9XnJytVzaW1uyJiYlN739g7qvikjMnpXX57ysmW11965cltXI8SDRLbHco4zVU6V4lD8SKQ8FjphKjDJuMitodlI5lf7fRMpD9+OosFH3lOMPQFfQ+dIsxCLloRpHknLf8rXJrKDZSeVU6pIrUh4KHDG9/YNlv8FPum7AOgnmT11yRcpDgSNm1YZdVTM9hU6C+Sv1DblEakkpO/ooxxFTLVf5qWYnlfR6+wdZsX4nQ8Mjld4VkapRyktg1ThiKn2Vn2l2UkktMf5GQUOkfFTjiFnSPZs71m6ryI1qNBCwMLpPhEj5qcYR09PZzufmFTYt+0Spfb4w1dK8KFJtJpUwyaHAkeTenssq8r4vvHGwIu9b6yrdvChSrUrZz0dNVSm0NE9iuMy3e9WVc37iU3+LyKlK2atKNY4U7rvx8rK/55ktjXlf7EIkT/0tIqdSr6oG8KtjxzXXUo6UEJeE1pZm5l8wrdK70XAUOFKoxHQfI6POHWu3KXjkQM16kvCrY8f56f73c16+3LNfV1Lb1NK1YihwpFCpE5MDdz69XcEjCyXEJWFk1Dl8JPcxPM7Jm7bVcxBpbjKWf+rSkm1fgSOFSp6YRsdcExxmobv9SaES46X2rLye1TfPob215cTA28/Pm0lrBXONLc2Tsn6vDZh/wTSaLH3Ya5vazKqbfqekg4h1B8AUquFOcp+fN7NiXYNrgaYZkYTWlmaOHh/LmvcyYPXNc/I6oWbrvddkxmevPI8fbN+f8bvYZMaYO2e2NHPs+ChHknpttjQ3cd+N0e893fe6bWozyz91KT2d7SnvWGrA5yZw3sjnDoAKHGl03v2jvKrApaDgkdn8lZvUs6rBxU+4qzbsYt/QMGe2NPOrY8fHzXQ90ZNqqhN14r3jgSif5RL7e25rC0u6Z594Pd33Onl2iUzbKEQ+gSPrOA4zWwP8AXDA3T8SylYAfwokRq39tbv/MLy2DLgVGAX+u7tvCOVzgUeAFuCHwF+4u5vZFOAxYC7wS+Bmd98T1lkE3BXe4153fzSXgyqG6y8/h8c37y3X26X0+Oa9PL5577grDTlJSfLG1Da1maEjI6ecLHM9Mecief2rL5nOlMmTTgSEdL/JxN/Z3runsz3t/qT7XieXZ9pGqeUyAPAR4JtEJ/e41e7+t/ECM/swsBC4FDgX+N9mdrG7jwIPAouBzUSB4zrgeaIgc9jdLzSzhcD9wM1mNg1YDnQR5bS2mtl6dz9c0JHmqZpGch8+MsKSZ7YDuitgXOvU5orXCqW8cp3TrZCTarxZyjg5DmJwaPiUi8hfZxggPNET+rmtLSlrHNXUKSRrctzdXwQO5bi9G4DvuvtRd38H2A1cYWbnAGe4+8setY09BvTE1knUJJ4BrjUzA7qBje5+KASLjUTBpiyq7Wp2ZNS5fe023ZM8ps5aWSWLUt5uIHlQabavVinv0pmq80e13WphIr2q/szMXjOzNWbWFsragXdjywyEsvbwPLl83Drufhx4Dzgrw7ZOYWaLzazPzPoOHixOTaGaonvc4NAwt6/dRufdP2r4APKeEuN1ZZJFTUDxXk7xXk+lvN1AIYNKS3Vx2dPZzn03Xla2Yy9EoXNVPQjcQxSY7wG+DvwJqbtGe4ZyClxnfKH7Q8BDECXHM+14rpZ0z654z6pMDh8ZYdm6HUDjNV8lmhRU4ah9FtqEipHcnYhCgkApLy4rmb/IRUE1Dnf/ubuPuvsY8G3givDSAHBebNEZwL5QPiNF+bh1zGwycCZR01i6bZVFT2c7p59W3WMFSlldrlaap6p+tDQ3sfqP5/DOyut5aek1FT1R5hsEqq3pqNwKChwhZ5Hwh8Dr4fl6YKGZTTGzWcBFwCvuvh9438zmhfzFLcD3YussCs9vAjaFPMgGYIGZtYWmsAWhrGz+5g+rvyvsvqFhevsHmb9yE7OWPlf3ORDNU1UfmsyqqvklVV4h0eRR7mazWpBLd9wngauAs81sgKin01VmNoeo6WgP8F8B3H2nmT0F/BQ4Dnwx9KgCuI2T3XGfDw+Ah4HvmNluoprGwrCtQ2Z2D/BqWO5ud881SV8UPZ3tVd1cBdGsuvF+44NDw3XdhFVtnRakMGPuVfX9zLUbrUQ0ADCLjqXPFW1b5VSvt6LVoL/6UK/fz1qWzwBAzVWVRSlnmCylQq7Ma6HJq5HbletFc5Ppc6xxChxZlHKGyVLKN9kXTzo7J5u8qjF4SO0qxwR8Unq6dWwWtZDnSOXqS6anfS3VdAypks7DI6OsWL+zqn7kX/3+zkrvghToG3lOMCjVSzWOOvWD7ftTlqerWaTLGwwNj1RNraO3f1BTjNSo+RdMU9CoIwocdWpoeISOFLmKdDWLTPP7V8tYkWrZD8nfE3/6u5XeBSkiBY46Nzg0zB1rt3FXb9RFN13SfDRD77pq6QJbLfsh+an2gbSSPwWOBuDAE5v30ts/mDZpnqHCUTXzdlXLfkh+mpt0mqk3+kRzcNEHT6/0LkyYE91Z7FdHj6d+PcNwnmrpOlkt+yH50WSU9Ue9qnJw5Fj6ufdrSSG3WW1tac6a1Cz2ncikvqimWH8UOHLQqG3rLc1NrPh05nEsybfKLOWUJ0qO155GnwywXilw5CDdHbnqWa63q03XSytxki9GTSR+ZzapHbrlcf1SjiMHqWbOrHfuudUY0tXG4uNDJjISXdOo16bTmoz+ryxQ0KhTChw5SNyRq5EMDY9knK+qt3+QOV/9UdqbKTWZZayJ5ErTqNemY6P1NXmqjKemKkkrcZva29duo21qM9dffg4vvHEw69V/S3NT2pN9vvmiRs0viVQz1Thy1OiJ2cNHRnh8896sQSNxg572ND1pHPKaeVc9cmpTa0ttziotuVHgyJGufHMzGm7QkykvlKjJdN79o1MCSPLU7pkma5Tqla03ntQ2NVXlqBF7VhXC4EQwmDJ5Usb8xOEjI9wRmsLaW1u4+pLpPLt1cFzX3me3VscEi5IfJcXrmwJHjpZ0zx43XkFSi49QHxnLniBNLDE4NMwTm/eekmzX/3ftyTRhptQHBY4cJa6g7nxqe8YJAaWwEepA2h5aUlv0+6h/WXMcZrbGzA6Y2espXvtLM3MzOzv83WFmw2a2LTy+FVt2rpntMLPdZvaAWXRZYmZTzGxtKN9iZh2xdRaZ2ZvhsagoRzwBPZ3tfP2Pf6fSu9FwdAVbW9J1jJD6kUty/BHguuRCMzsP+D1gb9JLb7n7nPD4Qqz8QWAxcFF4JLZ5K3DY3S8EVgP3h+1PA5YDVwJXAMvNrC3H4yqZns52Pj9vZqV3o2E0TzKmTFbgqCWaYqT+ZQ0c7v4icCjFS6uBvyKHFgYzOwc4w91fdncHHgN6wss3AI+G588A14baSDew0d0PufthYCMpAlglvPDGwUrvQt0zoi6dY8CRkfqYZFKkXhTUHdfMPg0Muvv2FC/PMrN+M/snM/t4KGsHBmLLDISyxGvvArj7ceA94Kx4eYp1kvdnsZn1mVnfwYOlP6mra25pGbD65jmYwWgOCXapLo0+5qkR5B04zGwq8GXgKyle3g/MdPdO4EvAP5jZGUTngmSJM0K61zKtM77Q/SF373L3runTS9/vX4PSSivRM0v3F69NurCqf4XUOC4AZgHbzWwPMAP4iZn9trsfdfdfArj7VuAt4GKi2sKM2DZmAPvC8wHgPAAzmwycSdQ0dqI8xToV1YiTHpZboT2zpPJ0YVX/8g4c7r7D3T/o7h3u3kF0gv+ou/+rmU03syYAMzufKAn+trvvB943s3khf3EL8L2wyfVAosfUTcCmkAfZACwws7aQFF8QyiquESc9FMmVkuP1L5fuuE8CLwOzzWzAzG7NsPgngNfMbDtRovsL7p5IrN8G/D2wm6gm8nwofxg4y8x2EzVvLQUI690DvBoed8e2VXE9ne3qJiqSZP4F0zRqvAGY19lgna6uLu/r6yvLe3Usfa4s7yNSCy764Ols/NJVld4NKZCZbXX3rlyW1SSHE6CBTiInKWg0DgWOCVCSXEQakQLHBCSS5Lr3gIg0EgWOCerpbGfb8gWV3g2pICP1oKNJBs1N6kAh9Uez4xZJu+7X0RCMaIBie2sLS7pnn+hB1Ns/yIr1O0+MP2mb2szyT0U3M1q1YdeEvxuJ9xWpBgocRaL7ddS/b9w8J21X057O9oyvQRRcMn1HWponMZxhXq49K69n1tLnFECk4tRUVSQ9ne18Zq76r9erz8+bOeHxCZlyYi3NTdx34+Vpe+olRmNrVLZUAwWOItKsufWnyYzPz5vJvT3FmSkgkRP7xs1zaG9twYiave678bK092pvaW46MRo7XU++SSlSKaefph5/UhpqqioiTe5W29qmNjN0ZIRzk/IXpZCuaStRtmrDLvYNDZ+yL+leT1XW97NDPL45+XY5IhOnwFFE5ypBXrMM6P9KdfSOy5QvyfR6clk5pzfXYNjGoqaqIlrSPZvmVG0GUvX+wwXTKr0LRVeuGrChiQ0bjQJHEfV0trPqj35HAwJr0J5f1l9NMV0i3Yia5RLPJ+pzReg4ILVFTVVFFm9GuGDZDxmts0kk61U95qdSdRGPem9ddsqJvtBuvsXsOCC1QzWOEvrsledlX0iqQj12c010/03VeytZtuNvbWlmavPJ00Xb1Ga+cfMcBY0GpRpHCSV+VOrZUt3i3V3rTbZEe0Kq2okRNUMpOEgyBY4Su7fnMro+NI0lT29nZEzNVtWiyYwx97J0va0F2boBi8QpcJRB4scXn8tIKiddO3+jy7V2IqIcR5nERwxL5WRq5xeR3KjGUWblHJQl47W3tvDS0msqvRsiNS9rjcPM1pjZATN7PcVrf2lmbmZnx8qWmdluM9tlZt2x8rlmtiO89oCZWSifYmZrQ/kWM+uIrbPIzN4Mj0UTPtoqUI/dPmtBPSfARcotl6aqR4DrkgvN7Dzg94C9sbIPAwuBS8M6f2dmiZnWHgQWAxeFR2KbtwKH3f1CYDVwf9jWNGA5cCVwBbDczNryO7zqk67bY3trC3tWXn9i8juZuFy6oYpI/rI2Vbn7i/FaQMxq4K+A78XKbgC+6+5HgXfMbDdwhZntAc5w95cBzOwxoAd4PqyzIqz/DPDNUBvpBja6+6GwzkaiYPNkfodYXdINykpcDccTlL39g9y+dlsldrMuqFlKpDQKSo6b2aeBQXffnvRSO/Bu7O+BUNYenieXj1vH3Y8D7wFnZdhWqv1ZbGZ9ZtZ38GB1T22ez6Csns521T4KpBnDREon7+S4mU0Fvgykmko01e/VM5QXus74QveHgIcAurq6qn6wRD7dHpd0z+aOtdt017c86f9LpHQKqXFcAMwCtocmqBnAT8zst4lqBfF5NmYA+0L5jBTlxNcxs8nAmcChDNtqKD2d7Xxu3kxdQedJNTWR0sk7cLj7Dnf/oLt3uHsH0Qn+o+7+r8B6YGHoKTWLKAn+irvvB943s3khf3ELJ3Mj64FEj6mbgE3u7sAGYIGZtYWk+IJQ1nDu7bmM1bGkeZMpjGSiHlQipZW1qcrMngSuAs42swFgubs/nGpZd99pZk8BPwWOA19090QW+DaiHlotREnx50P5w8B3QiL9EFGvLNz9kJndA7walrs7kShvRKmat3r7Bwsejd7a0szpUyYzODSMUdtNO00GZ7SU7+59Io3OvM6m/e7q6vK+vr5K70bZ5TsttgHvrLx+XNnnvv0yL71VW7FZ03qLFIeZbXX3rlyW1cjxOpHutrVNZinvCZJqPMkTf/q7Ob/fXb07eHLLu4y6Y8Akg9EyXoO0q2YhUjEKHHUi3fiQz8xt59mtg2nHjRTq3p7LSn6l39s/qNlaRaqQAkedyDQtdteHptXkCViztYpUJ+U4REREOQ4pHTUfiYgCh+Sst39wXB5lcGiYZet2ACh4iDQQ3chJcrZqw65xSXaA4ZFR3WNEpMEocEjO0t1LRPcYEWksChySs3T3EklXLiL1SYFDcrakezYtzU3jyjQvlEjjUXJccpZprIiINA4FDsmLBuWJiJqqREQkLwocIiKSFwUOERHJiwKHiIjkRYFDRETyUnez45rZQeBnE9jE2cAvirQ7lVQvxwE6lmpVL8dSL8cBEzuWD7n79FwWrLvAMVFm1pfr1MLVrF6OA3Qs1apejqVejgPKdyxqqhIRkbwocIiISF4UOE71UKV3oEjq5ThAx1Kt6uVY6uU4oEzHohyHiIjkRTUOERHJiwKHiIjkRYEjMLPrzGyXme02s6WV3p8EM9tjZjvMbJuZ9YWyaWa20czeDP+2xZZfFo5hl5l1x8rnhu3sNrMHzMxC+RQzWxvKt5hZRxH3fY2ZHTCz12NlZdl3M1sU3uNNM1tUomNZYWaD4bPZZmafrPZjMbPzzOwFM/sXM9tpZn8Rymvuc8lwLLX4uXzAzF4xs+3hWL4ayqvzc3H3hn8ATcBbwPnAacB24MOV3q+wb3uAs5PKvgYsDc+XAveH5x8O+z4FmBWOqSm89grwu4ABzwO/H8r/G/Ct8HwhsLaI+/4J4KPA6+Xcd2Aa8Hb4ty08byvBsawA/jLFslV7LMA5wEfD898E/l/Y35r7XDIcSy1+Lgb8RnjeDGwB5lXr56IaR+QKYLe7v+3ux4DvAjdUeJ8yuQF4NDx/FOiJlX/X3Y+6+zvAbuAKMzsHOMPdX/bom/JY0jqJbT0DXJu4Qpkod38ROFSBfe8GNrr7IXc/DGwErivBsaRTtcfi7vvd/Sfh+fvAvwDt1ODnkuFY0qnmY3F3//fwZ3N4OFX6uShwRNqBd2N/D5D5C1hODvzIzLaa2eJQ9lvuvh+iHw/wwVCe7jjaw/Pk8nHruPtx4D3grBIcR0I59r2cn+efmdlrFjVlJZoRauJYQlNFJ9HVbU1/LknHAjX4uZhZk5ltAw4Qncir9nNR4IikusKuln7K8939o8DvA180s09kWDbdcWQ6vmo59mLue7mO6UHgAmAOsB/4+gT2q6zHYma/ATwL3O7u/5Zp0QL2q9LHUpOfi7uPuvscYAZR7eEjGRav6LEocEQGgPNif88A9lVoX8Zx933h3wPAPxI1q/08VEkJ/x4Ii6c7joHwPLl83DpmNhk4k9ybZApRjn0vy+fp7j8PP/Yx4NtEn824/Up6/6o4FjNrJjrRPuHu60JxTX4uqY6lVj+XBHcfAn5M1FxUnZ9LocmcenoQ3Xv9baIkUyI5fmkV7NfpwG/Gnv/f8GVaxfiE2dfC80sZnzB7m5MJs1eJkm2JhNknQ/kXGZ8we6rIx9DB+IRyyfedKMn3DlGiry08n1aCYzkn9vwOojbnqj6W8L6PAd9IKq+5zyXDsdTi5zIdaA3PW4B/Bv6gWj+Xip4Yq+kBfJKoV8ZbwJcrvT9hn84PX47twM7EfhG1S/4f4M3w77TYOl8Ox7CL0JsilHcBr4fXvsnJWQM+ADxNlFx7BTi/iPv/JFFTwQjRVc2t5dp34E9C+W7gv5ToWL4D7ABeA9Yz/oRVlccC/EeiZojXgG3h8cla/FwyHEstfi6XA/1hn18HvlLO33q+x6IpR0REJC/KcYiISF4UOEREJC8KHCIikhcFDhERyYsCh4iI5EWBQ0RE8qLAISIiefn/eZ3Or+97zT0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 21, 21, 18, 18, 2, 21, 21, 11, 22, 31, 29, 21, 18, 21, 22, 20, 21,\n", + " 22, 22, 29, 22, 29, 21, 0])\n", + "loss= tensor(2.4311, grad_fn=) , base rewards= tensor([2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538,\n", + " 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538,\n", + " 2.5538, 2.5538, 2.5538, 2.5538, 1.7850, 1.1234, 0.5337]) return= 166887.4504648441\n", + "probs of actions: tensor([0.0137, 0.2289, 0.1612, 0.0625, 0.0370, 0.0108, 0.2209, 0.2333, 0.0437,\n", + " 0.1131, 0.0219, 0.0175, 0.2343, 0.0663, 0.2709, 0.1197, 0.0565, 0.1557,\n", + " 0.1201, 0.1213, 0.0153, 0.1368, 0.0190, 0.4450, 0.9233],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5919, 0.6386, 0.6743, 0.6737, 0.7055, 0.5960, 0.6407, 0.6956,\n", + " 0.6292, 0.6121, 0.6785, 0.7376, 0.7238, 0.6866, 0.6824, 0.6952, 0.6847,\n", + " 0.6815, 0.6864, 0.6531, 0.7204, 0.6700, 0.7333, 0.7540])\n", + "finalReturns: tensor([0.3239, 0.3723, 0.3639, 0.2203])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 27, 24, 29, 27, 29, 18, 31, 19, 8, 1, 13, 13, 1, 21, 31, 13, 22,\n", + " 18, 18, 19, 30, 31, 16, 0])\n", + "loss= tensor(4.6240, grad_fn=) , base rewards= tensor([2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330,\n", + " 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330,\n", + " 2.4330, 2.4330, 2.4330, 2.4330, 1.7213, 1.0863, 0.5168]) return= 164792.81532247848\n", + "probs of actions: tensor([0.0444, 0.0257, 0.0489, 0.0264, 0.0206, 0.0250, 0.0478, 0.0629, 0.0358,\n", + " 0.0119, 0.0132, 0.0890, 0.0917, 0.0125, 0.2366, 0.0529, 0.0809, 0.0627,\n", + " 0.0594, 0.0539, 0.0401, 0.0073, 0.0562, 0.0219, 0.9404],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5316, 0.6334, 0.6395, 0.6889, 0.6884, 0.7543, 0.6495, 0.7458,\n", + " 0.7412, 0.6843, 0.6090, 0.6280, 0.6544, 0.5675, 0.5739, 0.7257, 0.6545,\n", + " 0.6887, 0.6809, 0.6734, 0.6217, 0.6640, 0.7637, 0.7382])\n", + "finalReturns: tensor([0.3546, 0.4446, 0.4156, 0.2214])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAq6ElEQVR4nO3df5TV9X3n8ed7hhsypBUGJS0OkjH+wBNChDhVum5y1GwZExOdGg14kiO79ZSNm3arSacLCacQtSuGunrcnJqayjHG1OAPOtIal9AlqT2uqEMGGEllRSU4gw0kMK5HpjgM7/3jfi5853J/z/3xvXdej3Pu4fL5/pjP/c7c7/v7+W3ujoiISKGaap0BERGpLwocIiJSFAUOEREpigKHiIgURYFDRESKMqnWGSi3M844w9vb22udDRGRurJt27ZfufuMQvZtuMDR3t5Ob29vrbMhIlJXzOwXhe6rqioRESmKAoeIiBRFgUNERIqiwCEiIkVR4BARkaI0XK+qUvX0DbJ20272Dw1z5rQWujvn0LWgrdbZEhGJHQUOkkFjxYZ+hkdGARgcGmbFhn4ABQ8RkTSqqgLWbtp9ImikDI+MsnbT7hrlSEQkvhQ4gP1DwxnTB7Oki4hMZAocwJnTWjKmG8lqLBEROUmBA2g/PXPgcFB1lYhIGgUOYOvrh7Nuy1aNJSIyUSlwAKM51l2f2pKoYk5EROJPgSOPkdHjtc6CiEisKHDk8e57o/l3EhGZQBQ4RESkKAocwG/95vuybtMFEhEZS1OOAAfeeS/rtuMkx3Jo6hERiZtazbGnB2qS4zVy0VgOEYmb1Bx7g0PDOCfn2KvGoGUFjgJo6hERiZtazrGnqqoCNJvVOgsiMoGs7Onn0RfeZNSdZjNuuOQsOj40fUy1VLYH2sGh4YpXr+ctcZjZOjM7YGYvR9LWm9n28NprZtsj21aY2R4z221mnZH0i8ysP2y7zyx5NzazyeF8e8zsBTNrjxyz1MxeDa+l5frQxco1QFBEpJxW9vTzyNZ9J+47o+48snUfX3t8x5hqqVyPs5WusiqkxPEQ8G3g4VSCuy9OvTezu4G3w/uPAEuAucCZwD+a2fnuPgrcDywDtgI/Aq4EngFuAg67+7lmtgS4C1hsZtOBVUAHyWaIbWa20d2zzw9SIZMnqUZPRMqvp2+Q1Rt3MTQ8AkDrlARvh/fpRo+PfYDN9TibqrKqVKkjb+Bw92ejpYCoUGr4AnBFSLoG+KG7HwXeMLM9wMVmthc4zd2fD8c9DHSRDBzXAKvD8U8A3w7n7QQ2u/uhcMxmksHm0aI/5TgdPabR4yITUb5eS+Pp1dTTN0j34zsYiQSEw0cyB41SVLJtdrxtHJ8Afunur4b/t5EsUaQMhLSR8D49PXXMmwDufszM3gZOj6ZnOGYMM1tGsjTD7Nmzx/FxRESS8q0MWsjKodHAMrUlwXvHRjkyUp0H0Uq2zY63DuYGxpYAMuXUc6SXeszYRPcH3L3D3TtmzJiRI7siIoXJ12sp2/bVG3cBybaKW9dvP9EuMTQ8UrWgAZVtmy05cJjZJOBaYH0keQA4K/L/WcD+kD4rQ/qYY8I5pwKHcpyr6tTCITLxZFtSIZWebfvQ8Agre/r5wdZ9eceIVVJblgXqymE898T/ALzi7tEqqI3AktBT6mzgPOBFd38LeMfMFob2ixuBpyLHpHpMXQdscXcHNgGLzKzVzFqBRSGt6lKjx0Vk4si2MujUlgQ9fYM05agKeqTGQQOyL1BXDoV0x30UeB6YY2YDZnZT2LSEtIZqd98FPAb8HPhfwFdCjyqAm4G/AfYAr5FsGAd4EDg9NKR/FVgeznUIuB14KbxuSzWU10Kq+CkiE0N35xwSTacGh6HhEW5Zvz323fRzLVA3XoX0qrohS/p/zJL+F8BfZEjvBT6aIf3fgOuznGsdsC5fHqthKEsXORFpTF0L2vj6hp1jej3Vk0oGNo0cF5EJodCus+ljK+RUChwF0qQjIvUrU9fZW9Zv55b127n0nOn84A9/Fzg5altyU+AoUH0WVkUaTymD7jJ1nU157rVDtC9/uhJZbVgKHCJSNwoZlLd2027NaF1hChxF0IJOIrWVa9Ddig07Ga7iALuJTGPbiqAFnURqK9egOwWN6lHgKIKKvyK1lW1QnlSXAkcRDI0gF6ml7s45tCSaa52NCU+BowiOqqtEaiU1viJb7yipHjWOFylbHauIVE6mtSukdlTiKJLqWEWqb+2m3QoaMaLAUaTuzjm1zoLIhKOOKfGiwFEkjeMQqa6VPf21zoKkUeAQkdjq6RvU3FExpMAhIrGldXDiSYGjCO9r1hy5ItWkqc3jSYGjCM0ZVgMTEZloNI6jCJoLRxpRKdOUV8vkSU0cPabvXdwocIhMYPmmKa+llT39ChoxlbeqyszWmdkBM3s5Lf2PzWy3me0ys2+FtHYzGzaz7eH1ncj+F5lZv5ntMbP7zMxC+mQzWx/SXzCz9sgxS83s1fBaWrZPLSJA9mnK4zC1zg/Umyq2CilxPAR8G3g4lWBmlwPXAB9z96Nm9sHI/q+5+/wM57kfWAZsBX4EXAk8A9wEHHb3c81sCXAXsNjMpgOrgA6S00RtM7ON7n64uI8oItlkm0Kn1lPr9PQNatXNGMtb4nD3Z4FDack3A2vc/WjY50Cuc5jZTOA0d3/e3Z1kEOoKm68BvhfePwF8KpRGOoHN7n4oBIvNJIONiJRJtil0aj21jrrhxlupvarOBz4Rqpb+ycx+J7LtbDPrC+mfCGltwEBkn4GQltr2JoC7HwPeBk6Ppmc4ZgwzW2ZmvWbWe/DgwRI/ksjE0905h0RaN/NEs2WcWqenb5BL12zh7OVPc+maLWVZYiDbOdUNN95KbRyfBLQCC4HfAR4zsw8DbwGz3f3XZnYR0GNmc0kuZZEuVRLNti3XMWMT3R8AHgDo6OhQCVekGOnfGIfeXxwa09Pq8gtm8OS2wYIb0Vf29PPoC28y6k6zGTdcchYdH5qe95y3rt/OLeu3V/LTShmUGjgGgA2h2ulFMzsOnOHuB4FU9dU2M3uNZOlkAJgVOX4WsD9yrrOAATObBEwlWTU2AFyWdsxPS8yvyISR3r328gtm8JNXDmbsbvvNv991yqyzI8edH2zddyKeDA4Nj/l/SqoRPT1wrOzpHzNNyKg7j2zdx6Mvvslo+FnZzqmnvvpQauDoAa4Afmpm5wPvA35lZjOAQ+4+Gkog5wGvu/shM3vHzBYCLwA3Av8znGsjsBR4HrgO2OLubmabgP9uZq1hv0XAihLzWzY9fYM176Yokk2m7rXRm3i0pABw+EjmKqFCb+jRRvRUwMo2k+1oWoBSkKhfeQOHmT1K8sn/DDMbINnTaR2wLnTRfQ9YGm72nwRuM7NjwCjwZXdPNazfTLKHVgvJ3lTPhPQHge+b2R6SJY0lACHY3A68FPa7LXKumlmxYacCh8RWpu616YZHRvnaYzs4rWX8w7hSjejpAUsaW96/HHe/IcumL2XY90ngySzn6QU+miH934DrsxyzjmSQig2NHpc4K7Qb7ah71tJGoVoSzSca0b/591rSdSLRXFUiDaSS3WhbEk20TWvBgGktCd6faOKW9dtpX/70uIOQ1BcFjhJ88bvP1zoLIhlVcoXK4ZHjDA4NM7UlwbvvHVOwmMAUOErw3GuHytKHXaTcuha00TolUdGfMTQ8wsiomrYnMk1yWKJM3RBFqiFfd9urPjZTq+ZJRSlwlKjWc/nIxFRId1sFDak0VVWVqNZz+cjEpN5LEgcKHCWqZCOkSCY9fYNqkJZYUOAokdo3pNrisEaGCChwlEQrj0stZJvKQ6Ta1DheAnVElGqIzv2khxWJEwUOkRhK7z2lhxWJE1VVicRQIZMVitSKAkeJVvb0599JpEQaJyRxpsBRoke27tO0I1IRPX2DNJlaNSS+FDjGYfXGXbXOgjSYVNvGqKtVQ+JLgWMchoY1GEvKSyPDpR6oV5VIjfX0DbJ64y49iEjdUOAQqaGevkG6H9/ByHFVTUn9UFXVOKmBXMZj7abdChpSd/IGDjNbZ2YHzOzltPQ/NrPdZrbLzL4VSV9hZnvCts5I+kVm1h+23WeW7DZiZpPNbH1If8HM2iPHLDWzV8NraVk+cZlp/iAZD3W7lUqp5IJehZQ4HgKujCaY2eXANcDH3H0u8Jch/SPAEmBuOOavzKw5HHY/sAw4L7xS57wJOOzu5wL3AHeFc00HVgGXABcDq8ystaRPWUH64st4aHp+qZRVn5tbsXPnDRzu/ixwKC35ZmCNux8N+xwI6dcAP3T3o+7+BrAHuNjMZgKnufvz7u7Aw0BX5JjvhfdPAJ8KpZFOYLO7H3L3w8Bm0gJYHOiLL+Nx+QUzap0FaVCVnMG71DaO84FPhKqlfzKz3wnpbcCbkf0GQlpbeJ+ePuYYdz8GvA2cnuNcsaJ1OaRUPX2DPLlNbWRSfi2JyjZfl3r2SUArsBDoBh4LpYRMw109RzolHjOGmS0zs14z6z148GC+vIvEguajkkoZHjle0Y47pQaOAWCDJ70IHAfOCOlnRfabBewP6bMypBM9xswmAVNJVo1lO9cp3P0Bd+9w944ZM6pb9NfocSmV2sekkirZcafUwNEDXAFgZucD7wN+BWwEloSeUmeTbAR/0d3fAt4xs4WhZHIj8FQ410Yg1WPqOmBLaAfZBCwys9bQKL4opMWKBm1JqdQ+JpVUyQeTvAMAzexR4DLgDDMbINnTaR2wLnTRfQ9YGm72u8zsMeDnwDHgK+6eKovfTLKHVgvwTHgBPAh838z2kCxpLAFw90NmdjvwUtjvNndPb6SPhZ6+QS0lKwWLLtAkUimVfDAxb7DJ1Do6Ory3t7eoY9qXPz2un9k2rYXnll8xrnPIxJC+QJNIurZpLeN+qDDgnsXzi3qgNbNt7t5RyL4aOV4GqquuDz19g1y6ZgtnL3+aS9dsqcmofzWISy5t01ro7pwz7qWCnXh2x5WIqS2VG6Ep2RUTCFJP+oNDwzgwODTMig39VQ8eesiQlPTg0JJoprtzDl0L2sa9VHBbhdvPFDjKQGvuVF+xgSDTk/7wyGjVp4xRg/jE1Nw09ibRkmjmiwtn0zatBSN5o7/z2nknSgnjufGnAlAlaXbcMhg6op5V1ZYrEGQqomd70q92CaC7cw63rt8+7idKqR+p6qe1m3azf2iYM8P/c1UldXfOKaktrHVKglWfm1vxzjoKHGWgp8jqydcjKVsgODNLg2O1f3ddC9q4Zf32qv5MGb9EE3xgcqKk7vepIFHMzTy1bzG97+4tsjF8PFRVVQZDR97T9OpVEK2eyiZbILj8ghlZ65SrbfIkfe3qzbHjsH3VoqKrkKYkmkq+mXctaOO55Vdw7+L5tCSac+7bNq2lqkMCVOIog3ffG2XFhn6gsj0ZGl2qNJGtOF9Ij6RMkwam5oSKVg8Z8PmLinsKLJejx45X/WfK+KQeSIqtQnrfpOa8f9f5pJc+jLFzL9XiAUiBo0xy1a9LfunjG1KN3XDyi1NIe8QjW/fxk1cOjvlyZgo4DvzkFc1rJvlFb8ypv6lCl/odGh7J+3ddiGhV13gDUTkocMApEbxU6mpZvFxtFunBOFs7Rbr0L2dcGsZBK0bWm2azMb2d4ORNPHoDbzJjNMNg6mazojpxFKLY9pJKUGUr5QkaoEbyYhXSZhG9uXd3zslb15sS7Wqb7fdSi9+XVoysL8fds96kU20Qb6y5iru/cOEpf5stieaMwQTq/yFTgaOMtDZHcQpps3DgnBU/4ovfff7E/oUOmxkcGqanbzBjwKlVw7jmp4qn5iyDsQp9uOha0Mad1847ZVxGtsb0en/IVFUVyZ4PR0bG32BZ6+JjvSn0qWvUnedeOzm/ZTElxBUb+rnz2nncee28mtcLAzQZHNcgjtiY1pJg+6pFGecQK/bhIlsV0njPG0cKHMDkRHNZAocUp9A2i/FIVVk9t/yKMV/q1HQlg0PDNIf66bYKB5SevkEFjRhJNBurr557oq1ieGS07H8L0Q4atX5oKScFDuCwRn7XRHfnnKoMhksPTulPl6l66MGhYbqf2AFUpvSo9o34SI2wBk75W4jOGVUOcWjMLjcFDjjxlDFeK3v6uaNrXhly1JjSuxGmBuVV4yF8wW0/ZujICGdOa+HIe8eytq2MjDpf37CzIl90tW/UXkuieUwvqUvXbCl7r6eJQI3jUJagAckxBOpumVmmSQkf2bqvanM2HT4ycuLn5ithHqnAes36u6i99IkEIT5zmNUbBQ7KOwXx1zfsLNu5Gkm9rUNRTLVSIdO7q5qqtgxOaeeCeHXVricKHGSepqJUamTPrN6e4AaHhsu6zke9ff5Gky0QxKmrdj1R4EBTT1RDPT7BlXOdj3r8/I0iVyDINv5C7Ru5qXEcPQ1WQz2vQzGedT7yTQMvlZHqdFFIt9pG7PVUaXlLHGa2zswOmNnLkbTVZjZoZtvD6zMhvd3MhiPp34kcc5GZ9ZvZHjO7zyw5VNPMJpvZ+pD+gpm1R45ZamavhtfSsn7yCD0NVl45lsOspcGh4YzVVrnqyAuZUkUqIxU0MrVryPgVUlX1EHBlhvR73H1+eP0okv5aJP3LkfT7gWXAeeGVOudNwGF3Pxe4B7gLwMymA6uAS4CLgVVm1lr4Ryuc6jOro3VKfa/NnqnaKlcdeb11CGg0qkmonLyBw92fBQ7l2y8XM5sJnObuz7u7Aw8DXWHzNcD3wvsngE+F0kgnsNndD7n7YWAzmQNY7KjrZVK0t9H8b/6Yt0tYPS1uhkdG+dpjO078jnPVkevGVR3jnWdKijeeNo4/MrMbgV7ga+HmDnC2mfUB/w9Y6e7/DLQBA5FjB0Ia4d83Adz9mJm9DZweTc9wzBhmtoxkaYbZs2cX/UHK3VWyUgPI6kn66OxSltyMq1F3uh/fwTf/fteJQYWZ6tGrMaXKRHfv4vlAY84HFWel9qq6HzgHmA+8Bdwd0t8CZrv7AuCrwN+a2WmQcULTVJV3tm25jhmb6P6Au3e4e8eMGcV3rS33l7sSA8jqTaNX04wc9zGDCjP1vCpmGngp3rSWxImGbfWMqq6SShzu/svUezP7LvAPIf0ocDS832ZmrwHnkywtzIqcYhawP7wfAM4CBsxsEjCVZNXYAHBZ2jE/LSW/+ZRrypGoiT5lwUSrpol2wU31oqrE35WctPrquSfeq2dUdZVU4ghtFim/D7wc0meYWXN4/2GSjeCvu/tbwDtmtjC0X9wIPBWO3wikekxdB2wJ7SCbgEVm1hoaxReFtLKrxJe70AFkjWoi1i+nSh6pEqyCRmUpUNROId1xHwWeB+aY2YCZ3QR8K3St3QlcDtwadv8ksNPMdpBs6P6yu6ca1m8G/gbYA7wGPBPSHwRON7M9JKu3lgOE424HXgqv2yLnKqtyTjkSVcgAskY1UeuXG7l6TiTFvMGeijo6Ory3t7eoYzIt4lJuqT7lE0n78qdrnQVpYHvXXFXrLDQUM9vm7h2F7KspRzjZpbLQJUlLod41IuWTpQeuVIkCR1Dpkc0GeWdQbSSN/vmkthqsoqTuaK6qKkm1d8DJdg9o3AY+TSMulVSpdkkpjEocEdNaqjclRqYZVBvJROuOK9WjwX21p8AR8dkLZ+bfqYwa+eY6EbvjSuVpcF88KHBEVHtdjka+ueqJUCpBs93GgwJHRDVLAI1c3O7pG2T1xl21zoaIVIgCR0Q1SgCNPpdOakxMI01qKCJjqVdVRHfnHG5Zv71i558IgwAbfXJDEVGJY4xKlwAuv6D4mXvrTSM3+EttNWnQX2wocFRRtRvfa6GRG/ylto5r0F9sKHCkaUlU7pI0+tN4T98g7x49VutsSINSgSM+FDjSfP6iWfl3KtHUKg4wrDY1ikulqcARHwocaZ7e+VbFzv3ue8cadg4nNYqLTBwKHGkOH6ncE/PIqPO1x3Y0ZPBo9Go4qb3WKY1bYq83ChxVNurekAs7qVG8PtVLu0Gi2Vj1ubn5d5SqUOBIU42JDhtxgsPuzjm0JJprnQ0pwt41V3HP4vm0TWvBSHYMiWOXVzNYe92FDTlgtl5pAGCa1VfPreggwJRGW9gp9aVevXGXGsjrQOoBqWtBW8Ybck/fIF97bEfGddNTQebIyPGs529JNDGctj3RZCSa7ZTjDPjiwtl0fGg63Y/vYCTS7zbRZKy9XkEjblTiSFPNP9CVPf1V+1nV0LWgjQ9M1rNIHCSaLGubQKLJWH117mqfrgVt3P2FC08pRbYkmrln8Xx+fvunuXfx/Izb7108n38J21OlmbZpLay9/kJaPzD5lJ/lJMc4dS1oY+31F55yjIJG/OT9lpvZOuCzwAF3/2hIWw38IZAa0fZ1d/9R2LYCuAkYBf6ru28K6RcBDwEtwI+AP3F3N7PJwMPARcCvgcXuvjccsxRYGX7GHe7+vXF+3lh5ZOs+nt75Fqs+N7dhvhyNVpKqN0ayvam7c86Jv6mevkHWbtrN/qHhU7ZlEt3//aH66rhDsxmfv+hkCSX1b7ZzZyrN3JqlNJ/qXJGtBCTxUsjj4UPAt0ne3KPucfe/jCaY2UeAJcBc4EzgH83sfHcfBe4HlgFbSQaOK4FnSAaZw+5+rpktAe4CFpvZdGAV0EHyoWSbmW1098MlfdKYOnxkhO4ndgD1vxpgozX415tsc6EVcjNOBYvBoWGMk2MmotVNo+48uW2Qjg9NzxkccjlzWkvGhwt1rqgveauq3P1Z4FCB57sG+KG7H3X3N4A9wMVmNhM4zd2fd3cnGYS6IsekShJPAJ8yMwM6gc3ufigEi80kg03DaZRuuo3W4F9PxjNNf2rwZuqGnmug3Xg7dmTqRNHISww0qvG0cfyRme00s3Vm1hrS2oA3I/sMhLS28D49fcwx7n4MeBs4Pce5TmFmy8ys18x6Dx6sz/mgRt25Zf12Ftz247oNIBrLUR2tUxJ8aeHsMW0B45mmv9jBm+P5PXctaOPOa+eVLe9SG6W2ZN4P3E7y4eR24G7gD8jcLdxzpFPiMWMT3R8AHgDo6OgY98wErVMSFR0ImMvhIyOs2JBsNK+nL1NP3yBNZhl74Uh5tBXQPlGKYgPBeKuV1I5R/0oqcbj7L9191N2PA98FLg6bBoCzIrvOAvaH9FkZ0sccY2aTgKkkq8aynaviaj3QqN7GeaSqOhQ0KiPVU6lSy6YWEwhUrSRQYuAIbRYpvw+8HN5vBJaY2WQzOxs4D3jR3d8C3jGzhaH94kbgqcgxS8P764AtoR1kE7DIzFpDVdiikFZxcXgaGhwa5uzlT3Ppmi2xr7rSPFWV02xW8aqcTO0OqeL+tJYErVMSqlaSMQrpjvsocBlwhpkNkOzpdJmZzSdZdbQX+M8A7r7LzB4Dfg4cA74SelQB3MzJ7rjPhBfAg8D3zWwPyZLGknCuQ2Z2O/BS2O82dy+0kb4hOMkAEveqK7VtVM5x94r/3vN1qxVJZ95g1QsdHR3e29s77vO0L3+6DLkpnzgvO3vpmi0av1Ehcf69S2Mxs23u3lHIvho5nkXcZuLM91Tf0zfIpWu21KR6S3XeldHcZLq2EksKHFnUuoE8Xa4GzGg//Gj1VtzbRiQ7A+7WdBsSU5pYKIuuBW1VmeywUJdfMGPM/6PTQmTqBjs8MsrqjbuqcuOppx5g9eKexfMVNCS2VOKoE/+w4+TKhOkljGzdYIeGR6pS6lD7RnklmuLbEUIEFDjqxtDwyIlR5cV0f61GaaDZYriIQx07ln22cpFYUFVVHTl8ZIRb12/POZdQumqUBjTwr7ymxaxjhkg6lTjqTLG36GqUBlTgKC/FYYk7BY4czvvgB2qdhXGrRmlAN7ryelsrKErMqaoqhyPv1X9lc1uGbrzFLuwj1aW1KSTuFDhyqPepNDJNSJfqkZVqXK+HKU0mEk0iKPVAgSOHbKuV1YPWKYmMS9Jm6pGVGvNRbCkkVXKR8sj2OxOJG7Vx5FDPT37umUsQ2UpRQ8MjRY08T181Tsav788XKWhIXVDgyKFrQRsfeF9z/h1jaGh45JQ5q1b29BfcKyvfmiCaSl1k4lJVVQ49fYO8V8ejsQaHhrll/Xb+25M7OVrC58jVxlPv7T8iUjqVOHJYu2k3I8frv69pvqCRbSbgJrOs1VXq+SMycSlw5DBRnqpXfW7uKSvAQXIMyK3rt7OyJ9nrKjp1+7tHj1U7mw3tSwtn1zoLIgVTVVUO9dyrqhi9vzjE5ElNGdssHHhk6z4e2boP4+TI9SENUiurO7rm1ToLIgVTiSOHTGsxN6JHtu4rKBDUf6WdiJSDAkcOXQvauPPaeZr9VUQkIm/gMLN1ZnbAzF7OsO1PzczN7Izw/3YzGzaz7eH1nci+F5lZv5ntMbP7zJJ3YzObbGbrQ/oLZtYeOWapmb0aXkvL8omL1LWgjbu/cGEtfrSISCwVUuJ4CLgyPdHMzgJ+D9iXtuk1d58fXl+OpN8PLAPOC6/UOW8CDrv7ucA9wF3h/NOBVcAlwMXAKjNrLfBzlVU9j+eoJBVXRSamvN99d38WOJRh0z3An1FA1beZzQROc/fn3d2Bh4GusPka4Hvh/RPAp0JppBPY7O6H3P0wsJkMAaxaEs26Taar3xEuIjIeJd0NzexqYNDdd2TYfLaZ9ZnZP5nZJ0JaGzAQ2WcgpKW2vQng7seAt4HTo+kZjknPzzIz6zWz3oMHD5bykfLSVNciIklFBw4zmwJ8A/jzDJvfAma7+wLgq8DfmtlpQKbW5VRJJdu2XMeMTXR/wN073L1jxowZ+T5CSTTgTUQkqZQSxznA2cAOM9sLzAJ+Zma/7e5H3f3XAO6+DXgNOJ9kaWFW5ByzgP3h/QBwFoCZTQKmkqwaO5Ge4Ziq6+6cQ6JJvauk/DKtmSISZ0UHDnfvd/cPunu7u7eTvMF/3N3/1cxmmFkzgJl9mGQj+Ovu/hbwjpktDO0XNwJPhVNuBFI9pq4DtoR2kE3AIjNrDY3ii0JaTXQtaGPt9epdJeVXz7Mwy8RUSHfcR4HngTlmNmBmN+XY/ZPATjPbQbKh+8vunmpYvxn4G2APyZLIMyH9QeB0M9tDsnprOUA47nbgpfC6LXKumtCU11IJ+ruSepN3yhF3vyHP9vbI+yeBJ7Ps1wt8NEP6vwHXZzlmHbAuXx5F6lVLQr31pP7or7ZI01oyzyQrUoo7r/1YrbMgUjQFjiKtvnpurbMgDUTVVFKPFDiKpFHkIjLRKXCU4Mh7WjJVRCYuBY4SaDBg7bRNa+HexfO5d/H8Me1NUxJNWVcyFJHy0kJOJejunMOKDf0ZFz6Syrh38fxT2gMytQ/09A3qdyNSYSpxlKBrQRufv0iNmtXypYWzC25ETq2hkqn3W7Zx/1pvRaQ4Chwl+skrlZlMUU5qsmTQKHZZ1a4FbWxftYh7F8+nbVoLRrKK64sLZ5+yomNLopkbLjlrQqz0KFIuqqoq0f4JsBZ5rbRNa6G7c864u6p2LWg75RwdH5rO2k272T80zJmRn5OefvkFM/jJKwfZPzTM+xNNDI9oEnmRFAWOEp05rYVBBY+yMuCNNVdV9GdkCia50gEuXbNFv2uRCFVVlUiz5Zbfvztneq2zkFGlSpeahUDqlQJHiVKz5erLXz57fx3Pp/pKdL9uMs1CIPVLgWMcUo2we9dclbXHjhQuru1G3Z1zMjaq37t4PnvXXMXeIqvXJk9q4n984dTuxSL1QoGjTL64cHats1D34jqwMtXFN9pD685r54258ecqeaZqNJvN+NLC2ey+49MKGlLX1DheJnd0zePvfjbIu5qOpCQtieZYL2iUq/EcktVO3Y/vYOT4ydWNE03G2usvVJCQhqMSRxn9xe/PU4N5CTI9wdebVJtXtFSioCGNSiWOMkrdJFZs2Kl+/wVINBtrr2ucm2u+UolIo1DgKLPUjeOW9dtrm5E60EhBQ2QiUVVVBazdtLvWWYi9tmktChoidSpv4DCzdWZ2wMxezrDtT83MzeyMSNoKM9tjZrvNrDOSfpGZ9Ydt95klZ5Yzs8lmtj6kv2Bm7ZFjlprZq+G1dNyftkri2q00LuLeEC4iuRVS4ngIuDI90czOAn4P2BdJ+wiwBJgbjvkrM0t1gL8fWAacF16pc94EHHb3c4F7gLvCuaYDq4BLgIuBVWbWWtzHq41s3UqntSRoi2mX02rI1pVVROpL3sDh7s8ChzJsugf4M8AjadcAP3T3o+7+BrAHuNjMZgKnufvz7u7Aw0BX5JjvhfdPAJ8KpZFOYLO7H3L3w8BmMgSwOMo2YGz11XN5bvkVRQ8YaxRvrLmK55ZfoaAhUudKauMws6uBQXffkbapDXgz8v+BkNYW3qenjznG3Y8BbwOn5zhXpvwsM7NeM+s9eLD2050XMmBsIpc8RKS+Fd2rysymAN8AFmXanCHNc6SXeszYRPcHgAcAOjo6Mu5Tbfm6ZnZ3zuHW9dszfyARkRgrpcRxDnA2sMPM9gKzgJ+Z2W+TLBWcFdl3FrA/pM/KkE70GDObBEwlWTWW7VwNoWtB24SapkQlLJHGUXTgcPd+d/+gu7e7ezvJG/zH3f1fgY3AktBT6mySjeAvuvtbwDtmtjC0X9wIPBVOuRFI9Zi6DtgS2kE2AYvMrDU0ii8KaQ3jjq553Lt4fsPPsKteVCKNJW9VlZk9ClwGnGFmA8Aqd38w077uvsvMHgN+DhwDvuLuqcmbbibZQ6sFeCa8AB4Evm9me0iWNJaEcx0ys9uBl8J+t7l7pkb6upZepbWyp59Htu7LccRYzWaMenwrvMq1mp+IxId5jG86pejo6PDe3t5aZ2Nczl7+dMFtH6lV83r6Bul+fDtxmenk3sWaNlyknpjZNnfvKGRfTTkSQ8UsS5saM1LIPEkre/p59IU3K1pCUQlDpPEpcMRQd+ccVmzoZ3jk5BTtiSYDg5HRkzf9YtsO7uiaxx1d88qSx56+QdZu2s3+oWHOVLAQmVAUOGIodQNOvzFnSqvVzVozwYpMXGrjEBERtXHIWKpWEpFyUuBocD19g2PaSwaHhlmxoR9AwUNESqL1OBrc2k27xzSyAwyPjGrNEBEpmQJHg8u2NojWDBGRUilwNLhsa4NkSxcRyUeBo8FlWxtEc0eJSKnUON7gso0JUcO4iJRKgWMC0GA9ESknVVWJiEhRFDhERKQoChwiIlIUBQ4RESmKAoeIiBSl4WbHNbODwC/GcYozgF+VKTvlpHwVR/kqjvJVnEbM14fcfUYhOzZc4BgvM+stdGrhalK+iqN8FUf5Ks5Ez5eqqkREpCgKHCIiUhQFjlM9UOsMZKF8FUf5Ko7yVZwJnS+1cYiISFFU4hARkaIocIiISHHcXa9kdd2VwG5gD7C8gj9nL9APbAd6Q9p0YDPwavi3NbL/ipCn3UBnJP2icJ49wH2crHacDKwP6S8A7VnysQ44ALwcSatKPoCl4We8CiwtIF+rgcFwzbYDn6lmvoCzgJ8A/wLsAv4kRtcrW95qfc3eD7wI7Aj5+mYcrlmOfNX0eoVtzUAf8A9xuFY572OVukHW0yv8wl4DPgy8L/xRfaRCP2svcEZa2rcIwQpYDtwV3n8k5GUycHbIY3PY9iLwu4ABzwCfDun/BfhOeL8EWJ8lH58EPs7YG3TF8xG+DK+Hf1vD+9Y8+VoN/GmGz1CVfAEzgY+H978J/N/ws+NwvbLlrdbXzIDfCO8TJG9WC2t9zXLkq6bXK2z/KvC3nAwcNf/7ynofq8TNsd5e4UJvivx/BbCiQj9rL6cGjt3AzPB+JrA7Uz6ATSGvM4FXIuk3AH8d3Se8n0RyFKllyUs7Y2/QFc9HdJ+w7a+BG/LkazWZv9RVzVdk21PA78XlemXJW2yuGTAF+BlwSZyuWVq+anq9gFnA/wau4GTgiM21Sn+pjSOpDXgz8v+BkFYJDvzYzLaZ2bKQ9lvu/hZA+PeDefLVFt5nyu+JY9z9GPA2cHqBeatGPkq91n9kZjvNbJ2ZtdYqX2bWDiwg+aQaq+uVljeo8TUzs2Yz206y6nGzu8fimmXJV62v173AnwHHI9trfq2yUeBIsgxpXqGfdam7fxz4NPAVM/tkjn2z5StXfivxWcqZj1Lydz9wDjAfeAu4uxb5MrPfAJ4EbnH3/5cjv1W/XhnyVvNr5u6j7j6f5NP0xWb20Qz7n/gINc5Xza6XmX0WOODu2zJsz6TW30cFjmCAZCNjyixgfyV+kLvvD/8eAP4OuBj4pZnNBAj/HsiTr4HwPlN+TxxjZpOAqcChArNXjXwUfa3d/Zfhy34c+C7Ja1bVfJlZguSN+QfuviEkx+J6ZcpbHK5ZirsPAT8l2QElFtcsPV81vl6XAleb2V7gh8AVZvYIMbpWp8hXlzURXiTr/F4n2dCUahyfW4Gf8wHgNyPv/w/JL9NaxjaCfSu8n8vYRrDXOdkI9hLJRr1UI9hnQvpXGNsI9liO/LQzti2h4vkg2Qj3BsmGuNbwfnqefM2MvL8V+GE18xXO8TBwb1o+a369cuSt1tdsBjAtvG8B/hn4bK2vWY581fR6RX72ZZxs46j531fWe0e5b471+gI+Q7JHymvANyr0Mz4cfuE7SHYF/EZIP51kw9ir4d/ojeEbIU+7CT0kQnoH8HLY9m1Odrt7P/A4yW53LwIfzpKXR0kWyUdIPnXcVK18AH8Q0vcA/6mAfH2fZBfDncBGxn7JK54v4N+TLL7vJNJdMybXK1vean3NPkaya+nOcM4/r+bfegn5qun1imy/jJOBo+Z/X9lemnJERESKojYOEREpigKHiIgURYFDRESKosAhIiJFUeAQEZGiKHCIiEhRFDhERKQo/x+0/4VmlKg++QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 31, 18, 21, 31, 21, 31, 29, 31, 24, 12, 24, 0, 24, 21, 24, 21, 0,\n", + " 26, 31, 21, 27, 21, 24, 0])\n", + "loss= tensor(4.2829, grad_fn=) , base rewards= tensor([3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480,\n", + " 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480,\n", + " 3.0480, 3.0480, 3.0480, 2.2853, 1.6265, 1.0371, 0.5011]) return= 166985.79053327165\n", + "probs of actions: tensor([0.0153, 0.1539, 0.0354, 0.2007, 0.1461, 0.1883, 0.1508, 0.0368, 0.1541,\n", + " 0.0870, 0.0425, 0.0868, 0.0054, 0.0865, 0.1929, 0.0915, 0.1704, 0.0189,\n", + " 0.0245, 0.1555, 0.2186, 0.0451, 0.2213, 0.0887, 0.9680],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5007, 0.6711, 0.6605, 0.6216, 0.7234, 0.6531, 0.6996, 0.6962,\n", + " 0.7480, 0.7667, 0.6596, 0.7369, 0.5892, 0.6567, 0.6582, 0.6921, 0.7336,\n", + " 0.5776, 0.6122, 0.7186, 0.6739, 0.7208, 0.6903, 0.7524])\n", + "finalReturns: tensor([0.5079, 0.5520, 0.5369, 0.4055, 0.2512])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 31, 31, 31, 22, 31, 26, 31, 31, 27, 17, 31, 31, 31, 13, 21, 31, 31,\n", + " 31, 31, 31, 31, 31, 19, 0])\n", + "loss= tensor(3.1720, grad_fn=) , base rewards= tensor([3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928,\n", + " 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928,\n", + " 3.0928, 3.0928, 3.0928, 2.2793, 1.5971, 1.0063, 0.4801]) return= 172733.5729680412\n", + "probs of actions: tensor([0.0751, 0.4758, 0.4666, 0.5244, 0.0692, 0.5142, 0.0166, 0.5094, 0.4870,\n", + " 0.0485, 0.0051, 0.5040, 0.4339, 0.5063, 0.0046, 0.0832, 0.5138, 0.4380,\n", + " 0.4839, 0.5039, 0.6992, 0.6026, 0.5330, 0.0186, 0.9573],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5241, 0.6200, 0.6706, 0.7443, 0.6698, 0.7246, 0.6872, 0.7050,\n", + " 0.7371, 0.7677, 0.6500, 0.6860, 0.7044, 0.7928, 0.6911, 0.6370, 0.6794,\n", + " 0.7010, 0.7119, 0.7174, 0.7202, 0.7215, 0.7822, 0.7653])\n", + "finalReturns: tensor([0.6138, 0.7099, 0.6720, 0.5412, 0.2852])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAsRUlEQVR4nO3df5BV5Z3n8fenmyu5ZFYahOxII4H4g1SIkQ49hhk3KTUz4MSJ9hgVrFiyO9aycTOzo5khBYkV8EdWDJMh5abGjDNSxiRD2himxRiXMGMyTrmKQroRycqKSqQbJhihjSMtNs13/7jPhdO37+37+/f3VXWL08895/Q53fT9nuf5Pj9kZjjnnHO5aqn2BTjnnKsvHjicc87lxQOHc865vHjgcM45lxcPHM455/IyodoXUGrTpk2z2bNnV/synHOuruzYsePXZjY9l30bLnDMnj2b7du3V/synHOurkj6Za77elOVc865vHjgcM45lxcPHM455/LigcM551xesgYOSRskHZL0QqSsW1JfeO2T1BfKZ0sairz3rcgxCyTtkrRX0j2SFMonhvPtlbRN0uzIMcskvRRey0p548455wqTS6+qB4BvAg8mC8xsSXJb0teBNyP7v2xm89Oc515gOfAM8GPgMuBx4EbgiJmdI2kpcDewRNJUYDXQCRiwQ9JmMzuS890551yDubVnFxu37WfEDAGTTmvl6LsjzGiLs2LxXLo62st+DVlrHGb2JHA43Xuh1nAtsHG8c0g6EzjdzJ62xHS8DwJd4e0rgW+H7YeBT4bzLga2mtnhECy2kgg2zjnXlG7t2cV3n3mNkTCruQFvvzuCAQODQ9zc3UfH7T+hp3egrNdR7DiOjwO/MrOXImVzJPUCvwFuNbN/BdqB/sg+/aGM8O9+ADM7LulN4IxoeZpjRpG0nERthlmzZhV5S845Vzt6egdYt2UPBwaHyGURjCNHh1nx8E6AstU+ig0c1zG6tnEQmGVmb0haAPRImgcozbHJn0Gm98Y7ZnSh2X3AfQCdnZ2+wIhzrq719A6wZvNuBoeGCzp+eMS47dHdZQscBfeqkjQBuAroTpaZ2TEzeyNs7wBeBs4jUVuYGTl8JnAgbPcDZ0XOOZlE09jJ8jTHOOdcQ+rpHeDm7r6Cg0bSkaPFHT+eYrrj/j7wopmdbIKSNF1Sa9j+AHAu8IqZHQTekrQw5C9uAB4Jh20Gkj2mrgaeCHmQLcAiSVMkTQEWhTLnnGs4Pb0DXLT2CW7u7qv2pWSVtalK0kbgYmCapH5gtZndDyxlbFL8E8Dtko4DI8DnzCyZWL+JRA+tOIneVI+H8vuB70jaS6KmsRTAzA5LugN4Lux3e+RczjlXt6J5ixltcS754HR+uGOAoeGRal9aTtRoa453dnaaT3LonKtVPb0DrNq0a1SQEBkSuEXat/bynPeVtMPMOnPZt+Fmx3XOuVqSWrs4+u7xMTWLent898DhnHNlklq7GBgcqvIVlYYHjiD1qaBSIzCdc41r3ZY9dZO3yIcHDtI/FazatAso3wAa51zjO9AgNYxUHjhI/1QwNDzCui17PHA45/KSbL1olGapdDxwkPmpoJF/8c654qXrVtv93H6GR+ot3Z0fDxzAjLZ42iAhEv8xvNbhXHNLlwMFxjRxf/eZ16p5mRXjgQOYfUb6wGHgzVXONblMOdD3xFoaMvGdCw8cwDOvZF7io1GTW8653Nz26O60OdBmDRrgS8cCnJzbPp3J8VgFr8Q5V0tu7dlV1skC65UHjiyGR05U+xKcc1XQ0zvA95okZ5EvDxxZvP1u81ZHnWtm67bsqbupQCrFcxzOuaaUuljSpFgLE2Ot3jSVAw8cWbSmW4fQOVfXenoH+EJ3H9GG6KPDJzg67E3TufDAkUWDj+NxrqHkOufclzY9j4eIwnngcM41hHTjLW7p7uPm7j7isRaGvDZRMh44cuCjx52rDemm+Pjpi69zYHCIFmlM1/rkVx40SitrrypJGyQdkvRCpKxbUl947ZPUF3lvlaS9kvZIWhwpXyBpV3jvnrD2OJImhvPtlbRN0uzIMcskvRReyXXJK27dlj3V+tbOueDWnl3c0t3HwOAQxqkpPpJfjzcey5VWLjWOB4BvAg8mC8xsSXJb0teBN8P2h0isGT4PmAH8k6TzzGwEuBdYDjwD/Bi4jMS64zcCR8zsHElLgbuBJZKmAquBThIPDjskbTazzMO8y8RHjztXedHaxeR47GTvJ1d9WQOHmT0ZrQVEhVrDtcCloehK4Ptmdgx4VdJe4EJJ+4DTzezpcNyDQBeJwHElsCYc/zDwzXDexcBWMzscjtlKIthszPsui9Q2yUePO5fNeInpfBdKS81XeNCoLcXmOD4O/MrMXgpft5OoUST1h7LhsJ1anjxmP4CZHZf0JnBGtDzNMRXlNWDnxjfeYmgwdhbZ6HvRWsW7x0e8S2wdKDZwXMfoGkC6UQ82Tnmhx4wiaTmJZjBmzZqV6VoL9qY/7Tg3rvEWQ0tup763atPzHD9hJ9eu8FpF/Sh4yhFJE4CrgO5IcT9wVuTrmcCBUD4zTfmoY8I5JwOHxznXGGZ2n5l1mlnn9OnTC72ljGa0xUt+TucaSaY84IHBoYzvDQ2faPgFjxpVMXNV/T7woplFm6A2A0tDT6k5wLnAs2Z2EHhL0sKQv7gBeCRyTLLH1NXAE2ZmwBZgkaQpkqYAi0JZxV3ywdIHI+caSaaHq8nxmOcIG1Au3XE3Ak8DcyX1S7oxvLWUlES1me0GHgJ+Afxv4POhRxXATcDfA3uBl0kkxgHuB84IifQvACvDuQ4DdwDPhdftyUR5pf1o58FqfFvn6saKxXOJtYxtXR4cGva5nxpQLr2qrstQ/p8zlH8V+Gqa8u3Ah9OUvwNck+FcG4AN2a6x3Lzt1bnxdXW086VNzzN8wpuemoGPHHfOjStbN9voDLOuOXjgcM5llK6b7c1h/qdz3/de9v36qNcympAHDueaUK4D8tKtt5300qG3y32ZrghpUk4l44HDuSaTrhax4gc7+dKm533wXQMpZ0XQl47NUU/vQLUvwbmSSDdYb/iEedBwOfPAkSOfIdc1Cp+00xXLA0eOBvyPzTUInwnBFcsDRx68ucrVu57eAd4+drzal+EqYEoZR+x74MiDN1e5epZMivuYi8YXaxWrPz2vbOf3XlV58LZhV8/SJcVd42nPYb2TYnngyIO3Dbt65g8+zeGplZdm36lI3lSVhxWL51b7EpwrmM9S60rFA0ceyln1c67cfuO5jaZQiU48HjicawK39uzC10xqDpXoxOOBw7kmsHHb/mpfgquQSuSyPHA41wRGzKsbzaISnXi8V5VzFZLrjLTOFSoea61IJx4PHM5VQLoZaVdt2gWUv9PFrT27ynp+V11TJsUYPDpc0YeRXNYc3yDpkKQXUsr/TNIeSbslfS2UzZY0JKkvvL4V2X+BpF2S9kq6R5JC+URJ3aF8m6TZkWOWSXopvJaV7K6dq7B0g++Ghkcqksj83jOvlf17uOpob4vT+5VFvLr2cp5aeWnFarC51DgeAL4JPJgskHQJcCXwETM7Jul9kf1fNrP5ac5zL7AceAb4MXAZ8DhwI3DEzM6RtBS4G1giaSqwGugEDNghabOZHcnvFp2rvkwJy3InMnt6B/DsRuOq1tiyrDUOM3sSOJxSfBOw1syOhX0OjXcOSWcCp5vZ02ZmJIJQV3j7SuDbYfth4JOhNrIY2Gpmh0Ow2Eoi2DhXdzIlLMudyFyzeXdZz++qq1o5skJzHOcBH5f0VeAd4C/N7Lnw3hxJvcBvgFvN7F+BdqA/cnx/KCP8ux/AzI5LehM4I1qe5phRJC0nUZth1qxZBd6Sc+WzYvFcVjy8k+HIYIpYq0Y9MZYieZ56Dp/QsHG1V3EKpEIDxwRgCrAQ+B3gIUkfAA4Cs8zsDUkLgB5J84B0q98m/4IyvTfeMaMLze4D7gPo7Oz0mrmrqJw/8FP+Z46MGLc9uptbuvuYHI/x9rvHTwaWdMnzW3t2sXHbfkbMaJW47mNn0fn+qSe/93tiLQxFVvHzNWTqW6xF/NZ7JnDk6DBi9H+fSvWeyqTQwNEPbArNTs9KOgFMM7PXgWTz1Q5JL5OonfQDMyPHzwQORM51FtAvaQIwmUTTWD9wccoxPyvwekuip3fAu0+6UTKt333bo7tH9XS57dHdDKcsAn0COHI0USNIVzNIJs+7Otq5tWcX340kuUfM+O4zr7Hx2f2MhPMO+dKvDaNVYt01F5z8vKm1rtyFBo4e4FLgZ5LOA04Dfi1pOnDYzEZCDeRc4BUzOyzpLUkLgW3ADcD/CufaDCwDngauBp4wM5O0BfifkqaE/RYBqwq83pJI/hE7l5Rp/e5kQEgGktSgkasDg0P09A6MChpRIwWe19W2E2ajPmu6Otpr6rMna+CQtJHEk/80Sf0kejptADaELrrvAsvCh/0ngNslHQdGgM+ZWTKxfhOJHlpxEr2pHg/l9wPfkbSXRE1jKUAINncAydzJ7ZFzVYVX/V2qXHpFFRo0ACbHY6z4wc6Cj3f1qdaXcMgaOMzsugxvXZ9m3x8CP8xwnu3Ah9OUvwNck+GYDSSClHM1aUZbvKwPFJ7cbj7Vzl/kwueqypOvO+6iav0P3NWXKZNi3HXV+TXVLJWOB448rXh4pwcPd1JXRzst6fr/OTeO9rY41y+cRXtbHIWvv7FkPr1fWVTzQQN8rqq8DY+YJ8mbVLRny+R4DAkGjw77yGyXsxbBX187v+4/P7zGUQBfu7n5JLvdDgwOYSRyD0c8aLg8nbDKLLRUbh44ClDrPR5c6d326O4x3W6dK0QjPHh64CiAJ0SbS0/vwMlxGc4VqxEePD1wFKDe2yddfhqhacHVBtEYD54eOPLkPWiajw/8dOOZMinGhBw+GAR8duGshnjw9F5VefIZHppDsgeVBw2XSXtbnKdWXgrA7JWPZdxPUBPzS5WSBw7nUqROXOhcOrkmuV9de3mZr6TyvKnKuRTpJi50LlU0yd0Wj6XdJ1N5vfPAUYBbe3ZV+xJcGTVCd0lXXqnzSa25Yh6xlDxHrEWsuWJepS+tIjxwFCDTFNeu/vX0DtAi7wHhxkr+r2hvi4+ZT6qro51111wwagqR6HoajcZzHM4FPb0DrHh4JyPmPSDcWMbohHiqWlszo5y8xlEgn+iw8dz26O5Ra4I7l8qbMRM8cBTIB4U1jp7eAebf9hMfHd5k4rEW4rHWvI5phFHfpeBNVQXy/v2Noad3oKilXV19EnDXVR8BODleRzDupJX1sMBSpXjgKJCnTxvDui17PGg0oegI7uS/0WnzZ7TFueSD0/npi6+f/LqRBvAVK5c1xzcAfwQcMrMPR8r/DPhT4DjwmJl9MZSvAm4kseb4/zCzLaF8AafWHP8x8OdhnfKJwIPAAuANYImZ7QvHLANuDd/yTjP7drE3XCr+UdMYvM26uUiwPsN6GM2U3C5WLjmOB4DLogWSLgGuBD5iZvOAvwrlHwKWAvPCMX8jKdmIeC+wHDg3vJLnvBE4YmbnAOuBu8O5pgKrgY8BFwKrJU0p6C6dy6BtUmMO0HJjxVqUMWi4/GQNHGb2JHA4pfgmYK2ZHQv7HArlVwLfN7NjZvYqsBe4UNKZwOlm9rSZGYkaRlfkmGRN4mHgk5IELAa2mtlhMzsCbCUlgDlXjJ7eAf79nePVvgxXKd6+XDKF9qo6D/i4pG2S/kXS74TydmB/ZL/+UNYetlPLRx1jZseBN4EzxjnXGJKWS9ouafvrr79e4C3lJx7zDmn1zvMbzSW57LMrXqGffhOAKcBCYAXwUKglpIvpNk45BR4zutDsPjPrNLPO6dOnZ7v2kvCHl/rn+Y3m47/z0ig0cPQDmyzhWeAEMC2UnxXZbyZwIJTPTFNO9BhJE4DJJJrGMp2rJhwdPlHtS3BF8j75zcd/56VRaODoAS4FkHQecBrwa2AzsFTSRElzSCTBnzWzg8BbkhaGmskNwCPhXJuBZWH7auCJkAfZAiySNCUkxReFsprho8frV0/vAIffPlbty3AV5OMwSieX7rgbgYuBaZL6SfR02gBskPQC8C6wLHzY75b0EPALEt10P29myfmpb+JUd9zHwwvgfuA7kvaSqGksBTCzw5LuAJ4L+91uZqlJ+qpat2WP99CoQ6fW2/BaYzNJnZjQFS5r4DCz6zK8dX2G/b8KfDVN+Xbgw2nK3wGuyXCuDSSCVE3y9tLSSh2AVa4BV77eRvNpb4t70CghHzlehMkNukhLqeUSEFJX3RsYHGLVpsS6J6X+g/eAX39iLSq4B5zAm6hKzPuUFsGXbcguGRAGBocwTgWE1PxQulrA0PBIWbpPeoK0PrRKo9a2mFLgYM3o9CKuNLzGUYRBn001q/ECQvSPOVMtoBy1gxWL53Jzd1/Jz+tKJx5rTZuTyGcteJEIGnd2nV+GK2xuXuMogj+5jq+ndyDjLMKpASHTz7IcP2N/+qxN0dXz0gWNro527rrqfFpzrOqvXzLfg0aZeOAowq///Zh3yc0g2USVSWpAuOSD08cMqvTuk/UrGQBy1SJy6hTR1dHO16+9IOs6Gp4MLy8PHEU4dvwEKx7e2bTBo6d3gIvWPsGclY9x0donRv0csvVcuuSDp0b49/QO8MMdA6OmBRDwmQU+W2m9SgaAXNOAJ4xxc2BRyZpHMjD5A0fleeAoUjPOf5NcMe/m7r6MSe9suYmN2/af3DddkDHgpy9WZt4xV1rJXkxdHe18duGsvKfnyaVTRFdHO0+tvJR9ay9n/ZL5WZu5XGl5crwEmql7Z2q32aho0ntGW3zcVRJHzE42ZVUyMQ5wa0/mJjRXPONUHunOrvPpfP/Uk92xWyRGLHu32nx+976ORuV5jaMEmilJnq0JKvkHv2LxXGIt4z9rDg2P8BcP7cy4Jka5fq4bt+3PvpMrWGpuI1k7eHXt5TnlJ6C5/qbqkdc4SqCZ2lOzPQkaMGflY0w6rTWnAVsjZvz7O8eJtYrhkVP7l7OdOpcnXpfdpFgLwycsr99bsmaQrIFMjsd4+93jFfvdu9LwwAFcdPZUnnq58GmwmqmanK0JChLB4+13c5/SY/iE0RaP8d6JE05+mEhwS3cf67bs8bWea9BFZ09l3xtDDAwO0Rqan9pznCYmtWmpUlPNuNLxwAH84uBb1b6EurFi8Vxu6e4r+Zrrg0PD9K1elHbqkZu7+7jt0d2s/vS8oj9QmrUHXKkI+L2zp/Lz1948+TsaMTtZSyjk9+M5ivrjOQ7gSJEjwBv9wyja7XbN5t0lDxrR75Mph3Lk6HDWbpq5WLN5d1HHN7NWifVL5rPvjaGKTQ/japMHjhJYten5al9C2aTONTU4VL5pVpLdezMZGh4p+oO/nNffyOKxVr5+7QV0dbRXvBecqz0eOEpgaPhEw9Y6am0K8sGh4XF/1uMNSnSFaZVGjY2o5PQwrjZ54ADee1r27oHZNGo1vRafIm/u7ksbFHKdidfl54TZqBzEisVzx3Sp9Z5QzcUDBxBrLf7HUIsfsKVQq0+R6YJCJadmbyap/weiU374aO3m5L2qgDdL0O5dqx+wxSpXL6pSSJ2efby292Ti3eUnU03Ce0I1t6yP2pI2SDoU1hdPlq2RNCCpL7w+FcpnSxqKlH8rcswCSbsk7ZV0j5SYG1nSREndoXybpNmRY5ZJeim8lpX0ziNKsZJfo1bTuzraazJoJA2EoACZg/fkeOxkE5bLXWpuw7mkXNpoHgAuS1O+3szmh9ePI+UvR8o/Fym/F1gOnBteyXPeCBwxs3OA9cDdAJKmAquBjwEXAqslTcn91nJXipX8GvmPq9CV1yol2WSVqe1doqYS/PUiNbfhXFLWwGFmTwKFD6sGJJ0JnG5mT5uZAQ8CXeHtK4Fvh+2HgU+G2shiYKuZHTazI8BW0gewohU7jgMab+K8ZO+k2SsfK8nPp5ySc14BadvefaXGwjRq86srXjFZ4T+V9HxoyorWBOZI6pX0L5I+Hsragf7IPv2hLPnefgAzOw68CZwRLU9zzCiSlkvaLmn766/nPxV3riuKjee7z7zWML13or2T6sWIGbd0951cEnb9kvk8tfLSkzP1uvHFWkf/DXgvKTeeQgPHvcDZwHzgIPD1UH4QmGVmHcAXgH+QdDpj11oBTjadZ3pvvGNGF5rdZ2adZtY5ffr0dLuMq1ST3jVK8rXWxm7kKvlbTO1xla4Jy53SFo+x7uoLvJeUy1lBvarM7FfJbUl/B/wolB8DjoXtHZJeBs4jUVuYGTnFTOBA2O4HzgL6JU0AJpNoGusHLk455meFXG82rTmuEZBNo3TJbYT7SI4yX7N5t48Wz2LNFfO8l5TLS0E1jpCzSPpj4IVQPl1Sa9j+AIkk+CtmdhB4S9LCkL+4AXgkHL8ZSPaYuhp4IuRBtgCLJE0JTWGLQlnJlarGYdAQo5UbpWlncGjYg0YOPGC4fOXSHXcj8DQwV1K/pBuBr4Wutc8DlwC3hN0/ATwvaSeJRPfnzCyZWL8J+HtgL/Ay8Hgovx84Q9JeEs1bKwHCcXcAz4XX7ZFzlVTqwjPFaITRyt627Zwbj6zBFrXp7Oy07du353XMeMuhFqq9Lc5TKy8t2fkqbfbKx6p9Ca5C9q29vNqX4GqApB1m1pnLvj7lCKemUCilgcGhup5ob0KWZV9dYyjFGCbXfDxwBOVo563XifZ6egc4nsOyr67+NViDg6sQDxwVUG8T7dXTtbrilDK/55qHB46g3DWCeuriWk/X6grng/xcoTxwBOV+yq6nLq71dK2uMD7IzxXDp1UPyvmUXU9Pdj29A7x97Hi1L8OVWT33+HPV5zWOoFxP2fX0ZJfsluyD5pxz4/HAEZSjRpAcy1EPQQPqd44q51xleeAIyvHhfskH859wsZo8Ke6cy4UHjjL66Yv5T/FeTZ4Ud87lwgNHRDxW2h9HvT3B11sNyTlXHR44Iu666iMlPV8p1jKvlJ7eAX64o35GtzvnqscDRxn95p3huplqxBPjzrlceeCIKPUgwBMGqzY9X9Jzlku9Nau5wk2ZVD81YVebPHBElOPDc2j4RF3UOjwx3jxWf3petS/B1TkPHBHl+vCsh0kDfV3u8hFw/cJZJycUrOZM5vFYS92MK3K1y6cciVixeC43d/eV/LwDddAM1NXRzvZfHua7z7xW7UtpKAI+u3AWd3aNXe+lp3eAv3hoZ8mWLo6Kx1o4PmIMR6bHj7Wo5B1AXHPKZenYDZIOSXohUrZG0oCkvvD6VOS9VZL2StojaXGkfEFYbnavpHvC2uNImiipO5RvkzQ7cswySS+FV3Jd8rIp55PY7DpY1Knexp3Ukhadyh20htWR2tvirF8yP2PQWLdlT9qgEY+1cv3CWWNqgMny9rY4Yvwp0d8ZPsG6ay4Yte+6ay7w2oYriVxqHA8A3wQeTClfb2Z/FS2Q9CFgKTAPmAH8k6TzzGwEuBdYDjwD/Bi4jMS64zcCR8zsHElLgbuBJZKmAquBThJrIu2QtNnMjhR0pzUguagTlDdIFcoT5IX762vn5/Q77ekdYM3m3RnnAxPwmQXt3Nl1Pp3vn8q6LXs4MDjEjLY4KxbPHfM9Llr7RNoa7Yy2OF0d7TX5/8zVv6yBw8yejNYCsrgS+L6ZHQNelbQXuFDSPuB0M3saQNKDQBeJwHElsCYc/zDwzVAbWQxsNbPD4ZitJILNxhyvpSYNDY+wZvPumvyDjsdaODp8otqXUXfaw4d0NrmsbW+cqvnl8sG/YvHcMeesp9mYXX0qJjn+p5KeD01ZU0JZO7A/sk9/KGsP26nlo44xs+PAm8AZ45yr7g0ODdNx+09qrtlq6LgHjXzl8yGd61iZfGp+XR3t3HXV+aOapOplNmZXvwpNjt8L3EHiAekO4OvAn5C+w4iNU06Bx4wiaTmJZjBmzZo13nVn1SqVJVmZ6sjR4ZpqturpHfD1p3MwKdbCxFgrg0eHMzYfZZJrQMi3d583SblKKyhwmNmvktuS/g74UfiyHzgrsutM4EAon5mmPHpMv6QJwGTgcCi/OOWYn2W4nvuA+wA6OzuL+vi77mNnVaxnUXIt8mr/0SebUFxm7XkGiXRmtMWz9rDzZiZXDwpqqpJ0ZuTLPwaSPa42A0tDT6k5wLnAs2Z2EHhL0sKQv7gBeCRyTLLH1NXAE2ZmwBZgkaQpoSlsUSgrq3Q9YMppYHCo6r2tfLqRzGKt4htL5pdkXZVMY2VaQt3am5lcvcha45C0kcST/zRJ/SR6Ol0saT6JpqN9wH8DMLPdkh4CfgEcBz4felQB3ESih1acRFL88VB+P/CdkEg/TKJXFmZ2WNIdwHNhv9uTifJGU+3eVt6bKrP3njahZL+T5Hmy9ZRyrtbJGqxhu7Oz07Zv317UOWavfKxEV5Of5IqBlZapS6dLJNpeXXt5tS/DubKTtMPMOnPZ16ccqSGZnvx7ege4aO0TzCnTIEJvU8/M5/BybiyfciSNSvWsSpXuQyq173+1m7WaiSeqnUvPA0ca1QgacGoFvuR0FAcGh2hJE8RK3RurHiZhrDQJT1Q7l4EHjjTac+g2WQ4/2nmQzvdPHVXDyBTESnl9nt8Ya32OU4g414w8x5FGtZonBoeGuaW7L6euscmJ9EqhlOdqFB40nMvMA0ca1fzQyLWRrJTNadVqmqtV7z3N1yVxbjweOOpUKWsJXuEYLdbqfxbOjcf/QtKotckH0yllLcErHKO9mWHKc+dcgifH06iHXkbRRXyivbB8NHLxfOyGc+PzwJFGrU/BER1fkG6cx4of7OS2R3fnNINrPdSuKkn4gEjnsvGmqjRq/YnzMwvaR817lNoLa/iEceToMMapAYPpAoTPijvWZxfO8tqac1l44Egj0yymteJHOw+e3M6ldpQcMJjKZ8Udq9KzIztXj7ypKo2ujna2//JwxdblyNfg0DBzVj6Wc9ddSB9gar1JzjlXm7zGkUFy3edalW9HqMnxWE5lzjmXjQeODBrtaTzdOufDI77GeNT1C4tbdti5ZuFNVRnkssxnvTlydJibu/v40qbnmRhr5e13Pb8R5fkN53LjNY4MGrlL5tHhExw56oPcnHOF8cCRgXfJdM659LIGDkkbJB2S9EKa9/5SkkmaFr6eLWlIUl94fSuy7wJJuyTtlXSPlJghSdJESd2hfJuk2ZFjlkl6KbyWleSO89Be4+M5nHOuGnKpcTwAXJZaKOks4A+A1D6rL5vZ/PD6XKT8XmA5cG54Jc95I3DEzM4B1gN3h/NPBVYDHwMuBFZLmpLjfZVEIzdXOedcobIGDjN7Ejic5q31wBfJoWeopDOB083saTMz4EGgK7x9JfDtsP0w8MlQG1kMbDWzw2Z2BNhKmgBWTl0d7UyKeWuec85FFfSpKOkKYMDMdqZ5e46kXkn/Iunjoawd6I/s0x/Kku/tBzCz48CbwBnR8jTHpF7PcknbJW1//fXSjr8YGvYuq845F5V34JA0Cfgy8JU0bx8EZplZB/AF4B8knU5i7rhUyZpKpvfGO2Z0odl9ZtZpZp3Tp0/Pdgt5qfV5q5xzrtIKqXGcDcwBdkraB8wEfi7pt83smJm9AWBmO4CXgfNI1BZmRs4xEzgQtvuBswAkTQAmk2gaO1me5piK8TyHc86NlnfgMLNdZvY+M5ttZrNJfMB/1Mz+TdJ0Sa0Akj5AIgn+ipkdBN6StDDkL24AHgmn3Awke0xdDTwR8iBbgEWSpoSk+KJQVlFdHe1cdPbUSn9bV2G+CKJzucs6clzSRuBiYJqkfmC1md2fYfdPALdLOg6MAJ8zs2Ri/SYSPbTiwOPhBXA/8B1Je0nUNJYCmNlhSXcAz4X9bo+cq6L2vdFYI8jdWJ/16Uacy5mswdYN7ezstO3bt5f0nPnOROvqz761l1f7EpyrKkk7zKwzl329r2kOPEHunHOneODIwYrFc70N3DnnAg8cOejqaPc2cOecCzxw5Min3HbOuQQPHHnwSQ/zc/3CWexbeznfWDKf9rY4AtriMXwWF+fqmy/klIcVi+dyc3dftS+j5k2c0MLdn/nIyanpuzrax0xT33H7T3xNEOfqlD/75aGro53TWj1NPp7rF85iz51/mHU9k9Wfnkc81jqqLNYiYik/31iLaPEfuXM1xWsceXp3xEd0pBOPtXLXVefnvABWcr91W/ZwYHCIGW3xk9O7ZCor11K+bfFYWc7rXKPywOFKIp+gkZSuCStZnqmsp3eg5EFkzRXzSnYu55qBN1XlyZ9Ox2pvi1dsqd2ujnaeWnlpycbVxGMtvkywc3nywJGnNVfMI+aN7qNUYwbhUo3mv+uqj5TkPM41Ew8ceerqaGfdNRdU+zJqSjWe2FcsnjsmuS4SyflcXXT2VK9tOFcADxwF6Opoz+sDqpFVa2xLV0c7d111/snxIe1tcdYvmc+dXednbU5slbh+4Sy+919/tzIX61yD8eR4ge7sOp9//PkAb787Uu1LqZp4rLWqC11lSq6vuWIeK36wk+ETp3rAxVrEumsu8BqGcyXgNY4ifPWPz2/afIcorCdVJSSbE6O1EQ8azpWO1ziKkPwgWvGDPoZPVPliKqhF8NfXzq/pD+JMtRHnXPG8xlGkro523nd6c81hVetBwzlXXh44SuBAmUY016JKjtlwztWmrIFD0gZJhyS9kOa9v5RkkqZFylZJ2itpj6TFkfIFknaF9+6RpFA+UVJ3KN8maXbkmGWSXgqvZUXfbZk0ywqB1U6GO+dqQy41jgeAy1ILJZ0F/AHwWqTsQ8BSYF445m8kJTvb3wssB84Nr+Q5bwSOmNk5wHrg7nCuqcBq4GPAhcBqSVPyu73KSDemoBGT5rWaDHfOVVbWwGFmTwKH07y1HvgiEJ3170rg+2Z2zMxeBfYCF0o6EzjdzJ42MwMeBLoix3w7bD8MfDLURhYDW83ssJkdAbaSJoDVgnRjCtZdcwH71l5Oo0ym601UzrmkgnpVSboCGDCznaHFKakdeCbydX8oGw7bqeXJY/YDmNlxSW8CZ0TL0xyTej3LSdRmmDWrOgPzMvXi+fq18xtiDQ9vonLOJeWdHJc0Cfgy8JV0b6cps3HKCz1mdKHZfWbWaWad06dPT7dL1TTKKHOvbTjnkgrpVXU2MAfYKWkfMBP4uaTfJlErOCuy70zgQCifmaac6DGSJgCTSTSNZTpX3bmz63y+sWR+3c6s60vmOuei8g4cZrbLzN5nZrPNbDaJD/iPmtm/AZuBpaGn1BwSSfBnzewg8JakhSF/cQPwSDjlZiDZY+pq4ImQB9kCLJI0JSTFF4WyutTV0U7f6kV8Y8n8Mavc1bJYq7yZyjk3StYch6SNwMXANEn9wGozuz/dvma2W9JDwC+A48DnzSw5mdNNJHpoxYHHwwvgfuA7kvaSqGksDec6LOkO4Lmw3+1mli5JX1eSTT5/8dBORiz7aoItQLUGpU+ZFGP1p+d5M5VzbhRZDh9e9aSzs9O2b99e7cvIas7Kx9InbFII+L2zp/LUy5WLmadPbOX522qyA5tzrkwk7TCzzlz29bmqqmRGWzyn5U9ntMXHnf47uZRqdI3uaA0h0/s9vQOs2bybwaFhwGsXzrnceY2jSnp6B1i1aRdDw5mnZY/HWn3QnXOuIvKpcfhcVVWSbtDg9Qtnjfrag4ZzrhZ5U1UVFTP1d7YmKuecKxcPHHUotZlrYHCIVZt2AT5QzzlXft5UVYfWbdkzJjcyNDzCui17qnRFzrlm4oGjDmVa/6OZ1gVxzlWPB446lGn9j2ZZF8Q5V10eOOpQuvU/fJEl51yleHK8DiUT4N6ryjlXDR446lQxXXmdc64Y3lTlnHMuLx44nHPO5cUDh3POubx44HDOOZcXDxzOOefy0nDTqkt6HfhlEaeYBvy6RJdTL5rtnpvtfsHvuVkUc8/vN7PpuezYcIGjWJK25zonfaNotntutvsFv+dmUal79qYq55xzefHA4ZxzLi8eOMa6r9oXUAXNds/Ndr/g99wsKnLPnuNwzjmXF69xOOecy4sHDuecc3nxwBFIukzSHkl7Ja2s9vXkQtIGSYckvRApmyppq6SXwr9TIu+tCve3R9LiSPkCSbvCe/dIUiifKKk7lG+TNDtyzLLwPV6StKxC93uWpJ9K+r+Sdkv68ya45/dIelbSznDPtzX6PYfv2yqpV9KPmuF+w/feF663T9L2UFab921mTf8CWoGXgQ8ApwE7gQ9V+7pyuO5PAB8FXoiUfQ1YGbZXAneH7Q+F+5oIzAn32xreexb4XUDA48AfhvL/DnwrbC8FusP2VOCV8O+UsD2lAvd7JvDRsP0fgP8X7quR71nAb4XtGLANWNjI9xy+9xeAfwB+1Oj/ryP3vA+YllJWk/ddkR9Irb/CD3lL5OtVwKpqX1eO1z6b0YFjD3Bm2D4T2JPunoAt4b7PBF6MlF8H/G10n7A9gcSIVEX3Ce/9LXBdFe79EeAPmuWegUnAz4GPNfI9AzOBfwYu5VTgaNj7jXy/fYwNHDV5395UldAO7I983R/K6tF/NLODAOHf94XyTPfYHrZTy0cdY2bHgTeBM8Y5V8WEanYHiSfwhr7n0GzTBxwCtppZo9/zN4AvAiciZY18v0kG/ETSDknLQ1lN3revAJigNGWN1k850z2Od++FHFN2kn4L+CFws5n9JjThpt01TVnd3bOZjQDzJbUB/yjpw+PsXtf3LOmPgENmtkPSxbkckqasbu43xUVmdkDS+4Ctkl4cZ9+q3rfXOBL6gbMiX88EDlTpWor1K0lnAoR/D4XyTPfYH7ZTy0cdI2kCMBk4PM65yk5SjETQ+J6ZbQrFDX3PSWY2CPwMuIzGveeLgCsk7QO+D1wq6bs07v2eZGYHwr+HgH8ELqRW77tS7Xe1/CJR83qFRJIpmRyfV+3ryvHaZzM6x7GO0cm0r4XteYxOpr3CqWTacyQSrslk2qdC+ecZnUx7KGxPBV4lkUibEranVuBeBTwIfCOlvJHveTrQFrbjwL8Cf9TI9xy594s5leNo6PsF3gv8h8j2/yHxgFCT912R/wD18AI+RaKXzsvAl6t9PTle80bgIDBM4qnhRhJtlv8MvBT+nRrZ/8vh/vYQelqE8k7ghfDeNzk1o8B7gB8Ae0n01PhA5Jg/CeV7gf9Sofv9TySq0M8DfeH1qQa/548AveGeXwC+Esob9p4j3/tiTgWOhr5fEj06d4bXbsJnUK3et0854pxzLi+e43DOOZcXDxzOOefy4oHDOedcXjxwOOecy4sHDuecc3nxwOGccy4vHjicc87l5f8Dy7R2Iq7zrDkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 27, 31, 31, 31, 24, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 27, 31, 29, 31, 31, 31, 0])\n", + "loss= tensor(4.8994, grad_fn=) , base rewards= tensor([3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226,\n", + " 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226,\n", + " 3.5226, 3.5226, 2.7216, 2.0451, 1.4570, 0.9302, 0.4485]) return= 174757.78767184287\n", + "probs of actions: tensor([0.7862, 0.7586, 0.0294, 0.8176, 0.7825, 0.8072, 0.0207, 0.7976, 0.7895,\n", + " 0.7703, 0.7915, 0.8017, 0.7380, 0.8028, 0.8266, 0.7872, 0.8071, 0.7630,\n", + " 0.0241, 0.8530, 0.0122, 0.8752, 0.8303, 0.6949, 0.9726],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6624, 0.6630, 0.6927, 0.7077, 0.7538, 0.6878, 0.7053,\n", + " 0.7141, 0.7185, 0.7207, 0.7218, 0.7224, 0.7226, 0.7228, 0.7229, 0.7229,\n", + " 0.7461, 0.7049, 0.7259, 0.7094, 0.7162, 0.7195, 0.8173])\n", + "finalReturns: tensor([0.8706, 0.9667, 0.9174, 0.7960, 0.6066, 0.3688])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 21, 0])\n", + "loss= tensor(2.0205, grad_fn=) , base rewards= tensor([3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498,\n", + " 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498,\n", + " 3.5498, 3.5498, 2.7308, 2.0460, 1.4541, 0.9273, 0.4470]) return= 175369.33354397616\n", + "probs of actions: tensor([0.8780, 0.8573, 0.8730, 0.9065, 0.8867, 0.8989, 0.9029, 0.8870, 0.8921,\n", + " 0.8728, 0.8840, 0.8917, 0.8456, 0.8946, 0.9115, 0.8868, 0.8981, 0.8684,\n", + " 0.8785, 0.9372, 0.9667, 0.9486, 0.9153, 0.0555, 0.9760],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7749, 0.7744])\n", + "finalReturns: tensor([0.8912, 0.9873, 0.9491, 0.8181, 0.6220, 0.3274])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.1789, grad_fn=) , base rewards= tensor([3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.1535, 2.4688, 1.8768, 1.3501, 0.8697, 0.4227]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9456, 0.9385, 0.9475, 0.9667, 0.9544, 0.9637, 0.9643, 0.9583, 0.9566,\n", + " 0.9440, 0.9500, 0.9535, 0.9255, 0.9554, 0.9675, 0.9570, 0.9624, 0.9425,\n", + " 0.9633, 0.9830, 0.9915, 0.9852, 0.9737, 0.9243, 0.9795],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.1840, 1.2801, 1.2420, 1.1110, 0.9148, 0.6722, 0.3963])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0759, grad_fn=) , base rewards= tensor([3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.1535, 2.4688, 1.8768, 1.3501, 0.8697, 0.4227]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9670, 0.9690, 0.9739, 0.9847, 0.9762, 0.9840, 0.9834, 0.9817, 0.9764,\n", + " 0.9688, 0.9722, 0.9747, 0.9550, 0.9755, 0.9850, 0.9789, 0.9829, 0.9690,\n", + " 0.9872, 0.9942, 0.9978, 0.9936, 0.9881, 0.9660, 0.9772],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.1840, 1.2801, 1.2420, 1.1110, 0.9148, 0.6722, 0.3963])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0198, grad_fn=) , base rewards= tensor([4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 3.5585, 2.8737, 2.2818, 1.7551, 1.2747, 0.8277, 0.4050]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9942, 0.9943, 0.9953, 0.9974, 0.9956, 0.9973, 0.9974, 0.9971, 0.9958,\n", + " 0.9948, 0.9951, 0.9956, 0.9908, 0.9961, 0.9976, 0.9962, 0.9971, 0.9963,\n", + " 0.9986, 0.9994, 0.9999, 0.9993, 0.9983, 0.9934, 0.9909],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.5020, 1.5981, 1.5599, 1.4289, 1.2327, 0.9902, 0.7142, 0.4140])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 3.5585, 2.8737, 2.2818, 1.7551, 1.2747, 0.8277, 0.4050]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9984, 0.9983, 0.9987, 0.9993, 0.9987, 0.9993, 0.9994, 0.9992, 0.9988,\n", + " 0.9986, 0.9986, 0.9988, 0.9970, 0.9990, 0.9994, 0.9989, 0.9992, 0.9992,\n", + " 0.9998, 0.9999, 1.0000, 1.0000, 0.9997, 0.9982, 0.9962],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.5020, 1.5981, 1.5599, 1.4289, 1.2327, 0.9902, 0.7142, 0.4140])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694,\n", + " 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 3.9504,\n", + " 3.2657, 2.6737, 2.1470, 1.6666, 1.2196, 0.7969, 0.3919]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.8330, 1.9291, 1.8909, 1.7599, 1.5638, 1.3212, 1.0453, 0.7451, 0.4271])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.4919e-06, grad_fn=) , base rewards= tensor([4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694,\n", + " 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 3.9504,\n", + " 3.2657, 2.6737, 2.1470, 1.6666, 1.2196, 0.7969, 0.3919]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.8330, 1.9291, 1.8909, 1.7599, 1.5638, 1.3212, 1.0453, 0.7451, 0.4271])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.9095e-06, grad_fn=) , base rewards= tensor([5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517,\n", + " 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 4.3327, 3.6479,\n", + " 3.0560, 2.5292, 2.0489, 1.6019, 1.1792, 0.7742, 0.3823]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.1736, 2.2697, 2.2316, 2.1006, 1.9044, 1.6619, 1.3859, 1.0857, 0.7678,\n", + " 0.4368])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.9095e-06, grad_fn=) , base rewards= tensor([5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517,\n", + " 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 4.3327, 3.6479,\n", + " 3.0560, 2.5292, 2.0489, 1.6019, 1.1792, 0.7742, 0.3823]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.1736, 2.2697, 2.2316, 2.1006, 1.9044, 1.6619, 1.3859, 1.0857, 0.7678,\n", + " 0.4368])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.3770e-06, grad_fn=) , base rewards= tensor([5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268,\n", + " 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 4.7078, 4.0230, 3.4311,\n", + " 2.9043, 2.4240, 1.9770, 1.5543, 1.1493, 0.7574, 0.3751]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.5215, 2.6176, 2.5794, 2.4484, 2.2522, 2.0097, 1.7337, 1.4335, 1.1156,\n", + " 0.7846, 0.4439])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.3770e-06, grad_fn=) , base rewards= tensor([5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268,\n", + " 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 4.7078, 4.0230, 3.4311,\n", + " 2.9043, 2.4240, 1.9770, 1.5543, 1.1493, 0.7574, 0.3751]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.5215, 2.6176, 2.5794, 2.4484, 2.2522, 2.0097, 1.7337, 1.4335, 1.1156,\n", + " 0.7846, 0.4439])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.8937e-06, grad_fn=) , base rewards= tensor([5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965,\n", + " 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.0775, 4.3928, 3.8009, 3.2741,\n", + " 2.7937, 2.3468, 1.9240, 1.5191, 1.1271, 0.7449, 0.3698]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.8746, 2.9707, 2.9325, 2.8015, 2.6054, 2.3628, 2.0869, 1.7867, 1.4687,\n", + " 1.1377, 0.7971, 0.4492])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.8937e-06, grad_fn=) , base rewards= tensor([5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965,\n", + " 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.0775, 4.3928, 3.8009, 3.2741,\n", + " 2.7937, 2.3468, 1.9240, 1.5191, 1.1271, 0.7449, 0.3698]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.8746, 2.9707, 2.9325, 2.8015, 2.6054, 2.3628, 2.0869, 1.7867, 1.4687,\n", + " 1.1377, 0.7971, 0.4492])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(3.4586e-06, grad_fn=) , base rewards= tensor([6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622,\n", + " 6.2622, 6.2622, 6.2622, 6.2622, 5.4433, 4.7586, 4.1667, 3.6399, 3.1596,\n", + " 2.7126, 2.2899, 1.8849, 1.4930, 1.1107, 0.7356, 0.3658]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.2317, 3.3278, 3.2896, 3.1587, 2.9625, 2.7199, 2.4440, 2.1438, 1.8259,\n", + " 1.4948, 1.1542, 0.8064, 0.4532])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(3.4586e-06, grad_fn=) , base rewards= tensor([6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622,\n", + " 6.2622, 6.2622, 6.2622, 6.2622, 5.4433, 4.7586, 4.1667, 3.6399, 3.1596,\n", + " 2.7126, 2.2899, 1.8849, 1.4930, 1.1107, 0.7356, 0.3658]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.2317, 3.3278, 3.2896, 3.1587, 2.9625, 2.7199, 2.4440, 2.1438, 1.8259,\n", + " 1.4948, 1.1542, 0.8064, 0.4532])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.0710e-06, grad_fn=) , base rewards= tensor([6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249,\n", + " 6.6249, 6.6249, 6.6249, 5.8061, 5.1214, 4.5295, 4.0028, 3.5224, 3.0754,\n", + " 2.6527, 2.2477, 1.8558, 1.4735, 1.0984, 0.7287, 0.3628]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.5918, 3.6879, 3.6497, 3.5187, 3.3226, 3.0800, 2.8041, 2.5039, 2.1859,\n", + " 1.8549, 1.5143, 1.1664, 0.8133, 0.4562])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.0710e-06, grad_fn=) , base rewards= tensor([6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249,\n", + " 6.6249, 6.6249, 6.6249, 5.8061, 5.1214, 4.5295, 4.0028, 3.5224, 3.0754,\n", + " 2.6527, 2.2477, 1.8558, 1.4735, 1.0984, 0.7287, 0.3628]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.5918, 3.6879, 3.6497, 3.5187, 3.3226, 3.0800, 2.8041, 2.5039, 2.1859,\n", + " 1.8549, 1.5143, 1.1664, 0.8133, 0.4562])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.7302e-06, grad_fn=) , base rewards= tensor([6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852,\n", + " 6.9852, 6.9852, 6.1666, 5.4820, 4.8901, 4.3634, 3.8830, 3.4360, 3.0133,\n", + " 2.6083, 2.2164, 1.8342, 1.4591, 1.0893, 0.7235, 0.3606]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.9541, 4.0502, 4.0120, 3.8810, 3.6849, 3.4423, 3.1664, 2.8662, 2.5482,\n", + " 2.2172, 1.8766, 1.5287, 1.1756, 0.8185, 0.4584])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.7302e-06, grad_fn=) , base rewards= tensor([6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852,\n", + " 6.9852, 6.9852, 6.1666, 5.4820, 4.8901, 4.3634, 3.8830, 3.4360, 3.0133,\n", + " 2.6083, 2.2164, 1.8342, 1.4591, 1.0893, 0.7235, 0.3606]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.9541, 4.0502, 4.0120, 3.8810, 3.6849, 3.4423, 3.1664, 2.8662, 2.5482,\n", + " 2.2172, 1.8766, 1.5287, 1.1756, 0.8185, 0.4584])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(5.4359e-06, grad_fn=) , base rewards= tensor([7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436,\n", + " 7.3436, 6.5252, 5.8408, 5.2490, 4.7223, 4.2420, 3.7950, 3.3723, 2.9673,\n", + " 2.5754, 2.1931, 1.8180, 1.4483, 1.0824, 0.7196, 0.3590]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.3180, 4.4141, 4.3759, 4.2450, 4.0488, 3.8063, 3.5303, 3.2301, 2.9122,\n", + " 2.5812, 2.2405, 1.8927, 1.5395, 1.1824, 0.8223, 0.4601])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(5.4359e-06, grad_fn=) , base rewards= tensor([7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436,\n", + " 7.3436, 6.5252, 5.8408, 5.2490, 4.7223, 4.2420, 3.7950, 3.3723, 2.9673,\n", + " 2.5754, 2.1931, 1.8180, 1.4483, 1.0824, 0.7196, 0.3590]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.3180, 4.4141, 4.3759, 4.2450, 4.0488, 3.8063, 3.5303, 3.2301, 2.9122,\n", + " 2.5812, 2.2405, 1.8927, 1.5395, 1.1824, 0.8223, 0.4601])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.1874e-06, grad_fn=) , base rewards= tensor([7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001,\n", + " 6.8824, 6.1983, 5.6066, 5.0800, 4.5997, 4.1527, 3.7300, 3.3250, 2.9331,\n", + " 2.5509, 2.1758, 1.8060, 1.4402, 1.0773, 0.7167, 0.3577]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.6831, 4.7792, 4.7411, 4.6101, 4.4140, 4.1714, 3.8955, 3.5953, 3.2774,\n", + " 2.9464, 2.6057, 2.2579, 1.9047, 1.5476, 1.1875, 0.8252, 0.4613])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.1874e-06, grad_fn=) , base rewards= tensor([7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001,\n", + " 6.8824, 6.1983, 5.6066, 5.0800, 4.5997, 4.1527, 3.7300, 3.3250, 2.9331,\n", + " 2.5509, 2.1758, 1.8060, 1.4402, 1.0773, 0.7167, 0.3577]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.6831, 4.7792, 4.7411, 4.6101, 4.4140, 4.1714, 3.8955, 3.5953, 3.2774,\n", + " 2.9464, 2.6057, 2.2579, 1.9047, 1.5476, 1.1875, 0.8252, 0.4613])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.9844e-06, grad_fn=) , base rewards= tensor([8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 7.2380,\n", + " 6.5545, 5.9631, 5.4367, 4.9564, 4.5095, 4.0868, 3.6818, 3.2899, 2.9077,\n", + " 2.5326, 2.1628, 1.7970, 1.4341, 1.0735, 0.7145, 0.3568]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([5.0490, 5.1451, 5.1070, 4.9762, 4.7801, 4.5375, 4.2616, 3.9614, 3.6435,\n", + " 3.3125, 2.9718, 2.6240, 2.2709, 1.9137, 1.5537, 1.1914, 0.8274, 0.4622])\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 4\u001b[0m ep\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100_000\u001b[39m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(game\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m----> 7\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mep\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m50_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mclc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperParams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\Find the problem\\Actor critic\\learningBase.py:461\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage\u001b[1;34m(self, stage, episodes, print_step, prob_break_limit_ln, clc, options, lr, just_stage)\u001b[0m\n\u001b[0;32m 458\u001b[0m probs_lst_pre \u001b[38;5;241m=\u001b[39m probs_lst\n\u001b[0;32m 460\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolicy\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m--> 461\u001b[0m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 462\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim\u001b[38;5;241m.\u001b[39mstep()\n\u001b[0;32m 464\u001b[0m \u001b[38;5;66;03m# if episode != 0:\u001b[39;00m\n\u001b[0;32m 465\u001b[0m \u001b[38;5;66;03m# self.meanStageValue = (\u001b[39;00m\n\u001b[0;32m 466\u001b[0m \u001b[38;5;66;03m# (self.meanStageValue*episode)+rewards)/(episode+1)\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 469\u001b[0m \u001b[38;5;66;03m# self.returns[iteration][episode] = returns\u001b[39;00m\n\u001b[0;32m 470\u001b[0m \u001b[38;5;66;03m# self.loss[iteration][episode] = loss\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m 477\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m 478\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[0;32m 479\u001b[0m Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[0;32m 480\u001b[0m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 485\u001b[0m inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[0;32m 486\u001b[0m )\n\u001b[1;32m--> 487\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 488\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[0;32m 489\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\autograd\\__init__.py:197\u001b[0m, in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m 192\u001b[0m retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[0;32m 194\u001b[0m \u001b[38;5;66;03m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[0;32m 195\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[0;32m 196\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[1;32m--> 197\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1e-05, 1, 0]-stage 8-1682146185\n" + ] + } + ], + "source": [ + "print(algorithm.name)\n", + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'algorithm' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m plt\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[43malgorithm\u001b[49m\u001b[38;5;241m.\u001b[39mreturns)),algorithm\u001b[38;5;241m.\u001b[39mreturns)\n", + "\u001b[1;31mNameError\u001b[0m: name 'algorithm' is not defined" + ] + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/Learning + Population.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/Learning + Population.ipynb new file mode 100644 index 0000000..79ca58a --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/Learning + Population.ipynb @@ -0,0 +1,288 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ffac79d8", + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgent import LearningAlgorithm\n", + "from environment import Model\n", + "from Qtable import QTable\n", + "from policyTable import PolicyTable\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from policyTable import PolicyTable\n", + "from play import Tournament\n", + "import re\n", + "import bimatrix\n", + "from fractions import Fraction\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3cbdc6fd", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f47a0d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters for the game:\n", + "total_demand = 400\n", + "initial_demands = [total_demand/2, total_demand/2]\n", + "discount_factor = 1\n", + "low_cost = 57\n", + "high_cost = 71 \n", + "total_stages = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "58173708", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters for the adversary:\n", + "number_actions = 60\n", + "number_demands = total_demand + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b48ea041", + "metadata": {}, + "outputs": [], + "source": [ + "high_cost_player = PolicyTable(number_demands,number_actions,high_cost,total_stages)\n", + "high_cost_player = high_cost_player.random_reset()\n", + "high_cost_probabilities = [1]\n", + "high_cost_players = [high_cost_player]\n", + "low_cost_players = []" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "67c0c760", + "metadata": {}, + "outputs": [], + "source": [ + "def training(total_demand, discount_factor, costs, total_stages, adversary_probabilities, adversaries, number_episodes):\n", + " \n", + " game = Model(total_demand, costs, total_stages, adversaries, adversary_probabilities)\n", + " constant = int(number_episodes/49)\n", + " Qtable = QTable(total_demand + 1, number_actions, total_stages , learning_rate = [constant,constant])\n", + " algorithm = LearningAlgorithm(game, Qtable, number_episodes, discount_factor)\n", + " \n", + " episode_counter = 0\n", + " number_rounds = 1\n", + " number_episodes_per_round = int(number_episodes / number_rounds) \n", + " for round_ in range(number_rounds): \n", + " algorithm.epsilon_greedy_learning(number_episodes_per_round, episode_counter, number_episodes) \n", + " episode_counter += number_episodes_per_round\n", + " agent = Qtable.to_policy_table(costs[0])\n", + " payoff = 0\n", + " if costs[0] < costs[1]:\n", + " for index, adversary in enumerate(adversaries):\n", + " _, _, payoff_against_adversary, _ = new_equilibrium([agent], [adversary], discount_factor, costs, total_stages, [200,200])\n", + " payoff += (payoff_against_adversary * adversary_probabilities[index])\n", + " else:\n", + " for index, adversary in enumerate(adversaries):\n", + " _, _, _, payoff_against_adversary = new_equilibrium([adversary], [agent], discount_factor, [costs[1],costs[0]], total_stages, [200,200])\n", + " payoff += (payoff_against_adversary * adversary_probabilities[index]) \n", + " return Qtable.to_policy_table(costs[0]), payoff" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0522b9af", + "metadata": {}, + "outputs": [], + "source": [ + "def new_equilibrium(low_cost_players, high_cost_players, discount_factor, costs, total_stages, initial_demands):\n", + " \n", + " tournament = Tournament(low_cost_players, high_cost_players, discount_factor, costs, total_stages, initial_demands)\n", + " A,B = tournament.run_tournament()\n", + " number_rows = len(A) # Low cost players\n", + " number_columns = len(A[0]) # High cost players\n", + " \n", + " with open('game.txt', 'w') as f:\n", + " f.write(str(number_rows) + \" \" + str(number_columns))\n", + " f.write('\\n')\n", + " f.write('\\n')\n", + " for row in A:\n", + " for column in row:\n", + " f.write(np.array2string(np.array(int(column))) + \" \")\n", + " f.write('\\n')\n", + " f.write('\\n')\n", + " for row in B:\n", + " for column in row:\n", + " f.write(np.array2string(np.array(int(column))) + \" \")\n", + " f.write('\\n')\n", + " f.write('\\n')\n", + " game = bimatrix.bimatrix(\"game.txt\")\n", + " equilibrium = game.tracing(100)\n", + " low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs(equilibrium)\n", + " low_cost_probabilities = return_distribution(len(low_cost_players), low_cost_probs, low_cost_support)\n", + " high_cost_probabilities = return_distribution(len(high_cost_players), high_cost_probs, high_cost_support)\n", + " low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul(A,np.transpose(high_cost_probabilities)))\n", + " high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul(B,np.transpose(high_cost_probabilities)))\n", + " return low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0fdf2766", + "metadata": {}, + "outputs": [], + "source": [ + "def recover_probs(test):\n", + " low_cost_probs, high_cost_probs, rest = test.split(\")\")\n", + " low_cost_probs = low_cost_probs.split(\"(\")[1] \n", + " _, high_cost_probs = high_cost_probs.split(\"(\")\n", + " high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')]\n", + " low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')]\n", + " _, low_cost_support, high_cost_support = rest.split('[')\n", + " high_cost_support, _ = high_cost_support.split(']')\n", + " high_cost_support = [int(s) for s in high_cost_support.split(',')]\n", + " low_cost_support, _ = low_cost_support.split(']')\n", + " low_cost_support = [int(s) for s in low_cost_support.split(',')]\n", + " return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e1116476", + "metadata": {}, + "outputs": [], + "source": [ + "def return_distribution(number_players, cost_probs, cost_support):\n", + " player_probabilities = [0]* number_players\n", + " for index, support in enumerate(cost_support):\n", + " player_probabilities[support] = cost_probs[support]\n", + " return player_probabilities" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5ca6017a", + "metadata": {}, + "outputs": [], + "source": [ + "low_cost_payoff = 0\n", + "high_cost_payoff = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3cdc6a13", + "metadata": {}, + "outputs": [], + "source": [ + "number_rounds = 1\n", + "number_episodes = 1_000\n", + "equilibria = list()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "656a9d0f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Round 1 of 1\n", + "[1.0] [1.0] 4578.4 2315.9\n" + ] + } + ], + "source": [ + "for round_ in range(number_rounds):\n", + " print(\"Round\",round_ + 1, \" of \", number_rounds)\n", + " update = False\n", + " \n", + " low_cost_player, payoff = training(total_demand, discount_factor, [low_cost, high_cost], total_stages, high_cost_probabilities, high_cost_players, number_episodes)\n", + " if payoff > low_cost_payoff:\n", + " update = True\n", + " low_cost_players.append(low_cost_player)\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = new_equilibrium(low_cost_players, high_cost_players, discount_factor, [low_cost, high_cost], total_stages, initial_demands)\n", + " equilibria.append([low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff)\n", + " \n", + " high_cost_player, payoff = training(total_demand, discount_factor, [high_cost, low_cost], total_stages, low_cost_probabilities, low_cost_players, number_episodes)\n", + " if payoff > high_cost_payoff:\n", + " update = True\n", + " high_cost_players.append(high_cost_player)\n", + " low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = new_equilibrium(low_cost_players, high_cost_players, discount_factor, [low_cost, high_cost], total_stages, initial_demands)\n", + " equilibria.append([low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff])\n", + " print(low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff)\n", + " \n", + " if update:\n", + " number_episodes = 100_000\n", + " else:\n", + " number_episodes += 100_000\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5102fb03", + "metadata": {}, + "outputs": [], + "source": [ + "for index, low_cost_player in enumerate(low_cost_players):\n", + " policy_table = PolicyTable(total_demand + 1, number_actions, low_cost, total_stages)\n", + " policy_table.define(low_cost_player)\n", + " policy_table.save(\"Low Cost \" + str(index))\n", + "for index, high_cost_player in enumerate(high_cost_players):\n", + " policy_table = PolicyTable(total_demand + 1, number_actions, low_cost, total_stages)\n", + " policy_table.define(high_cost_player)\n", + " policy_table.save(\"High Cost \" + str(index))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/TEMPLATE.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/TEMPLATE.ipynb new file mode 100644 index 0000000..18f30c5 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/TEMPLATE.ipynb @@ -0,0 +1,955 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.0001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "24527 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 18, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968,\n", + " 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968,\n", + " 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968, 0.5968]) return= 140305.1458599319\n", + "probs of actions: tensor([9.7228e-01, 9.7357e-01, 9.7232e-01, 9.7705e-01, 9.6317e-01, 9.7690e-01,\n", + " 9.7655e-01, 9.7618e-01, 9.7250e-01, 9.8279e-01, 9.8160e-01, 9.7764e-01,\n", + " 9.7504e-01, 9.7618e-01, 9.6984e-01, 9.7103e-01, 9.7842e-01, 9.7346e-01,\n", + " 9.7620e-01, 9.8331e-01, 9.6818e-01, 9.7596e-01, 1.3203e-04, 9.6867e-01,\n", + " 9.9901e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5301, 0.6320, 0.5968])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "25755 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 26, 0, 26, 26, 26, 26, 0, 26, 26, 0, 26, 26, 26, 0, 26, 26, 26,\n", + " 26, 26, 26, 26, 0, 26, 0])\n", + "loss= tensor(3.7815e-05, grad_fn=) , base rewards= tensor([1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759,\n", + " 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759,\n", + " 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 1.2759, 0.6121]) return= 163403.48619982437\n", + "probs of actions: tensor([0.2713, 0.9437, 0.2477, 0.9074, 0.7945, 0.9064, 0.8652, 0.1833, 0.8615,\n", + " 0.8040, 0.3010, 0.8593, 0.8648, 0.7408, 0.1000, 0.8775, 0.6739, 0.8823,\n", + " 0.8630, 0.7801, 0.8445, 0.8598, 0.1583, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4690, 0.6500, 0.5379, 0.6197, 0.6626, 0.6845, 0.7632, 0.5914,\n", + " 0.6480, 0.7447, 0.5828, 0.6435, 0.6748, 0.7583, 0.5892, 0.6468, 0.6765,\n", + " 0.6916, 0.6992, 0.7030, 0.7049, 0.7734, 0.5962, 0.7180])\n", + "finalReturns: tensor([0.0383, 0.1059])\n", + "----------------------------------------\n", + "614 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 0, 26, 26, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390,\n", + " 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.8390,\n", + " 1.8390, 1.8390, 1.8390, 1.8390, 1.8390, 1.1748, 0.5625]) return= 170660.4533652142\n", + "probs of actions: tensor([0.9908, 0.9982, 0.9919, 0.9974, 0.9944, 0.9979, 0.9970, 0.9954, 0.9965,\n", + " 0.9951, 0.9921, 0.9969, 0.9968, 0.9932, 0.9974, 0.9966, 0.9910, 0.9972,\n", + " 0.9969, 0.9943, 0.9961, 0.0026, 0.9991, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7744, 0.5966, 0.6507, 0.7461])\n", + "finalReturns: tensor([0.1543, 0.2219, 0.1836])\n", + "----------------------------------------\n", + "26 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582,\n", + " 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582, 2.5582,\n", + " 2.5582, 2.5582, 2.5582, 2.5582, 1.7838, 1.1196, 0.5324]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9934, 0.9986, 0.9940, 0.9980, 0.9958, 0.9984, 0.9977, 0.9967, 0.9974,\n", + " 0.9964, 0.9942, 0.9978, 0.9976, 0.9951, 0.9981, 0.9975, 0.9933, 0.9979,\n", + " 0.9977, 0.9958, 0.9971, 0.9990, 0.9992, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.3366, 0.4042, 0.3616, 0.2420])\n", + "----------------------------------------\n", + "21 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0012, grad_fn=) , base rewards= tensor([3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514,\n", + " 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514, 3.0514,\n", + " 3.0514, 3.0514, 3.0514, 2.2770, 1.6128, 1.0256, 0.4932]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9955, 0.9990, 0.9959, 0.9986, 0.9971, 0.9990, 0.9985, 0.9978, 0.9982,\n", + " 0.9976, 0.9961, 0.9985, 0.9984, 0.9968, 0.9987, 0.9983, 0.9954, 0.9986,\n", + " 0.9985, 0.9972, 0.9990, 0.9996, 0.9994, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.5502, 0.6178, 0.5752, 0.4556, 0.2812])\n", + "----------------------------------------\n", + "16 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161,\n", + " 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161, 3.5161,\n", + " 3.5161, 3.5161, 2.7417, 2.0775, 1.4903, 0.9579, 0.4647]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9972, 0.9993, 0.9974, 0.9991, 0.9981, 0.9993, 0.9990, 0.9986, 0.9988,\n", + " 0.9985, 0.9975, 0.9991, 0.9989, 0.9980, 0.9991, 0.9989, 0.9970, 0.9991,\n", + " 0.9990, 0.9990, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([0.7923, 0.8599, 0.8173, 0.6977, 0.5233, 0.3097])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0031, grad_fn=) , base rewards= tensor([3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600,\n", + " 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600, 3.9600,\n", + " 3.9600, 3.1856, 2.5214, 1.9343, 1.4018, 0.9086, 0.4439]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9972, 0.9994, 0.9975, 0.9991, 0.9981, 0.9994, 0.9990, 0.9986, 0.9989,\n", + " 0.9985, 0.9976, 0.9991, 0.9990, 0.9980, 0.9992, 0.9989, 0.9971, 0.9991,\n", + " 0.9990, 0.9991, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.0552, 1.1228, 1.0802, 0.9605, 0.7862, 0.5726, 0.3305])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0047, grad_fn=) , base rewards= tensor([4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887,\n", + " 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887, 4.3887,\n", + " 3.6143, 2.9500, 2.3629, 1.8305, 1.3373, 0.8726, 0.4286]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9973, 0.9994, 0.9975, 0.9991, 0.9982, 0.9994, 0.9991, 0.9987, 0.9989,\n", + " 0.9985, 0.9977, 0.9991, 0.9990, 0.9981, 0.9992, 0.9989, 0.9972, 0.9991,\n", + " 0.9991, 0.9991, 0.9996, 0.9998, 0.9996, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.3333, 1.4009, 1.3584, 1.2387, 1.0643, 0.8507, 0.6086, 0.3458])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "12 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060,\n", + " 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.8060, 4.0316,\n", + " 3.3674, 2.7802, 2.2478, 1.7546, 1.2899, 0.8460, 0.4174]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9985, 0.9996, 0.9987, 0.9995, 0.9990, 0.9997, 0.9995, 0.9993, 0.9994,\n", + " 0.9992, 0.9988, 0.9995, 0.9995, 0.9990, 0.9996, 0.9994, 0.9991, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.6228, 1.6904, 1.6478, 1.5281, 1.3538, 1.1402, 0.8981, 0.6352, 0.3570])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150,\n", + " 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 5.2150, 4.4406, 3.7764,\n", + " 3.1892, 2.6568, 2.1636, 1.6989, 1.2550, 0.8263, 0.4090]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9986, 0.9997, 0.9987, 0.9995, 0.9990, 0.9997, 0.9995, 0.9993, 0.9994,\n", + " 0.9993, 0.9988, 0.9996, 0.9995, 0.9990, 0.9996, 0.9994, 0.9991, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([1.9206, 1.9882, 1.9456, 1.8260, 1.6516, 1.4380, 1.1959, 0.9330, 0.6549,\n", + " 0.3654])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177,\n", + " 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 5.6177, 4.8434, 4.1791, 3.5920,\n", + " 3.0596, 2.5664, 2.1017, 1.6578, 1.2291, 0.8118, 0.4028]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9987, 0.9997, 0.9988, 0.9996, 0.9991, 0.9997, 0.9996, 0.9993, 0.9995,\n", + " 0.9993, 0.9989, 0.9996, 0.9995, 0.9991, 0.9996, 0.9995, 0.9992, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.2246, 2.2922, 2.2497, 2.1300, 1.9556, 1.7420, 1.4999, 1.2370, 0.9589,\n", + " 0.6694, 0.3716])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0084, grad_fn=) , base rewards= tensor([6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 6.0158,\n", + " 6.0158, 6.0158, 6.0158, 6.0158, 6.0158, 5.2415, 4.5773, 3.9901, 3.4577,\n", + " 2.9645, 2.4998, 2.0559, 1.6272, 1.2099, 0.8009, 0.3981]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9987, 0.9997, 0.9989, 0.9996, 0.9991, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9993, 0.9990, 0.9996, 0.9995, 0.9991, 0.9996, 0.9995, 0.9993, 0.9997,\n", + " 0.9997, 0.9997, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.5333, 2.6009, 2.5583, 2.4387, 2.2643, 2.0507, 1.8086, 1.5457, 1.2676,\n", + " 0.9781, 0.6803, 0.3763])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105, 6.4105,\n", + " 6.4105, 6.4105, 6.4105, 6.4105, 5.6361, 4.9719, 4.3848, 3.8524, 3.3592,\n", + " 2.8945, 2.4506, 2.0219, 1.6046, 1.1956, 0.7928, 0.3947]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9988, 0.9997, 0.9989, 0.9996, 0.9992, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9994, 0.9990, 0.9996, 0.9996, 0.9992, 0.9997, 0.9995, 0.9993, 0.9998,\n", + " 0.9998, 0.9998, 0.9998, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([2.8454, 2.9130, 2.8704, 2.7508, 2.5764, 2.3628, 2.1207, 1.8578, 1.5797,\n", + " 1.2902, 0.9924, 0.6884, 0.3797])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0106, grad_fn=) , base rewards= tensor([6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024, 6.8024,\n", + " 6.8024, 6.8024, 6.8024, 6.0282, 5.3640, 4.7769, 4.2445, 3.7513, 3.2866,\n", + " 2.8427, 2.4140, 1.9967, 1.5877, 1.1849, 0.7868, 0.3921]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9989, 0.9997, 0.9990, 0.9996, 0.9992, 0.9997, 0.9996, 0.9994, 0.9995,\n", + " 0.9994, 0.9991, 0.9996, 0.9996, 0.9993, 0.9997, 0.9996, 0.9994, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.1601, 3.2277, 3.1851, 3.0655, 2.8911, 2.6775, 2.4354, 2.1725, 1.8944,\n", + " 1.6049, 1.3071, 1.0031, 0.6944, 0.3823])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923, 7.1923,\n", + " 7.1923, 7.1923, 6.4182, 5.7541, 5.1670, 4.6346, 4.1415, 3.6767, 3.2328,\n", + " 2.8042, 2.3868, 1.9779, 1.5751, 1.1769, 0.7823, 0.3902]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9989, 0.9997, 0.9990, 0.9996, 0.9993, 0.9998, 0.9996, 0.9995, 0.9996,\n", + " 0.9994, 0.9991, 0.9997, 0.9996, 0.9993, 0.9997, 0.9996, 0.9994, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.4767, 3.5443, 3.5017, 3.3821, 3.2077, 2.9941, 2.7520, 2.4892, 2.2110,\n", + " 1.9216, 1.6237, 1.3197, 1.0111, 0.6989, 0.3842])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0147, grad_fn=) , base rewards= tensor([7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805, 7.5805,\n", + " 7.5805, 6.8067, 6.1427, 5.5557, 5.0233, 4.5302, 4.0655, 3.6215, 3.1929,\n", + " 2.7756, 2.3666, 1.9638, 1.5657, 1.1710, 0.7789, 0.3887]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9990, 0.9997, 0.9991, 0.9997, 0.9993, 0.9998, 0.9997, 0.9995, 0.9996,\n", + " 0.9995, 0.9992, 0.9997, 0.9997, 0.9994, 0.9997, 0.9997, 0.9995, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([3.7948, 3.8624, 3.8198, 3.7002, 3.5258, 3.3122, 3.0701, 2.8072, 2.5291,\n", + " 2.2396, 1.9418, 1.6378, 1.3291, 1.0170, 0.7023, 0.3857])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0154, grad_fn=) , base rewards= tensor([7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671, 7.9671,\n", + " 7.1938, 6.5301, 5.9432, 5.4109, 4.9178, 4.4531, 4.0092, 3.5805, 3.1632,\n", + " 2.7542, 2.3514, 1.9533, 1.5586, 1.1665, 0.7764, 0.3876]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9991, 0.9998, 0.9992, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9996,\n", + " 0.9995, 0.9993, 0.9997, 0.9997, 0.9995, 0.9998, 0.9997, 0.9995, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.1139, 4.1815, 4.1389, 4.0193, 3.8450, 3.6314, 3.3893, 3.1264, 2.8482,\n", + " 2.5588, 2.2610, 1.9570, 1.6483, 1.3362, 1.0215, 0.7048, 0.3868])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0162, grad_fn=) , base rewards= tensor([8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 8.3518, 7.5796,\n", + " 6.9165, 6.3298, 5.7976, 5.3045, 4.8399, 4.3960, 3.9674, 3.5500, 3.1410,\n", + " 2.7383, 2.3401, 1.9454, 1.5534, 1.1632, 0.7745, 0.3868]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9991, 0.9998, 0.9992, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9997,\n", + " 0.9996, 0.9994, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9996, 0.9998,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.4337, 4.5013, 4.4588, 4.3392, 4.1649, 3.9513, 3.7092, 3.4464, 3.1682,\n", + " 2.8788, 2.5810, 2.2769, 1.9683, 1.6562, 1.3414, 1.0248, 0.7067, 0.3876])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0162, grad_fn=) , base rewards= tensor([8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 8.7337, 7.9639, 7.3017,\n", + " 6.7156, 6.1836, 5.6907, 5.2261, 4.7822, 4.3536, 3.9362, 3.5273, 3.1245,\n", + " 2.7263, 2.3317, 1.9396, 1.5494, 1.1607, 0.7730, 0.3862]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9992, 0.9998, 0.9993, 0.9997, 0.9994, 0.9998, 0.9997, 0.9996, 0.9997,\n", + " 0.9996, 0.9994, 0.9998, 0.9998, 0.9996, 0.9998, 0.9997, 0.9996, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([4.7540, 4.8216, 4.7792, 4.6597, 4.4854, 4.2719, 4.0298, 3.7669, 3.4888,\n", + " 3.1993, 2.9015, 2.5975, 2.2889, 1.9767, 1.6620, 1.3454, 1.0273, 0.7082,\n", + " 0.3882])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0156, grad_fn=) , base rewards= tensor([9.1110, 9.1110, 9.1110, 9.1110, 9.1110, 9.1110, 8.3456, 7.6856, 7.1004,\n", + " 6.5689, 6.0762, 5.6117, 5.1679, 4.7393, 4.3220, 3.9130, 3.5102, 3.1121,\n", + " 2.7174, 2.3253, 1.9352, 1.5464, 1.1588, 0.7720, 0.3858]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9993, 0.9998, 0.9994, 0.9997, 0.9995, 0.9998, 0.9998, 0.9997, 0.9997,\n", + " 0.9997, 0.9995, 0.9998, 0.9998, 0.9996, 0.9998, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.0745, 5.1421, 5.0999, 4.9805, 4.8063, 4.5928, 4.3508, 4.0880, 3.8098,\n", + " 3.5204, 3.2226, 2.9185, 2.6099, 2.2978, 1.9831, 1.6664, 1.3484, 1.0292,\n", + " 0.7092, 0.3886])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0166, grad_fn=) , base rewards= tensor([9.4794, 9.4794, 9.4794, 9.4794, 9.4794, 8.7231, 8.0672, 7.4840, 6.9535,\n", + " 6.4612, 5.9969, 5.5532, 5.1247, 4.7074, 4.2984, 3.8957, 3.4975, 3.1029,\n", + " 2.7108, 2.3206, 1.9319, 1.5442, 1.1574, 0.7712, 0.3854]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9993, 0.9998, 0.9994, 0.9998, 0.9995, 0.9998, 0.9998, 0.9997, 0.9998,\n", + " 0.9997, 0.9996, 0.9998, 0.9998, 0.9997, 0.9999, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.3948, 5.4624, 5.4205, 5.3014, 5.1275, 4.9141, 4.6721, 4.4093, 4.1312,\n", + " 3.8417, 3.5439, 3.2399, 2.9313, 2.6191, 2.3044, 1.9878, 1.6697, 1.3506,\n", + " 1.0306, 0.7100, 0.3890])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0163, grad_fn=) , base rewards= tensor([9.8309, 9.8309, 9.8309, 9.8309, 9.0923, 8.4448, 7.8656, 7.3369, 6.8455,\n", + " 6.3817, 5.9382, 5.5097, 5.0925, 4.6836, 4.2808, 3.8827, 3.4880, 3.0959,\n", + " 2.7058, 2.3170, 1.9294, 1.5426, 1.1564, 0.7706, 0.3852]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9994, 0.9998, 0.9995, 0.9998, 0.9996, 0.9999, 0.9998, 0.9997, 0.9998,\n", + " 0.9997, 0.9996, 0.9999, 0.9998, 0.9997, 0.9999, 0.9998, 0.9997, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([5.7143, 5.7819, 5.7407, 5.6222, 5.4486, 5.2354, 4.9936, 4.7309, 4.4528,\n", + " 4.1634, 3.8656, 3.5615, 3.2529, 2.9408, 2.6261, 2.3094, 1.9914, 1.6722,\n", + " 1.3522, 1.0316, 0.7106, 0.3892])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0176, grad_fn=) , base rewards= tensor([10.1492, 10.1492, 10.1492, 9.4457, 8.8147, 8.2433, 7.7183, 7.2288,\n", + " 6.7658, 6.3227, 5.8945, 5.4774, 5.0685, 4.6658, 4.2677, 3.8730,\n", + " 3.4809, 3.0907, 2.7020, 2.3144, 1.9275, 1.5413, 1.1556, 0.7701,\n", + " 0.3850]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9995, 0.9999, 0.9995, 0.9998, 0.9996, 0.9999, 0.9998, 0.9998, 0.9998,\n", + " 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999, 0.9998, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.0318, 6.0994, 6.0595, 5.9422, 5.7694, 5.5567, 5.3151, 5.0525, 4.7745,\n", + " 4.4851, 4.1874, 3.8834, 3.5747, 3.2626, 2.9479, 2.6313, 2.3132, 1.9940,\n", + " 1.6741, 1.3535, 1.0324, 0.7111, 0.3894])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0167, grad_fn=) , base rewards= tensor([10.4043, 10.4043, 9.7682, 9.1696, 8.6136, 8.0961, 7.6101, 7.1489,\n", + " 6.7067, 6.2789, 5.8620, 5.4532, 5.0505, 4.6525, 4.2578, 3.8657,\n", + " 3.4756, 3.0868, 2.6992, 2.3124, 1.9262, 1.5404, 1.1550, 0.7698,\n", + " 0.3848]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9995, 0.9999, 0.9996, 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9998,\n", + " 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.3452, 6.4128, 6.3756, 6.2606, 6.0894, 5.8776, 5.6365, 5.3742, 5.0963,\n", + " 4.8070, 4.5093, 4.2053, 3.8967, 3.5846, 3.2699, 2.9532, 2.6352, 2.3160,\n", + " 1.9960, 1.6754, 1.3544, 1.0330, 0.7114, 0.3896])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\n", + " 26, 26, 26, 26, 26, 26, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([10.5430, 10.0317, 9.4952, 8.9696, 8.4668, 7.9880, 7.5303, 7.0898,\n", + " 6.6628, 6.2463, 5.8377, 5.4352, 5.0371, 4.6425, 4.2504, 3.8603,\n", + " 3.4716, 3.0839, 2.6971, 2.3109, 1.9251, 1.5397, 1.1545, 0.7696,\n", + " 0.3847]) return= 171931.00017309192\n", + "probs of actions: tensor([0.9996, 0.9999, 0.9996, 0.9998, 0.9997, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9998, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999, 0.9999, 0.9998, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5684, 0.6359, 0.6709, 0.6888, 0.6978, 0.7023, 0.7045, 0.7057,\n", + " 0.7062, 0.7065, 0.7067, 0.7067, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068,\n", + " 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7068, 0.7744])\n", + "finalReturns: tensor([6.6501, 6.7177, 6.6859, 6.5756, 6.4075, 6.1975, 5.9575, 5.6957, 5.4181,\n", + " 5.1290, 4.8313, 4.5273, 4.2187, 3.9066, 3.5919, 3.2753, 2.9572, 2.6381,\n", + " 2.3181, 1.9975, 1.6765, 1.3551, 1.0335, 0.7116, 0.3897])\n", + "0,[0.0001,1][1, 10000, 1, 1],1682338032 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[50996, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 171931.00017309192, 61130.999905586235, 0.01784641481935978, 0.0001, 1, 0, 'tensor([26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,\\n 26, 26, 26, 26, 26, 26, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[0.0001,1][1, 10000, 1, 1],1682338032', 25, 50, 171931.00017309192, 216972.079356517, 90141.68158887929, 132851.47466666668, 129867.688, 75586.00175631171, 75586.00175631171, 91712.14211264676, 91712.14211264676, 103918.78070576812, 75586.00175631171, 91712.14211264676]\n", + "policy reset\n", + "----------------------------------------\n", + "20196 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9829, 0.9817, 0.9833, 0.9813, 0.9814, 0.9830, 0.9766, 0.9877, 0.9829,\n", + " 0.9777, 0.9770, 0.9807, 0.9820, 0.9828, 0.9853, 0.9854, 0.9831, 0.9799,\n", + " 0.9780, 0.9840, 0.9796, 0.9798, 0.9782, 0.9862, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "29231 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 4, 0, 0, 0, 0, 0, 0, 0, 18, 18, 0, 18, 0, 0, 2, 0, 0,\n", + " 2, 0, 18, 18, 0, 18, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033,\n", + " 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033,\n", + " 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 1.2033, 0.5884]) return= 145639.90478618248\n", + "probs of actions: tensor([0.8123, 0.0217, 0.8376, 0.8246, 0.8538, 0.8365, 0.6731, 0.8068, 0.8012,\n", + " 0.5065, 0.1790, 0.7986, 0.3048, 0.8478, 0.8667, 0.0651, 0.7699, 0.7195,\n", + " 0.0874, 0.7782, 0.1389, 0.1057, 0.7413, 0.9990, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5350, 0.5644, 0.5634, 0.5630, 0.5627, 0.5626, 0.5626, 0.5625,\n", + " 0.5301, 0.5996, 0.6683, 0.5819, 0.6591, 0.6099, 0.5855, 0.5818, 0.5721,\n", + " 0.5669, 0.5724, 0.5351, 0.6022, 0.6697, 0.5825, 0.6595])\n", + "finalReturns: tensor([0.0387, 0.0711])\n", + "----------------------------------------\n", + "5854 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 18, 18, 18,\n", + " 18, 18, 18, 0, 18, 18, 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903,\n", + " 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.7903,\n", + " 1.7903, 1.7903, 1.7903, 1.7903, 1.7903, 1.1589, 0.5624]) return= 162500.80801629333\n", + "probs of actions: tensor([0.9176, 0.9049, 0.8263, 0.8896, 0.8708, 0.9044, 0.9630, 0.9452, 0.9347,\n", + " 0.9912, 0.9645, 0.9213, 0.9762, 0.8875, 0.1613, 0.8918, 0.9604, 0.9668,\n", + " 0.9129, 0.9288, 0.9479, 0.0403, 0.9990, 0.9999, 0.9990],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.7056, 0.5996, 0.6359, 0.6544,\n", + " 0.6638, 0.6685, 0.6708, 0.7044, 0.5991, 0.6356, 0.6867])\n", + "finalReturns: tensor([0.1310, 0.1634, 0.1243])\n", + "----------------------------------------\n", + "225 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0006, grad_fn=) , base rewards= tensor([2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587,\n", + " 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587, 2.4587,\n", + " 2.4587, 2.4587, 2.4587, 2.4587, 1.7531, 1.1211, 0.5416]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9828, 0.9791, 0.9639, 0.9793, 0.9724, 0.9812, 0.9923, 0.9902, 0.9876,\n", + " 0.9981, 0.9930, 0.9858, 0.9954, 0.9777, 0.9626, 0.9789, 0.9934, 0.9941,\n", + " 0.9832, 0.9868, 0.9900, 0.9990, 0.9996, 1.0000, 0.9989],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.2665, 0.2989, 0.2577, 0.1640])\n", + "----------------------------------------\n", + "61 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728,\n", + " 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728, 2.9728,\n", + " 2.9728, 2.9728, 2.9728, 2.2672, 1.6351, 1.0556, 0.5140]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9912, 0.9893, 0.9827, 0.9902, 0.9873, 0.9906, 0.9962, 0.9955, 0.9940,\n", + " 0.9990, 0.9965, 0.9933, 0.9976, 0.9892, 0.9819, 0.9897, 0.9967, 0.9971,\n", + " 0.9915, 0.9931, 0.9990, 0.9995, 0.9998, 1.0000, 0.9988],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.4256, 0.4580, 0.4169, 0.3232, 0.1916])\n", + "----------------------------------------\n", + "41 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0014, grad_fn=) , base rewards= tensor([3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666,\n", + " 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666, 3.4666,\n", + " 3.4666, 3.4666, 2.7610, 2.1289, 1.5494, 1.0078, 0.4938]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9953, 0.9943, 0.9912, 0.9949, 0.9935, 0.9952, 0.9979, 0.9978, 0.9969,\n", + " 0.9995, 0.9981, 0.9966, 0.9987, 0.9945, 0.9906, 0.9946, 0.9983, 0.9985,\n", + " 0.9955, 0.9990, 0.9996, 0.9997, 0.9998, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.6050, 0.6374, 0.5963, 0.5026, 0.3710, 0.2118])\n", + "----------------------------------------\n", + "26 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455,\n", + " 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455, 3.9455,\n", + " 3.9455, 3.2399, 2.6078, 2.0283, 1.4867, 0.9727, 0.4789]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9972, 0.9965, 0.9948, 0.9969, 0.9961, 0.9970, 0.9987, 0.9987, 0.9981,\n", + " 0.9996, 0.9989, 0.9980, 0.9991, 0.9967, 0.9943, 0.9967, 0.9989, 0.9991,\n", + " 0.9990, 0.9995, 0.9998, 0.9998, 0.9999, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([0.7993, 0.8317, 0.7906, 0.6969, 0.5653, 0.4061, 0.2267])\n", + "----------------------------------------\n", + "1 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134,\n", + " 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134, 4.4134,\n", + " 3.7078, 3.0757, 2.4962, 1.9546, 1.4406, 0.9468, 0.4679]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9972, 0.9966, 0.9950, 0.9970, 0.9963, 0.9971, 0.9987, 0.9987, 0.9982,\n", + " 0.9997, 0.9989, 0.9980, 0.9992, 0.9968, 0.9945, 0.9968, 0.9989, 0.9991,\n", + " 0.9991, 0.9996, 0.9998, 0.9998, 0.9999, 1.0000, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.0046, 1.0370, 0.9959, 0.9022, 0.7706, 0.6114, 0.4320, 0.2377])\n", + "----------------------------------------\n", + "1 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731,\n", + " 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.8731, 4.1675,\n", + " 3.5355, 2.9560, 2.4143, 1.9003, 1.4065, 0.9276, 0.4597]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9973, 0.9967, 0.9951, 0.9971, 0.9964, 0.9972, 0.9988, 0.9988, 0.9983,\n", + " 0.9997, 0.9989, 0.9981, 0.9992, 0.9969, 0.9946, 0.9969, 0.9990, 0.9992,\n", + " 0.9992, 0.9996, 0.9998, 0.9998, 0.9999, 1.0000, 0.9986],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.2181, 1.2505, 1.2093, 1.1156, 0.9841, 0.8249, 0.6455, 0.4512, 0.2459])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "15 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267,\n", + " 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 5.3267, 4.6211, 3.9891,\n", + " 3.4096, 2.8680, 2.3539, 1.8601, 1.3812, 0.9133, 0.4536]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9984, 0.9980, 0.9971, 0.9982, 0.9979, 0.9983, 0.9992, 0.9993, 0.9990,\n", + " 0.9998, 0.9993, 0.9989, 0.9995, 0.9982, 0.9968, 0.9991, 0.9997, 0.9997,\n", + " 0.9996, 0.9998, 0.9999, 0.9999, 0.9999, 1.0000, 0.9985],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.4377, 1.4701, 1.4289, 1.3352, 1.2036, 1.0445, 0.8651, 0.6708, 0.4655,\n", + " 0.2520])\n", + "----------------------------------------\n", + "14 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758,\n", + " 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.7758, 5.0702, 4.4382, 3.8587,\n", + " 3.3171, 2.8030, 2.3092, 1.8303, 1.3624, 0.9027, 0.4491]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9988, 0.9984, 0.9990, 0.9988, 0.9990, 0.9995, 0.9996, 0.9994,\n", + " 0.9999, 0.9996, 0.9993, 0.9997, 0.9990, 0.9990, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.6618, 1.6942, 1.6530, 1.5593, 1.4277, 1.2686, 1.0892, 0.8949, 0.6896,\n", + " 0.4761, 0.2565])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0056, grad_fn=) , base rewards= tensor([6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 6.2209,\n", + " 6.2209, 6.2209, 6.2209, 6.2209, 6.2209, 5.5156, 4.8837, 4.3043, 3.7627,\n", + " 3.2487, 2.7549, 2.2760, 1.8081, 1.3484, 0.8948, 0.4457]) return= 163476.0224004586\n", + "probs of actions: tensor([9.9908e-01, 9.9883e-01, 9.9843e-01, 9.9899e-01, 7.8089e-04, 9.9918e-01,\n", + " 9.9949e-01, 9.9957e-01, 9.9941e-01, 9.9986e-01, 9.9962e-01, 9.9937e-01,\n", + " 9.9969e-01, 9.9901e-01, 9.9912e-01, 9.9968e-01, 9.9988e-01, 9.9989e-01,\n", + " 9.9982e-01, 9.9987e-01, 9.9993e-01, 9.9994e-01, 9.9993e-01, 9.9999e-01,\n", + " 9.9840e-01], grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6925, 0.5934, 0.6327, 0.6528, 0.6630,\n", + " 0.6681, 0.6706, 0.6719, 0.6726, 0.6729, 0.6730, 0.6731, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([1.8893, 1.9217, 1.8805, 1.7868, 1.6552, 1.4961, 1.3167, 1.1224, 0.9171,\n", + " 0.7036, 0.4840, 0.2599])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645, 6.6645,\n", + " 6.6645, 6.6645, 6.6645, 6.6645, 5.9590, 5.3270, 4.7475, 4.2059, 3.6919,\n", + " 3.1981, 2.7192, 2.2513, 1.7916, 1.3379, 0.8889, 0.4432]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9990, 0.9989, 0.9991, 0.9996, 0.9996, 0.9994,\n", + " 0.9999, 0.9996, 0.9994, 0.9997, 0.9991, 0.9992, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.1194, 2.1518, 2.1106, 2.0169, 1.8853, 1.7261, 1.5467, 1.3524, 1.1471,\n", + " 0.9336, 0.7141, 0.4899, 0.2624])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0079, grad_fn=) , base rewards= tensor([7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057, 7.1057,\n", + " 7.1057, 7.1057, 7.1057, 6.4002, 5.7682, 5.1888, 4.6472, 4.1331, 3.6393,\n", + " 3.1604, 2.6925, 2.2328, 1.7792, 1.3301, 0.8844, 0.4413]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9991, 0.9989, 0.9991, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9996, 0.9994, 0.9997, 0.9991, 0.9992, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.3513, 2.3837, 2.3425, 2.2488, 2.1172, 1.9581, 1.7787, 1.5844, 1.3791,\n", + " 1.1656, 0.9460, 0.7219, 0.4944, 0.2643])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0087, grad_fn=) , base rewards= tensor([7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454, 7.5454,\n", + " 7.5454, 7.5454, 6.8400, 6.2080, 5.6286, 5.0870, 4.5730, 4.0792, 3.6003,\n", + " 3.1324, 2.6727, 2.2190, 1.7700, 1.3243, 0.8811, 0.4398]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9989, 0.9986, 0.9991, 0.9990, 0.9991, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9997, 0.9994, 0.9997, 0.9992, 0.9993, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.5846, 2.6170, 2.5759, 2.4822, 2.3506, 2.1914, 2.0120, 1.8177, 1.6124,\n", + " 1.3989, 1.1794, 0.9552, 0.7277, 0.4977, 0.2658])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0089, grad_fn=) , base rewards= tensor([7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837, 7.9837,\n", + " 7.9837, 7.2786, 6.6467, 6.0673, 5.5258, 5.0118, 4.5180, 4.0390, 3.5712,\n", + " 3.1114, 2.6578, 2.2087, 1.7630, 1.3199, 0.8786, 0.4388]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9990, 0.9986, 0.9991, 0.9990, 0.9992, 0.9996, 0.9996, 0.9995,\n", + " 0.9999, 0.9997, 0.9995, 0.9997, 0.9993, 0.9993, 0.9997, 0.9999, 0.9999,\n", + " 0.9998, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([2.8190, 2.8514, 2.8103, 2.7166, 2.5850, 2.4258, 2.2464, 2.0521, 1.8468,\n", + " 1.6334, 1.4138, 1.1897, 0.9622, 0.7321, 0.5002, 0.2668])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0101, grad_fn=) , base rewards= tensor([8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209, 8.4209,\n", + " 7.7162, 7.0845, 6.5052, 5.9637, 5.4497, 4.9559, 4.4770, 4.0091, 3.5494,\n", + " 3.0958, 2.6467, 2.2010, 1.7579, 1.3166, 0.8768, 0.4380]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9992, 0.9990, 0.9987, 0.9992, 0.9991, 0.9992, 0.9996, 0.9997, 0.9995,\n", + " 0.9999, 0.9997, 0.9995, 0.9998, 0.9993, 0.9994, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9984],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.0542, 3.0866, 3.0455, 2.9518, 2.8202, 2.6610, 2.4816, 2.2874, 2.0821,\n", + " 1.8686, 1.6490, 1.4249, 1.1974, 0.9673, 0.7354, 0.5020, 0.2676])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0108, grad_fn=) , base rewards= tensor([8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.8568, 8.1528,\n", + " 7.5215, 6.9424, 6.4010, 5.8871, 5.3933, 4.9144, 4.4465, 3.9868, 3.5332,\n", + " 3.0841, 2.6384, 2.1953, 1.7540, 1.3142, 0.8754, 0.4374]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9987, 0.9992, 0.9991, 0.9992, 0.9996, 0.9997, 0.9996,\n", + " 0.9999, 0.9997, 0.9996, 0.9998, 0.9994, 0.9994, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 0.9999, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.2900, 3.3224, 3.2812, 3.1876, 3.0560, 2.8968, 2.7175, 2.5232, 2.3179,\n", + " 2.1044, 1.8848, 1.6607, 1.4332, 1.2031, 0.9712, 0.7378, 0.5034, 0.2682])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0117, grad_fn=) , base rewards= tensor([9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 9.2906, 8.5882, 7.9578,\n", + " 7.3790, 6.8378, 6.3239, 5.8302, 5.3513, 4.8834, 4.4237, 3.9701, 3.5210,\n", + " 3.0754, 2.6322, 2.1909, 1.7511, 1.3123, 0.8743, 0.4369]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9991, 0.9988, 0.9992, 0.9991, 0.9993, 0.9996, 0.9997, 0.9996,\n", + " 0.9999, 0.9997, 0.9996, 0.9998, 0.9994, 0.9995, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.5261, 3.5585, 3.5174, 3.4238, 3.2922, 3.1331, 2.9537, 2.7594, 2.5541,\n", + " 2.3406, 2.1211, 1.8969, 1.6694, 1.4394, 1.2075, 0.9741, 0.7397, 0.5045,\n", + " 0.2687])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0138, grad_fn=) , base rewards= tensor([9.7209, 9.7209, 9.7209, 9.7209, 9.7209, 9.7209, 9.0218, 8.3929, 7.8149,\n", + " 7.2740, 6.7604, 6.2667, 5.7879, 5.3200, 4.8603, 4.4067, 3.9577, 3.5120,\n", + " 3.0688, 2.6275, 2.1877, 1.7489, 1.3109, 0.8735, 0.4366]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9991, 0.9989, 0.9993, 0.9992, 0.9993, 0.9997, 0.9997, 0.9996,\n", + " 0.9999, 0.9998, 0.9996, 0.9998, 0.9995, 0.9995, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 0.9999, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.7624, 3.7948, 3.7538, 3.6602, 3.5288, 3.3696, 3.1903, 2.9960, 2.7907,\n", + " 2.5772, 2.3577, 2.1335, 1.9060, 1.6760, 1.4441, 1.2107, 0.9763, 0.7411,\n", + " 0.5053, 0.2690])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0163, grad_fn=) , base rewards= tensor([10.1448, 10.1448, 10.1448, 10.1448, 10.1448, 9.4522, 8.8264, 8.2499,\n", + " 7.7097, 7.1964, 6.7029, 6.2242, 5.7563, 5.2967, 4.8431, 4.3940,\n", + " 3.9483, 3.5052, 3.0639, 2.6241, 2.1853, 1.7473, 1.3099, 0.8730,\n", + " 0.4364]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9993, 0.9992, 0.9989, 0.9993, 0.9992, 0.9993, 0.9997, 0.9997, 0.9996,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9995, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([3.9987, 4.0311, 3.9903, 3.8969, 3.7655, 3.6064, 3.4271, 3.2328, 3.0276,\n", + " 2.8141, 2.5945, 2.3704, 2.1429, 1.9128, 1.6809, 1.4475, 1.2131, 0.9779,\n", + " 0.7421, 0.5058, 0.2692])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0183, grad_fn=) , base rewards= tensor([10.5560, 10.5560, 10.5560, 10.5560, 9.8764, 9.2568, 8.6832, 8.1445,\n", + " 7.6319, 7.1387, 6.6602, 6.1924, 5.7328, 5.2792, 4.8302, 4.3845,\n", + " 3.9413, 3.5001, 3.0602, 2.6214, 2.1835, 1.7461, 1.3091, 0.8725,\n", + " 0.4362]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9992, 0.9990, 0.9993, 0.9993, 0.9994, 0.9997, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.2346, 4.2670, 4.2265, 4.1334, 4.0022, 3.8433, 3.6640, 3.4698, 3.2646,\n", + " 3.0511, 2.8315, 2.6074, 2.3799, 2.1499, 1.9179, 1.6846, 1.4502, 1.2149,\n", + " 0.9791, 0.7429, 0.5063, 0.2694])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0216, grad_fn=) , base rewards= tensor([10.9428, 10.9428, 10.9428, 10.2887, 9.6813, 9.1136, 8.5777, 8.0665,\n", + " 7.5741, 7.0958, 6.6283, 6.1687, 5.7152, 5.2662, 4.8205, 4.3773,\n", + " 3.9361, 3.4962, 3.0575, 2.6195, 2.1821, 1.7451, 1.3085, 0.8722,\n", + " 0.4360]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9990, 0.9994, 0.9993, 0.9995, 0.9997, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.4695, 4.5019, 4.4621, 4.3697, 4.2389, 4.0802, 3.9011, 3.7069, 3.5017,\n", + " 3.2883, 3.0687, 2.8446, 2.6171, 2.3870, 2.1551, 1.9218, 1.6873, 1.4521,\n", + " 1.2163, 0.9801, 0.7435, 0.5066, 0.2696])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0235, grad_fn=) , base rewards= tensor([11.2821, 11.2821, 10.6776, 10.0943, 9.5383, 9.0082, 8.4997, 8.0087,\n", + " 7.5311, 7.0639, 6.6045, 6.1510, 5.7020, 5.2564, 4.8132, 4.3720,\n", + " 3.9322, 3.4934, 3.0554, 2.6180, 2.1811, 1.7445, 1.3081, 0.8719,\n", + " 0.4359]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9991, 0.9994, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997,\n", + " 0.9999, 0.9998, 0.9997, 0.9999, 0.9997, 0.9997, 0.9998, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.7023, 4.7347, 4.6963, 4.6051, 4.4751, 4.3169, 4.1381, 3.9441, 3.7389,\n", + " 3.5255, 3.3060, 3.0819, 2.8544, 2.6243, 2.3924, 2.1590, 1.9246, 1.6894,\n", + " 1.4536, 1.2173, 0.9807, 0.7439, 0.5069, 0.2697])\n", + "----------------------------------------\n", + "0 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0243, grad_fn=) , base rewards= tensor([11.5326, 11.0213, 10.4848, 9.9519, 9.4330, 8.9302, 8.4418, 7.9656,\n", + " 7.4991, 7.0400, 6.5867, 6.1378, 5.6922, 5.2491, 4.8078, 4.3680,\n", + " 3.9292, 3.4912, 3.0538, 2.6169, 2.1803, 1.7439, 1.3078, 0.8718,\n", + " 0.4358]) return= 164632.33345850307\n", + "probs of actions: tensor([0.9995, 0.9994, 0.9992, 0.9995, 0.9995, 0.9996, 0.9998, 0.9998, 0.9998,\n", + " 0.9999, 0.9998, 0.9998, 0.9999, 0.9997, 0.9997, 0.9999, 0.9999, 0.9999,\n", + " 0.9999, 0.9999, 1.0000, 1.0000, 1.0000, 1.0000, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6472, 0.6601, 0.6667, 0.6699, 0.6716, 0.6724,\n", + " 0.6728, 0.6730, 0.6731, 0.6731, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732,\n", + " 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.6732, 0.7056])\n", + "finalReturns: tensor([4.9307, 4.9631, 4.9275, 4.8387, 4.7104, 4.5531, 4.3748, 4.1811, 3.9761,\n", + " 3.7628, 3.5433, 3.3192, 3.0917, 2.8617, 2.6298, 2.3964, 2.1620, 1.9268,\n", + " 1.6910, 1.4547, 1.2181, 0.9813, 0.7442, 0.5070, 0.2698])\n", + "0,[0.0001,1][1, 10000, 1, 1],1682339633 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[55690, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 164632.33345850307, 70408.33325584729, 0.024329129606485367, 0.0001, 1, 0, 'tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\\n 18, 18, 18, 18, 18, 18, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[0.0001,1][1, 10000, 1, 1],1682339633', 25, 50, 164632.33345850307, 193521.20851536895, 78111.91688437786, 135363.21866666665, 132442.06666666665, 102604.52812037412, 102604.52812037412, 120699.79187222247, 120699.79187222247, 90621.14382460734, 102604.52812037412, 120699.79187222247]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=3_000_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm.solver(print_step=100_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage lr=10^-4.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage lr=10^-4.ipynb new file mode 100644 index 0000000..40487e2 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage lr=10^-4.ipynb @@ -0,0 +1,1192 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.0001, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9931, 0.9919, 0.9949, 0.9938, 0.9933, 0.9941, 0.9932, 0.9945, 0.9943,\n", + " 0.9961, 0.9932, 0.9958, 0.9938, 0.9940, 0.9923, 0.9945, 0.9951, 0.9961,\n", + " 0.9944, 0.9934, 0.9917, 0.9916, 0.9938, 0.9936, 0.9999],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139591.33336462575\n", + "probs of actions: tensor([0.9987, 0.9985, 0.9991, 0.9989, 0.9988, 0.9989, 0.9988, 0.9990, 0.9990,\n", + " 0.9993, 0.9987, 0.9993, 0.9989, 0.9989, 0.9986, 0.9990, 0.9991, 0.9993,\n", + " 0.9990, 0.9988, 0.9984, 0.9984, 0.9989, 0.9988, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAfSUlEQVR4nO3df5BV5Z3n8feHpiWNO/I7O9jgNP6ckjGLsaNkXVNGJ+BmdpRkzIpVKdldd5i4mamN2TEFEysYTCYaJ3HKmYoZJ7L+DMExFjIxDqGGVKxKKdoMGDCRFaORbtmAARw3dLRpvvvHfS6ebm73ved20/f2vZ9X1Slvf895Ds/T6v3y/DjPUURgZmZWqQm1roCZmY0vThxmZpaLE4eZmeXixGFmZrk4cZiZWS4Ta12B0TZz5szo6OiodTXMzMaVrVu3vhERsyq5tuESR0dHB11dXbWuhpnZuCLpF5Ve66EqMzPLxYnDzMxyceIwM7NcnDjMzCwXJw4zM8ul4VZVVevm9TtYu2UP/RG0SFx70Vy+tOS8WlfLzKzuOHFQSBoPPfPasZ/7I4797ORhZjaQh6qAtVv25IqbmTUzJw4KPYw8cTOzZubEYWZmuThxmJlZLk4cwNS21lxxM7Nm5sQBSPniZmbNzIkDOHS4L1fczKyZOXEAU4YYkhoqbmbWzMomDklrJO2TtDMTWydpezpelbQ9c26lpN2SdklanIlfIGlHOneXVBgIkjQp3W+3pC2SOjJllkl6KR3LRqvRg/X1H80VNzNrZpX0OO4DrsgGIuKaiFgQEQuA7wKPAUg6F1gKzE9lviGpJRW7G1gOnJWO4j2vBw5GxJnAncDt6V7TgVXARcCFwCpJ06pqZRm/fqc/V9zMrJmVTRwR8RRwoNS51Gv4z8DaFLoK+E5EvB0RrwC7gQslzQZOiYinIyKAB4AlmTL3p8+PApen+y4GNkXEgYg4CGxiUAIzM7OxN9I5jkuAX0bES+nndiC7T0d3irWnz4PjA8pExBHgTWDGMPc6jqTlkrokde3fv39EDTIzs+GNNHFcy7u9DYBSC1hjmHi1ZQYGI+6JiM6I6Jw1q6J3rZuZWZWqThySJgIfB9Zlwt3A3MzPc4DXU3xOifiAMumeUygMjQ11r1E31OMafozDzOx4I+lx/D7wYkRkh6A2AEvTSql5FCbBn42IvcBbkham+YvrgMczZYorpq4GNqd5kI3AIknT0qT4ohQbdUNtZegtDs3MjlfJcty1wNPAOZK6JV2fTi1l4DAVEfEC8AjwU+CfgE9HRHFp0g3AtyhMmL8MPJni9wIzJO0GPgusSPc6ANwKPJeO1Sk2ptZv6xnrP9LMrK4pGmzr8M7Ozujq6spVpmPFE0Oemza5lW1fWDTSapmZ1TVJWyOis5Jr/eR4GQe97YiZ2QBOHGZmlosTh5mZ5eLEUca0yd7o0Mwsy4mjjFV/OL/WVTAzqytOHGUsOb/kLidmZk3LiaMMP8dhZjaQE0cZd2zcVesqmJnVFSeOMnoO9da6CmZmdcWJw8zMcnHiMDOzXJw4zMwsFycOMzPLxYmjjEkT/SsyM8vyt2IZ7xw5WusqmJnVFSeOMk6d2lbrKpiZ1RUnjjI6ZjhxmJllOXGU8eOXx/xttWZmdc2Jw8zMcnHiMDOzXJw4zMwsl7KJQ9IaSfsk7RwU/zNJuyS9IOmrKdYhqVfS9nR8M3P9BZJ2SNot6S5JSvFJktal+BZJHZkyyyS9lI5lo9ZqMzOr2sQKrrkP+FvggWJA0oeBq4D3RcTbkt6buf7liFhQ4j53A8uBZ4DvA1cATwLXAwcj4kxJS4HbgWskTQdWAZ1AAFslbYiIg/maaGZmo6lsjyMingIGLy26AbgtIt5O1+wb7h6SZgOnRMTTEREUktCSdPoq4P70+VHg8tQbWQxsiogDKVlsopBszMyshqqd4zgbuCQNLf1I0gcy5+ZJ2pbil6RYO9CduaY7xYrn9gBExBHgTWBGNl6izACSlkvqktS1f//+KptkZmaVqGSoaqhy04CFwAeARySdDuwFTouIX0m6AFgvaT6gEveI9M+hzg1XZmAw4h7gHoDOzs6S15iZ2eiotsfRDTwWBc8CR4GZEfF2RPwKICK2Ai9T6J10A3My5ecAr2fuNRdA0kRgCoWhsWPxEmXMzKxGqk0c64HLACSdDZwEvCFplqSWFD8dOAv4eUTsBd6StDDNX1wHPJ7utQEorpi6Gtic5kE2AoskTZM0DViUYmZmVkNlh6okrQUuBWZK6qaw0mkNsCYt0X0HWBYRIelDwGpJR4B+4FMRUZxYv4HCCq02Cqupnkzxe4EHJe2m0NNYChARByTdCjyXrluduZeZmdVI2cQREdcOceqTJa79LvDdIe7TBfxeifhvgE8MUWYNhSRlZmZ1wk+Om5lZLk4cZmaWixOHmZnl4sRhZma5OHGYmVkuThwVWL+tp9ZVMDOrG04cFfjiP75Q6yqYmdUNJ44KHDzcV+sqmJnVDScOMzPLxYmjAlPbWmtdBTOzuuHEUYFbrpxf6yqYmdUNJ44KdP3CeyuamRU5cVRg7ZY95S8yM2sSThwV6A+/VNDMrMiJowIq9RJbM7Mm5cRRgdYJzhxmZkVOHBV4p99DVWZmRU4cZmaWixNHBdpa/WsyMyvyN2IFPMNhZvYuJ44KHO47WusqmJnVDScOMzPLpWzikLRG0j5JOwfF/0zSLkkvSPpqJr5S0u50bnEmfoGkHencXVLh6QhJkyStS/EtkjoyZZZJeikdy0alxWZmNiKV9DjuA67IBiR9GLgKeF9EzAf+KsXPBZYC81OZb0hqScXuBpYDZ6WjeM/rgYMRcSZwJ3B7utd0YBVwEXAhsErStKpaaWZmo6Zs4oiIp4DBu/zdANwWEW+na/al+FXAdyLi7Yh4BdgNXChpNnBKRDwdEQE8ACzJlLk/fX4UuDz1RhYDmyLiQEQcBDYxKIGZmdnYq3aO42zgkjS09CNJH0jxdiC7I2B3irWnz4PjA8pExBHgTWDGMPc6jqTlkrokde3fv7/KJpmZWSWqTRwTgWnAQuAm4JHUSyi1cjWGiVNlmYHBiHsiojMiOmfNmlWu7mZmNgLVJo5u4LEoeBY4CsxM8bmZ6+YAr6f4nBJxsmUkTQSmUBgaG+peZmZWQ9UmjvXAZQCSzgZOAt4ANgBL00qpeRQmwZ+NiL3AW5IWpp7JdcDj6V4bgOKKqauBzWkeZCOwSNK0NCm+KMXMzKyGJpa7QNJa4FJgpqRuCiud1gBr0hLdd4Bl6cv+BUmPAD8FjgCfjoj+dKsbKKzQagOeTAfAvcCDknZT6GksBYiIA5JuBZ5L162OCL+Kz8ysxsomjoi4dohTnxzi+i8DXy4R7wJ+r0T8N8AnhrjXGgpJyszM6oSfHDczs1ycOMzMLBcnDjMzy8WJw8zMcnHiACZN9K/BzKxS/sYE3jni922YmVXKiYMh9jExM7OSnDjMzCwXJw4zM8vFiQNon9pW9pqb1+8Yg5qYmdU/Jw7gpsXnlL3moWdeG4OamJnVPycOYMn5Jd8PdZz123pOcE3MzOqfE0cOd2zcVesqmJnVnBNHDq8f6q11FczMas6JI4epk1trXQUzs5pz4sgh/KSgmZkTB1S+1PbN3r4TXBMzs/rnxAE8vKWypbanVvC8h5lZo3PioPIhqEqe9zAza3ROHDlU+ryHmVkjc+IATmpRratgZjZulE0cktZI2idpZyZ2i6QeSdvT8dEU75DUm4l/M1PmAkk7JO2WdJckpfgkSetSfIukjkyZZZJeSseyUW15xsQJThxmZpWqpMdxH3BFifidEbEgHd/PxF/OxD+Vid8NLAfOSkfxntcDByPiTOBO4HYASdOBVcBFwIXAKknTKm9a5Q73VfYiJ290aGZWQeKIiKeAAyP5QyTNBk6JiKcjIoAHgCXp9FXA/enzo8DlqTeyGNgUEQci4iCwidIJbMw87I0OzcxGNMfxp5J+koaysj2BeZK2SfqRpEtSrB3ozlzTnWLFc3sAIuII8CYwIxsvUWYAScsldUnq2r9/f+6GTG2r7IlwP/9nZlZ94rgbOANYAOwFvpbie4HTIuJ84LPAtyWdApSaRCh+Dw91brgyA4MR90REZ0R0zpo1q+JGFN1y5fzcZczMmlVViSMifhkR/RFxFPh7CnMQRMTbEfGr9Hkr8DJwNoXewpzMLeYAr6fP3cBcAEkTgSkUhsaOxUuUGVVeZmtmVrmqEkeasyj6GLAzxWdJakmfT6cwCf7ziNgLvCVpYZq/uA54PJXfABRXTF0NbE7zIBuBRZKmpaGwRSlmZmY1NLHcBZLWApcCMyV1U1jpdKmkBRSGjl4F/iRd/iFgtaQjQD/wqYgoTqzfQGGFVhvwZDoA7gUelLSbQk9jKUBEHJB0K/Bcum515l41s35bj3soZtbUFA225WtnZ2d0dXXlLtex4omKrmuf2saPV1yW+/5mZvVM0taI6KzkWj85npNf5mRmzc6JIyfvkGtmzc6JIyfvkGtmzc6Jw8zMcnHiSCr9RdyxcdcJrYeZWb1z4ki+fs2Ciq7z5LiZNTsnjqTSZzOmVLivlZlZo3LiyOmdI/21roKZWU05ceRU6bs7zMwalRNHFdZv66l1FczMasaJI8mTDFY+tsPJw8yalhNHkmeZbW9fv5flmlnTcuJI8i6z9bJcM2tWThxJ3mW23rPKzJqVE0eiUi+qHcaHfzf/K2rNzBqBE0dy6HBfrut/+OL+E1QTM7P65sSR5B166vEch5k1KSeOJO926TlHtszMGoYTR5L3PeKBHwQ0s+bkxDECfpbDzJqRE8cI+FkOM2tGThwj4Gc5zKwZlU0cktZI2idpZyZ2i6QeSdvT8dHMuZWSdkvaJWlxJn6BpB3p3F1S4ckJSZMkrUvxLZI6MmWWSXopHctGrdWjxO8fN7NmVEmP4z7gihLxOyNiQTq+DyDpXGApMD+V+YaklnT93cBy4Kx0FO95PXAwIs4E7gRuT/eaDqwCLgIuBFZJmpa7hSfQHRt3eYLczJpO2cQREU8BByq831XAdyLi7Yh4BdgNXChpNnBKRDwdEQE8ACzJlLk/fX4UuDz1RhYDmyLiQEQcBDZROoHVTM+hXu+Ua2ZNZyRzHH8q6SdpKKvYE2gH9mSu6U6x9vR5cHxAmYg4ArwJzBjmXseRtFxSl6Su/fvH9olu75RrZs2m2sRxN3AGsADYC3wtxUs9FxfDxKstMzAYcU9EdEZE56xZY7+HlFdXmVkzqSpxRMQvI6I/Io4Cf09hDgIKvYK5mUvnAK+n+JwS8QFlJE0EplAYGhvqXnXHq6vMrJlUlTjSnEXRx4DiiqsNwNK0UmoehUnwZyNiL/CWpIVp/uI64PFMmeKKqauBzWkeZCOwSNK0NBS2KMXqSltri1dXmVlTmVjuAklrgUuBmZK6Kax0ulTSAgpDR68CfwIQES9IegT4KXAE+HRE9Kdb3UBhhVYb8GQ6AO4FHpS0m0JPY2m61wFJtwLPpetWR0Slk/RjQsBXPn5e7u1KzMzGMxX+ct84Ojs7o6urq6qyHSueyF3m1dv+oKo/y8ysnkjaGhGdlVzrJ8dH6Ob1O2pdBTOzMeXEMUIPPfOak4eZNRUnjoyTT2opf1EJDz/z2ijXxMysfjlxZHz5Y+dVVc7v5jCzZuLEkTGS1VE3rtvu5GFmTcGJY5QE8L/+4XknDzNreE4cGSP90u8/Gt63yswanhNHxi0bXhjxPbxvlZk1OieOjEO9fSO+h/etMrNG58QxyrxvlZk1OieOjMmtI/91fPEfX/AEuZk1NCeOjEmt1T0AmHXwcB83rtvup8nNrGE5cWQcOjzyOQ4oLM19+JnX3PMws4bkxJExmhPbAV6aa2YNyYkjY7QntnsO9dKx4gnOX/0D9z7MrGE4cWScqBcyHTzcx02P+qlyM2sMThxjpK/fT5WbWWNw4hhDfqrczBpB2XeO2+iZ0tbKxbdtpudQLy0S/RG0T23jpsXn+L3lZjZuOHGMkQmCf/1N37FtTfrTu957DvWy8rHCMx9OHmY2HnioaoxMnCCORulzvX39nv8ws3GjbOKQtEbSPkk7S5z7c0khaWb6uUNSr6Tt6fhm5toLJO2QtFvSXZKU4pMkrUvxLZI6MmWWSXopHctGpcU18k7/EFkj8fyHmY0XlfQ47gOuGByUNBf4CDD4hdsvR8SCdHwqE78bWA6clY7iPa8HDkbEmcCdwO3p/tOBVcBFwIXAKknTKmzXuONddc1svCibOCLiKeBAiVN3Ap+j8JD0sCTNBk6JiKcjIoAHgCXp9FXA/enzo8DlqTeyGNgUEQci4iCwiRIJbLRdfMb0E/1HHKettcW76prZuFHVHIekK4GeiHi+xOl5krZJ+pGkS1KsHejOXNOdYsVzewAi4gjwJjAjGy9RZnB9lkvqktS1f//+app0zMN//MERlc9r2uRWvvLx8zwxbmbjRu5VVZImA58HFpU4vRc4LSJ+JekCYL2k+YBKXFvsqQx1brgyA4MR9wD3AHR2dpbtAdWLqW2tbPtCqV+jmVn9qqbHcQYwD3he0qvAHOBfJP12RLwdEb8CiIitwMvA2RR6C3My95gDvJ4+dwNzASRNBKZQGBo7Fi9RpiHccuX8WlfBzCy33D2OiNgBvLf4c0oenRHxhqRZwIGI6Jd0OoVJ8J9HxAFJb0laCGwBrgP+Jt1iA7AMeBq4GtgcESFpI/CXmQnxRcDKqlpZh4rvjLr4ts28fqiXUwc9CLh+Ww93bNxV8pyZWS2VTRyS1gKXAjMldQOrIuLeIS7/ELBa0hGgH/hURBQn1m+gsEKrDXgyHQD3Ag9K2k2hp7EUICWbW4Hn0nWrM/ca9/qOwk2PPk9f//EPAgKsfGwHvX39x51z8jCzWlPEuJkSqEhnZ2d0dXWN6B4dK54YpdrkN7WtlZMnTaSnxHMd7VPb+PGKy2pQKzNrdJK2RkRnJdd6y5E6c6j33W1JBvNDgmZWD5w4xpHiQ4I3r9/B2i176I+gReLai+bypSXn1bh2ZtYsnDjGkZ5DvZz1F0/Qd/TdWH8EDz1TeHjfycPMxoI3OSzhkwtPq3UVhpRNGllrt+wpGV+/rYeLb9vMvBVPcPFtm/0WQjMbMfc4SvjSkvOO/S1+vChu055dxjulrZVfv3Ok5Motr84ys2q5x9EgWiRuXr+DG9dtp+dQL0Fhor1v0K683sLdzEbKPY6GERX3krw6y8xGwoljCJMmTuDtI0NMKNShMq/7OM75q3/AocN9VT2VPpKn2uvxifh6rJNZPXPiGMLtf/Q+PrNue62rcUIEcPBw4VmRPPMe67f1cMuGFwY8Z5K3fL09EV+vdXIis3rmOY4hNNP/qL19/Xxm3fZhV10Vv2BLPZxY6bzJHRt3HfuCzlv2RKm3OhV/z8V5qmIi82o4qydOHHbMcF9Spb5gB5ctZ6i5lVrOudRbneotkZmV4qEqG6C3r58bH9nOjeu2DxgmKZcYJpR6e8ogp05tK3mfWr42t5I6jeXQUb0lMrNSnDiGcfEZ0/nxyw2zIW/Fivte9hzq5cZ12+n6xQFapGPPipRyNAqbQxavay/xBXvT4nMGzCfA8K/NHYsv7HJ1Gus5kHpMrmaDeahqGA//8Qc5670n17oaNRXAQ8+8NmzSyCpeV2rYa8n57Xzl4+fRPrUNUdjtd6jX5o7VWH+5OuUdOhrpk/o3LT6HttaWATG/k97qjbdVr0Att1kf76a2tbJ91buvxy32InoO9ZbsnWTPl5J3a/mR9lrmrXii9PuKgb++ZsGAew3unUDhSz/vO+VL1Rko247xshprvNSz2eTZVt2Jo4z123oadlmuvWuCCsNt4t0X2xdj9eo9LWLGb72HnkO9A+pdVIxNbWtFgkOH+5iSPh883DegzLTJraz6w/nHJcJSSf7DvzuL7z2/d8jt/wffa7htcIpOPqmFj72/nR++uL/kXyqAAfcotuc9rRPozWzgdvJJLXz5Y4XNPgcvHZ+cXrt5OF0/uXUCk1pbjnueaajEVmo5erGt2fqNNBlWmlgH/16Lv5Nq/3wnjlFMHBfftrmiFUNm413LBPG1T/y7Y1+Sg3tPtdI6QSCOSzZDKZVEK/pzWsQ1H5jLd7f2HNdr/KML2ln37B76SvxNYoIKv7ts/fL0NMsl1lL3Kvfvp5qerhPHKCaO4YYqzBpR+9Q2Dr9z5NhDos1kqF5mucUhpVQyrFppgh58r0r+Qpt3WNdvABxFUye3NuX/QNa8mrmHPdTQZN6kAUP/HsvN4w11r3krnjg2DFXJ8uwTuYTbiWMY67f18P9+c6TW1TCzcahFKjlPVO1QWnF14Y3rtjP5pBZ+/c7wvZQTuYTbiWMYd2zcVXJM08ysnP6IAQtrir2WkX6jBJRNGsAJXcLt5ziG4ad1zWy8OpFLnMsmDklrJO2TtLPEuT+XFJJmZmIrJe2WtEvS4kz8Akk70rm7JCnFJ0lal+JbJHVkyiyT9FI6lo24tTn5aV0zG69O5MaYlfQ47gOuGByUNBf4CPBaJnYusBSYn8p8Q1LxMdi7geXAWeko3vN64GBEnAncCdye7jUdWAVcBFwIrJI0LV/zRmaop3hbKtiXycyslv7isZ+csHuXTRwR8RRQasOmO4HPMXDI7irgOxHxdkS8AuwGLpQ0GzglIp6OwvrfB4AlmTL3p8+PApen3shiYFNEHIiIg8AmSiSwE2mo7Sg87WFm9e5w34l7EV1Vk+OSrgR6IuL5NOJU1A48k/m5O8X60ufB8WKZPQARcUTSm8CMbLxEmcH1WU6hN8Npp51WTZOGtOT89uPGCvMupTMzayS5J8clTQY+D3yh1OkSsRgmXm2ZgcGIeyKiMyI6Z82aVeqSUVVqCMvMrFlUs6rqDGAe8LykV4E5wL9I+m0KvYK5mWvnAK+n+JwScbJlJE0EplAYGhvqXjU3eAirrdWL08yseeQeqoqIHcB7iz+n5NEZEW9I2gB8W9LXgVMpTII/GxH9kt6StBDYAlwH/E26xQZgGfA0cDWwOSJC0kbgLzMT4ouAldU08kQYPIR18/odPPzMa96exMwaXiXLcddS+FI/R1K3pOuHujYiXgAeAX4K/BPw6YgoPqlyA/AtChPmLwNPpvi9wAxJu4HPAivSvQ4AtwLPpWN1itWlLy05jzuvWXCsFzK1rZVpk1sRfljGzBqLNzkcQ4UNzX4yYBtoM7MT4dXb/iDX9d7ksE6VWqFVrcF79pd7R0Jxa+gfvrg/1zsDhtqFM+/Om/VstF7A1MjG88uXxnPd65V7HA1qtP5naZYvVX+5WLPz+zicOEaVv1TNGp+HqmxUjeYQm5mNf17wY2ZmuThxmJlZLk4cZmaWixOHmZnl4sRhZma5NNxyXEn7gV+M4BYzgTdGqTrjRbO1udnaC25zsxhJm38nIiraXrzhEsdISeqqdC1zo2i2Njdbe8FtbhZj1WYPVZmZWS5OHGZmlosTx/HuqXUFaqDZ2txs7QW3uVmMSZs9x2FmZrm4x2FmZrk4cZiZWS5OHImkKyTtkrRb0opa1ycPSXMl/VDSzyS9IOl/pvh0SZskvZT+OS1TZmVq6y5JizPxCyTtSOfukqQUnyRpXYpvkdQx5g0tQVKLpG2Svpd+bug2S5oq6VFJL6Z/3x9sgjbfmP673ilpraT3NFqbJa2RtE/SzkxsTNooaVn6M16StKyiCkdE0x9AC4X3oJ8OnAQ8D5xb63rlqP9s4P3p828B/wc4F/gqsCLFVwC3p8/npjZOAualtrekc88CHwRE4b3w/zHF/wfwzfR5KbCu1u1Odfks8G3ge+nnhm4zcD/w39Pnk4CpjdxmoB14BWhLPz8C/JdGazPwIeD9wM5M7IS3EZgO/Dz9c1r6PK1sfWv9P0I9HOkXvTHz80pgZa3rNYL2PA58BNgFzE6x2cCuUu0DNqbfwWzgxUz8WuDvstekzxMpPJ2qGrdzDvDPwGW8mzgats3AKRS+RDUo3shtbgf2pC+2icD3gEWN2Gagg4GJ44S3MXtNOvd3wLXl6uqhqoLif5xF3Sk27qQu6PnAFuDfRsRegPTP96bLhmpve/o8OD6gTEQcAd4EZpyQRlTur4HPAUczsUZu8+nAfuB/p+G5b0k6mQZuc0T0AH8FvAbsBd6MiB/QwG3OGIs2VvXd58RRoBKxcbdOWdK/Ab4LfCYi/nW4S0vEYpj4cGVqQtJ/AvZFxNZKi5SIjas2U/ib4vuBuyPifODXFIYwhjLu25zG9a+iMCRzKnCypE8OV6REbFy1uQKj2caq2u7EUdANzM38PAd4vUZ1qYqkVgpJ4+GIeCyFfylpdjo/G9iX4kO1tzt9HhwfUEbSRGAKcGD0W1Kxi4ErJb0KfAe4TNJDNHabu4HuiNiSfn6UQiJp5Db/PvBKROyPiD7gMeDf09htLhqLNlb13efEUfAccJakeZJOojB5tKHGdapYWjlxL/CziPh65tQGoLhKYhmFuY9ifGlaaTEPOAt4NnWH35K0MN3zukFlive6GtgcaVC0FiJiZUTMiYgOCv++NkfEJ2nsNv9fYI+kc1LocuCnNHCbKQxRLZQ0OdX1cuBnNHabi8aijRuBRZKmpd7dohQb3lhPANXrAXyUwmqkl4HP17o+Oev+Hyh0L38CbE/HRymMYf4z8FL65/RMmc+ntu4irbxI8U5gZzr3t7y7u8B7gH8AdlNYuXF6rdudqfOlvDs53tBtBhYAXenf9XoKK2Eavc1fBF5M9X2QwmqihmozsJbCHE4fhV7A9WPVRuC/pfhu4L9WUl9vOWJmZrl4qMrMzHJx4jAzs1ycOMzMLBcnDjMzy8WJw8zMcnHiMDOzXJw4zMwsl/8Ps0ABR4c6AtgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(5.0962e-09, grad_fn=) , base rewards= tensor([1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936,\n", + " 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936,\n", + " 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 0.5852]) return= 148841.83344956237\n", + "probs of actions: tensor([0.9438, 0.0135, 0.9372, 0.9715, 0.9338, 0.8138, 0.9466, 0.9783, 0.9724,\n", + " 0.9158, 0.9742, 0.9542, 0.9893, 0.9777, 0.9852, 0.9560, 0.9527, 0.9816,\n", + " 0.9614, 0.9419, 0.9861, 0.9813, 0.9813, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5588, 0.5570, 0.5807, 0.5927, 0.5987, 0.6018, 0.6033, 0.6040,\n", + " 0.6044, 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.0196, 0.0232])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(5.0962e-09, grad_fn=) , base rewards= tensor([1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936,\n", + " 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936,\n", + " 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 1.1936, 0.5852]) return= 148838.58350535232\n", + "probs of actions: tensor([0.9437, 0.9863, 0.0634, 0.9723, 0.9331, 0.8130, 0.9465, 0.9783, 0.9724,\n", + " 0.9157, 0.9742, 0.9542, 0.9892, 0.9777, 0.9852, 0.9560, 0.9527, 0.9816,\n", + " 0.9614, 0.9419, 0.9861, 0.9813, 0.9813, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5833, 0.5693, 0.5869, 0.5958, 0.6003, 0.6025, 0.6037,\n", + " 0.6042, 0.6045, 0.6047, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.0196, 0.0232])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8636e-08, grad_fn=) , base rewards= tensor([1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618,\n", + " 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618,\n", + " 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.1534, 0.5681]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.0562, 0.0598, 0.0403])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8636e-08, grad_fn=) , base rewards= tensor([1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618,\n", + " 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.7618,\n", + " 1.7618, 1.7618, 1.7618, 1.7618, 1.7618, 1.1534, 0.5681]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.0562, 0.0598, 0.0403])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(4.2578e-08, grad_fn=) , base rewards= tensor([2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173,\n", + " 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173,\n", + " 2.3173, 2.3173, 2.3173, 2.3173, 1.7089, 1.1236, 0.5555]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.1055, 0.1091, 0.0896, 0.0529])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(4.2578e-08, grad_fn=) , base rewards= tensor([2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173,\n", + " 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173, 2.3173,\n", + " 2.3173, 2.3173, 2.3173, 2.3173, 1.7089, 1.1236, 0.5555]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.1055, 0.1091, 0.0896, 0.0529])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(7.7996e-08, grad_fn=) , base rewards= tensor([2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634,\n", + " 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634,\n", + " 2.8634, 2.8634, 2.8634, 2.2550, 1.6697, 1.1016, 0.5461]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.1642, 0.1678, 0.1483, 0.1116, 0.0623])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(7.7996e-08, grad_fn=) , base rewards= tensor([2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634,\n", + " 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634, 2.8634,\n", + " 2.8634, 2.8634, 2.8634, 2.2550, 1.6697, 1.1016, 0.5461]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.1642, 0.1678, 0.1483, 0.1116, 0.0623])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.2541e-07, grad_fn=) , base rewards= tensor([3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025,\n", + " 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025,\n", + " 3.4025, 3.4025, 2.7941, 2.2088, 1.6407, 1.0852, 0.5391]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.2299, 0.2335, 0.2140, 0.1773, 0.1280, 0.0693])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.2541e-07, grad_fn=) , base rewards= tensor([3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025,\n", + " 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025, 3.4025,\n", + " 3.4025, 3.4025, 2.7941, 2.2088, 1.6407, 1.0852, 0.5391]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.2299, 0.2335, 0.2140, 0.1773, 0.1280, 0.0693])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8501e-07, grad_fn=) , base rewards= tensor([3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363,\n", + " 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363,\n", + " 3.9363, 3.3279, 2.7427, 2.1746, 1.6191, 1.0730, 0.5339]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.3009, 0.3045, 0.2849, 0.2482, 0.1989, 0.1402, 0.0745])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8501e-07, grad_fn=) , base rewards= tensor([3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363,\n", + " 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363, 3.9363,\n", + " 3.9363, 3.3279, 2.7427, 2.1746, 1.6191, 1.0730, 0.5339]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.3009, 0.3045, 0.2849, 0.2482, 0.1989, 0.1402, 0.0745])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(2.5678e-07, grad_fn=) , base rewards= tensor([4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663,\n", + " 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663,\n", + " 3.8579, 3.2727, 2.7046, 2.1491, 1.6030, 1.0639, 0.5300]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.3757, 0.3793, 0.3597, 0.3230, 0.2737, 0.2150, 0.1493, 0.0784])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(2.5678e-07, grad_fn=) , base rewards= tensor([4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663,\n", + " 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663, 4.4663,\n", + " 3.8579, 3.2727, 2.7046, 2.1491, 1.6030, 1.0639, 0.5300]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.3757, 0.3793, 0.3597, 0.3230, 0.2737, 0.2150, 0.1493, 0.0784])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(3.4059e-07, grad_fn=) , base rewards= tensor([4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934,\n", + " 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.3850,\n", + " 3.7998, 3.2317, 2.6762, 2.1301, 1.5910, 1.0571, 0.5271]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.4534, 0.4570, 0.4374, 0.4007, 0.3514, 0.2927, 0.2270, 0.1561, 0.0813])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(3.4059e-07, grad_fn=) , base rewards= tensor([4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934,\n", + " 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.9934, 4.3850,\n", + " 3.7998, 3.2317, 2.6762, 2.1301, 1.5910, 1.0571, 0.5271]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.4534, 0.4570, 0.4374, 0.4007, 0.3514, 0.2927, 0.2270, 0.1561, 0.0813])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(4.3626e-07, grad_fn=) , base rewards= tensor([5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183,\n", + " 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 4.9099, 4.3247,\n", + " 3.7566, 3.2011, 2.6550, 2.1159, 1.5820, 1.0520, 0.5249]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.5333, 0.5369, 0.5173, 0.4806, 0.4313, 0.3726, 0.3069, 0.2360, 0.1612,\n", + " 0.0835])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(4.3626e-07, grad_fn=) , base rewards= tensor([5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183,\n", + " 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 5.5183, 4.9099, 4.3247,\n", + " 3.7566, 3.2011, 2.6550, 2.1159, 1.5820, 1.0520, 0.5249]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.5333, 0.5369, 0.5173, 0.4806, 0.4313, 0.3726, 0.3069, 0.2360, 0.1612,\n", + " 0.0835])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(5.4359e-07, grad_fn=) , base rewards= tensor([6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416,\n", + " 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 5.4332, 4.8480, 4.2799,\n", + " 3.7244, 3.1783, 2.6392, 2.1053, 1.5753, 1.0482, 0.5233]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.6148, 0.6184, 0.5988, 0.5621, 0.5128, 0.4541, 0.3884, 0.3175, 0.2427,\n", + " 0.1650, 0.0851])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(5.4359e-07, grad_fn=) , base rewards= tensor([6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416,\n", + " 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 6.0416, 5.4332, 4.8480, 4.2799,\n", + " 3.7244, 3.1783, 2.6392, 2.1053, 1.5753, 1.0482, 0.5233]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.6148, 0.6184, 0.5988, 0.5621, 0.5128, 0.4541, 0.3884, 0.3175, 0.2427,\n", + " 0.1650, 0.0851])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(6.6238e-07, grad_fn=) , base rewards= tensor([6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636,\n", + " 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 5.9553, 5.3700, 4.8019, 4.2464,\n", + " 3.7003, 3.1612, 2.6273, 2.0973, 1.5702, 1.0453, 0.5221]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.6975, 0.7011, 0.6816, 0.6449, 0.5956, 0.5369, 0.4712, 0.4003, 0.3255,\n", + " 0.2478, 0.1679, 0.0863])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(6.6238e-07, grad_fn=) , base rewards= tensor([6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 6.5636,\n", + " 6.5636, 6.5636, 6.5636, 6.5636, 6.5636, 5.9553, 5.3700, 4.8019, 4.2464,\n", + " 3.7003, 3.1612, 2.6273, 2.0973, 1.5702, 1.0453, 0.5221]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.6975, 0.7011, 0.6816, 0.6449, 0.5956, 0.5369, 0.4712, 0.4003, 0.3255,\n", + " 0.2478, 0.1679, 0.0863])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbc0lEQVR4nO3df5BVZX7n8fdHQLetWQUBE+3GNCo6648ZHHqQ2qyWPzZgnKrATOEEN7OyCRWiOzO1k6kx0Y0bJjDuaNwsW1ZWLTJ0+WMSxKiFTM04LFVkdWoCaBNRwITY/gg0kKG1G9cMiNB894/ztHNp7z339uX2vf3j86o65e3vOefheYTbn/ucc+45igjMzMxKOa3RHTAzs+HNQWFmZrkcFGZmlstBYWZmuRwUZmaWa3yjO1BrU6ZMidbW1kZ3w8xsRNm2bdu7ETG12LpRFxStra10dHQ0uhtmZiOKpH8qtc6HnszMLJeDwszMcjkozMwsl4PCzMxyOSjMzCzXqLvqqVr3rNvBmq176YtgnMStV0/jOwuubHS3zMwazkFBFhLf37Ln45/7Ij7+2WFhZmOdDz0Ba7buHVTdzGwscVCQzSAGUzczG0scFGZmlstBYWZmuRwUwMSmCYOqm5mNJQ4KQBpc3cxsLHFQAIcOHxtU3cxsLHFQAGeXOMRUqm5mNpaUDQpJ7ZIOStpZUFsraXta3pG0vWDd3ZI6Je2WNK+gPkvSjrTuQSk7sCPpjNRep6StkloL9lks6Y20LK7VoAc61ndiUHUzs7GkkhnFo8BNhYWI+M2ImBkRM4FngGcBJF0GLAIuT/s8JGlc2u1hYCkwIy39bS4BeiPiYmAlcH9q6xxgGXA1MBtYJmlSVaMs4+cf9Q2qbmY2lpQNioh4Eegpti7NCr4MrEml+cCTEXE0It4GOoHZks4DzoqIzRERwOPAgoJ9HkuvnwZuTO3OAzZGRE9E9AIbGRBYZmY29E71HMU1wM8i4o30czNQeN+LrlRrTq8H1k/aJyKOA+8Dk3Pa+gRJSyV1SOro7u4+pQGZmdnJTjUobuUXswmAYheURk692n1OLkasioi2iGibOrXos8HNzKxKVQeFpPHAl4C1BeUuYFrBzy3A/lRvKVI/aZ/U5tlkh7pKtVVzpb4u4a9RmJmd2ozi3wP/EBGFh5TWA4vSlUzTyU5avxQRB4APJM1J5x9uA54r2Kf/iqaFwKZ0HmMDMFfSpHQSe26q1VypW//5loBmZhU8j0LSGuA6YIqkLmBZRKwmu7qp8LATEbFL0lPA68Bx4KsR0X/p0B1kV1A1Ac+nBWA18ISkTrKZxKLUVo+kFcDLabvlEVH0pLqZmQ2dskEREbeWqP+nEvV7gXuL1DuAK4rUPwRuKdFWO9Bero9mZjZ0/M1sMzPL5aAwM7NcDgozM8vloDAzs1wOCjMzy+WgMDOzXA4KMzPL5aAwM7NcDgozM8vloDAzs1wOCjMzy+WgMDOzXA4KMzPL5aAwM7NcDgozM8vloDAzs1wOCjMzy+WgMDOzXA4KMzPL5aAwM7NcDgozM8tVNigktUs6KGnngPrXJe2WtEvSn6Zaq6Qjkran5ZGC7WdJ2iGpU9KDkpTqZ0ham+pbJbUW7LNY0htpWVyzUZuZWcXGV7DNo8CfA4/3FyRdD8wHPhMRRyWdW7D9mxExs0g7DwNLgS3Aj4CbgOeBJUBvRFwsaRFwP/Cbks4BlgFtQADbJK2PiN7BDdHMzE5F2RlFRLwI9Awo3wHcFxFH0zYH89qQdB5wVkRsjoggC50FafV84LH0+mngxjTbmAdsjIieFA4bycLFzMzqqNpzFJcA16RDRS9I+nzBuumSXkn1a1KtGegq2KYr1frX7QWIiOPA+8DkwnqRfU4iaamkDkkd3d3dVQ7JzMyKqeTQU6n9JgFzgM8DT0m6EDgAXBAR70maBayTdDmgIm1E+m+pdXn7nFyMWAWsAmhrayu6jZmZVafaGUUX8GxkXgJOAFMi4mhEvAcQEduAN8lmH11AS8H+LcD+gramAUgaD5xNdqjr43qRfczMrE6qDYp1wA0Aki4BTgfelTRV0rhUvxCYAbwVEQeADyTNSecfbgOeS22tB/qvaFoIbErnMTYAcyVNkjQJmJtqZmZWR2UPPUlaA1wHTJHURXYlUjvQni6Z/QhYHBEh6VpguaTjQB9we0T0nwi/g+wKqiayq52eT/XVwBOSOslmEosAIqJH0grg5bTd8oK2zMysTsoGRUTcWmLVV4ps+wzwTIl2OoAritQ/BG4psU87WSiZmVmD+JvZZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrnKBoWkdkkHJe0cUP+6pN2Sdkn604L63ZI607p5BfVZknakdQ9KUqqfIWltqm+V1Fqwz2JJb6RlcU1GbGZmg1LJjOJR4KbCgqTrgfnAZyLicuB/pPplwCLg8rTPQ5LGpd0eBpYCM9LS3+YSoDciLgZWAvents4BlgFXA7OBZZImVTVKMzOrWtmgiIgXgZ4B5TuA+yLiaNrmYKrPB56MiKMR8TbQCcyWdB5wVkRsjogAHgcWFOzzWHr9NHBjmm3MAzZGRE9E9AIbGRBYZmY29Ko9R3EJcE06VPSCpM+nejOwt2C7rlRrTq8H1k/aJyKOA+8Dk3Pa+gRJSyV1SOro7u6uckhmZlZMtUExHpgEzAHuBJ5KswAV2TZy6lS5z8nFiFUR0RYRbVOnTi3XdzMzG4Rqg6ILeDYyLwEngCmpPq1guxZgf6q3FKlTuI+k8cDZZIe6SrVlZmZ1VG1QrANuAJB0CXA68C6wHliUrmSaTnbS+qWIOAB8IGlOmnncBjyX2loP9F/RtBDYlM5jbADmSpqUTmLPTTUzM6uj8eU2kLQGuA6YIqmL7EqkdqA9XTL7EbA4/XLfJekp4HXgOPDViOhLTd1BdgVVE/B8WgBWA09I6iSbSSwCiIgeSSuAl9N2yyNi4El1MzMbYmWDIiJuLbHqKyW2vxe4t0i9A7iiSP1D4JYSbbWThZKZmTWIv5ltZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrnKBoWkdkkHJe0sqH1b0j5J29Nyc6q3SjpSUH+kYJ9ZknZI6pT0oCSl+hmS1qb6VkmtBfsslvRGWhbXdORmZlaRSmYUjwI3FamvjIiZaflRQf3NgvrtBfWHgaXAjLT0t7kE6I2Ii4GVwP0Aks4BlgFXA7OBZZImVT40MzOrhbJBEREvAj2n8odIOg84KyI2R0QAjwML0ur5wGPp9dPAjWm2MQ/YGBE9EdELbKR4YJmZ2RA6lXMUX5P0Wjo0VfhJf7qkVyS9IOmaVGsGugq26Uq1/nV7ASLiOPA+MLmwXmSfk0haKqlDUkd3d/cpDMnMzAaqNigeBi4CZgIHgD9L9QPABRFxFfBN4K8knQWoSBuR/ltqXd4+JxcjVkVEW0S0TZ06teJBmJlZeVUFRUT8LCL6IuIE8Bdk5xCIiKMR8V56vQ14E7iEbDbQUtBEC7A/ve4CpgFIGg+cTXao6+N6kX3MzKxOqgqKdM6h3xeBnak+VdK49PpCspPWb0XEAeADSXPS+YfbgOfS/uuB/iuaFgKb0nmMDcBcSZPSoa25qWZmZnU0vtwGktYA1wFTJHWRXYl0naSZZIeC3gF+L21+LbBc0nGgD7g9IvpPhN9BdgVVE/B8WgBWA09I6iSbSSwCiIgeSSuAl9N2ywvaMjOzOikbFBFxa5Hy6hLbPgM8U2JdB3BFkfqHwC0l9mkH2sv10czMho6/mW1mZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrnKPjPbhsY963awZute+iIQcObp4zj8UR/nT2ziznmXsuCq5kZ30cwM8IyiIe5Zt4Pvb9lDXwQAAfz8oz4C2HfoCN9Yu52rlv8f1r2yr6H9NDMDB0VDrNm6t+w2vYeP8ftrt3PPuh116JGZWWllg0JSu6SDknYW1L4taZ+k7Wm5uWDd3ZI6Je2WNK+gPkvSjrTuQUlK9TMkrU31rZJaC/ZZLOmNtCyu2agbrH8mUU4A39+yx2FhZg1VyYziUeCmIvWVETEzLT8CkHQZsAi4PO3zkKRxafuHgaXAjLT0t7kE6I2Ii4GVwP2prXOAZcDVwGxgmaRJgx7hKPCXW/b4MJSZNUzZoIiIF4GeCtubDzwZEUcj4m2gE5gt6TzgrIjYHBEBPA4sKNjnsfT6aeDGNNuYB2yMiJ6I6AU2UjywhtRw+AUdwAMbdje6G2Y2Rp3KOYqvSXotHZrq/6TfDBQegO9Kteb0emD9pH0i4jjwPjA5p61PkLRUUoekju7u7lMY0icNl1/Q+w8daXQXzGyMqvby2IeBFWQfdlcAfwb8DqAi20ZOnSr3ObkYsQpYBdDW1lbZCYAK1foXdLUzlABa7/phTftiZqPXO/d9oWZtVTWjiIifRURfRJwA/oLsHAJkn/qnFWzaAuxP9ZYi9ZP2kTQeOJvsUFepturq/IlNNWtr3Sv7+Mba7TVrz8yslFp+sKwqKNI5h35fBPqviFoPLEpXMk0nO2n9UkQcAD6QNCedf7gNeK5gn/4rmhYCm9J5jA3AXEmT0qGtualWV3fOu7Rmbf3JD3bVrC0zs3ope+hJ0hrgOmCKpC6yK5GukzST7IjIO8DvAUTELklPAa8Dx4GvRkRfauoOsiuomoDn0wKwGnhCUifZTGJRaqtH0grg5bTd8oio9KR6zdTyG9K9h4/VrC0zs3opGxQRcWuR8uqc7e8F7i1S7wCuKFL/ELilRFvtQHu5PpqZ2dDxN7PNzCyXg6IMfyvazEaiWl715LvHlrFm616+s+DKRndjWGue2MRP77qhom1/9b5N7CtyyfFg2qiVevZlOI270HDt12gz0v8/e0ZRRqX3ZRqrmiaMG9SVYXfOu5SmCeNOqg22jVqpZ1+G07gLDdd+jTYj/f+zZxQGwOnjxEd9lYWiyC53a67i2Rn92z6wYTf7Dx1p6PM36tmX4TTukdCv0Wak/39WjLJPzG1tbdHR0TGofcp9MaVWx/oa+c3qWh6vNLPRR9K2iGgrts6HnszMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4NiDFCxp4+bmVXIQTEGjLK7tJhZnTkohqnT0ixgYtMEJp05AYBxVU4Nmic21apbZjYG+e6xw1DePerXvbKPu5/dwZFjfZ9YN+E0geBYwV1gR9KtjM1sePKMogL1fsrd/iIPOOm34KpmvvulKz+eJfTPMponNvHALZ/lgYWfpXliE0q1737pyhFzK2MzG548o6jAX27dU9en3J1f5lDRgquac3/5OxjMrJbKzigktUs6KGlnkXXfkhSSpqSfWyUdkbQ9LY8UbDtL0g5JnZIelLKPwpLOkLQ21bdKai3YZ7GkN9KyuCYjrkI9TwafJnyoyMyGlUoOPT0K3DSwKGka8GvAngGr3oyImWm5vaD+MLAUmJGW/jaXAL0RcTGwErg/tX8OsAy4GpgNLJM0qcJxjUjjTxP/88szPSMws2GlbFBExItAT5FVK4E/IHsqZi5J5wFnRcTmyB6p9ziwIK2eDzyWXj8N3JhmG/OAjRHRExG9wEaKBNZo0vnfb3ZImNmwU9XJbEm/AeyLiFeLrJ4u6RVJL0i6JtWaga6CbbpSrX/dXoCIOA68D0wurBfZZ2B/lkrqkNTR3d1dzZDMzKyEQZ/MlnQm8EfA3CKrDwAXRMR7kmYB6yRdDhT7AkD/TKTUurx9Ti5GrAJWQfbM7PwRmJnZYFQzo7gImA68KukdoAX4O0m/HBFHI+I9gIjYBrwJXEI2G2gpaKMF2J9edwHTACSNB84mO9T1cb3IPnXVNMFXEZvZ2DXo34ARsSMizo2I1ohoJfuF/rmI+GdJUyWNA5B0IdlJ67ci4gDwgaQ56fzDbcBzqcn1QP8VTQuBTek8xgZgrqRJ6ST23FSrO98qyczGskouj10DbAYuldQlaUnO5tcCr0l6lezE9O0R0X8i/A7ge0An2Uzj+VRfDUyW1Al8E7gLIO23Ang5LcsL2qqrw8dOsO6VfY34o83MGq7sOYqIuLXM+taC188Az5TYrgO4okj9Q+CWEvu0A+3l+lgPD2zY7SuSzGxM8sH3CuXdVsPMbDRzUFRoYrqDq5nZWOOgqNC/fHis0V0wM2sIB0WFjp1odA/MzBrDQTEIQ3nlU7UPJTIzG2oOikH4kx/sGrK2b716WvmNzMwawEExCL2Hh+48RT2fd2FmNhh+cNEgXfbfnueMCeM4dPgY509s4s55l/r7FWY2qnlGMUiHj52g9/AxAth36Ai/v3Y7rXf9kF+9b5O/vW1mo5KD4hT136p236Ej3P3sDoeFmY06DooaOnKsjwc27G50N8zMaspBUWO+1YeZjTYOiho7f2JTo7tgZlZTDooaapowjjvnXdrobpiZ1ZQvj62hD4/18dcde3hgw272Hzriy2fNbFRwUNRQAD998xfPVtp36AjfWLudb6zd3rA+mZmdKh96MjOzXA4KMzPL5aAwM7NcDgozM8vloAD8JAgzs9IcFPzifk1mZvZJZYNCUrukg5J2Fln3LUkhaUpB7W5JnZJ2S5pXUJ8laUda96CUPdJN0hmS1qb6VkmtBfsslvRGWhaf8mhLaPa3qc3MSqpkRvEocNPAoqRpwK8BewpqlwGLgMvTPg9JGpdWPwwsBWakpb/NJUBvRFwMrATuT22dAywDrgZmA8skTRrc8Crjb1ObmZVWNigi4kWgp8iqlcAfcPKRm/nAkxFxNCLeBjqB2ZLOA86KiM0REcDjwIKCfR5Lr58GbkyzjXnAxojoiYheYCNFAqsW/M1pM7PSqjpHIek3gH0R8eqAVc3A3oKfu1KtOb0eWD9pn4g4DrwPTM5pq1h/lkrqkNTR3d1dzZDMzKyEQQeFpDOBPwL+uNjqIrXIqVe7z8nFiFUR0RYRbVOnTi22iZmZVamaGcVFwHTgVUnvAC3A30n6ZbJP/dMKtm0B9qd6S5E6hftIGg+cTXaoq1RbZmZWR4MOiojYERHnRkRrRLSS/UL/XET8M7AeWJSuZJpOdtL6pYg4AHwgaU46/3Ab8Fxqcj3Qf0XTQmBTOo+xAZgraVI6iT031YbEV+ZcMFRNm5mNaJVcHrsG2AxcKqlL0pJS20bELuAp4HXgx8BXI6Ivrb4D+B7ZCe43gedTfTUwWVIn8E3grtRWD7ACeDkty1NtSHxnwZVD1bSZ2Yim7MP76NHW1hYdHR1V79961w9r2JvKvHPfF+r+Z5qZFZK0LSLaiq3z8ygGeOe+L3DPuh18f8ue8huTPdXuu1/KZiOFDyy6/tNT+Zt/6PYDjMxsxHNQFPGdBVfS9ivn8O31uzh05NhJ6yacJj71r8Zz6PCxTwSAg8DMRiMHRQkLrmpmwVXNrHtlnx9tamZjmoOijP7AMDMbq3z3WDMzy+WgMDOzXA4KMzPL5aAwM7NcDgozM8s16r6ZLakb+KdTaGIK8G6NutNIo2Uc4LEMV6NlLKNlHHBqY/mViCh6++1RFxSnSlJHqa+xjySjZRzgsQxXo2Uso2UcMHRj8aEnMzPL5aAwM7NcDopPWtXoDtTIaBkHeCzD1WgZy2gZBwzRWHyOwszMcnlGYWZmuRwUZmaWa0wGhaSbJO2W1CnpriLrJenBtP41SZ9rRD8rUcFYfiuN4TVJfyvps43oZyXKjaVgu89L6pO0sJ79q1Ql45B0naTtknZJeqHefaxUBf++zpb0A0mvprH8diP6WY6kdkkHJe0ssX4kvefLjaX27/mIGFMLMI7smd0XAqcDrwKXDdjmZrJneguYA2xtdL9PYSz/FpiUXv/6SB5LwXabgB8BCxvd7yr/TiaSPVf+gvTzuY3u9ymM5b8C96fXU4Ee4PRG973IWK4FPgfsLLF+RLznKxxLzd/zY3FGMRvojIi3IuIj4Elg/oBt5gOPR2YLMFHSefXuaAXKjiUi/jYietOPW4CWOvexUpX8vQB8HXgGOFjPzg1CJeP4D8CzEbEHICJG8lgC+NeSBHyKLCiO17eb5UXEi2R9K2WkvOfLjmUo3vNjMSiagb0FP3el2mC3GQ4G288lZJ+ahqOyY5HUDHwReKSO/RqsSv5OLgEmSfq/krZJuq1uvRucSsby58C/AfYDO4D/EhEn6tO9mhop7/nBqsl7fiw+4U5FagOvEa5km+Gg4n5Kup7sH82/G9IeVa+Ssfwv4A8joi/7ADssVTKO8cAs4EagCdgsaUtE/ONQd26QKhnLPGA7cANwEbBR0k8i4v8Ncd9qbaS85ytWy/f8WAyKLmBawc8tZJ+GBrvNcFBRPyV9Bvge8OsR8V6d+jZYlYylDXgyhcQU4GZJxyNiXV16WJlK/329GxE/B34u6UXgs8BwC4pKxvLbwH2RHRDvlPQ28Gngpfp0sWZGynu+IrV+z4/FQ08vAzMkTZd0OrAIWD9gm/XAbelKiDnA+xFxoN4drUDZsUi6AHgW+I/D8BNrobJjiYjpEdEaEa3A08B/HmYhAZX9+3oOuEbSeElnAlcDf1/nflaikrHsIZsZIemXgEuBt+ray9oYKe/5sobiPT/mZhQRcVzS14ANZFd1tEfELkm3p/WPkF1RczPQCRwm+9Q07FQ4lj8GJgMPpU/ix2MY3imzwrEMe5WMIyL+XtKPgdeAE8D3IqLopY6NVOHfyQrgUUk7yA7f/GFEDLtbdktaA1wHTJHUBSwDJsDIes9DRWOp+Xvet/AwM7NcY/HQk5mZDYKDwszMcjkozMwsl4PCzMxyOSjMzEa4cjcKLLL9lyW9nm7k+Fdlt/dVT2ZmI5uka4F/Ibtf1RVltp0BPAXcEBG9ks4td78xzyjMzEa4YjcKlHSRpB+n+4n9RNKn06rfBf53/40DK7kppYPCzGx0WgV8PSJmAd8CHkr1S4BLJP1U0hZJN5VraMx9M9vMbLST9Cmy51L8dcENNM9I/x0PzCD7dncL8BNJV0TEoVLtOSjMzEaf04BDETGzyLouYEtEHAPelrSbLDhezmvMzMxGkXSb97cl3QIfP+q1/5Go64DrU30K2aGo3Bs5OijMzEa4dKPAzcClkrokLQF+C1gi6VVgF794OuEG4D1JrwN/A9xZ7lbkvjzWzMxyeUZhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5/j9FHUl9FVdXQwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(7.9246e-07, grad_fn=) , base rewards= tensor([7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848,\n", + " 7.0848, 7.0848, 7.0848, 7.0848, 6.4764, 5.8912, 5.3230, 4.7676, 4.2215,\n", + " 3.6824, 3.1485, 2.6185, 2.0914, 1.5665, 1.0432, 0.5211]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.7812, 0.7848, 0.7652, 0.7285, 0.6792, 0.6205, 0.5548, 0.4839, 0.4091,\n", + " 0.3314, 0.2515, 0.1700, 0.0873])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(7.9246e-07, grad_fn=) , base rewards= tensor([7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848, 7.0848,\n", + " 7.0848, 7.0848, 7.0848, 7.0848, 6.4764, 5.8912, 5.3230, 4.7676, 4.2215,\n", + " 3.6824, 3.1485, 2.6185, 2.0914, 1.5665, 1.0432, 0.5211]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.7812, 0.7848, 0.7652, 0.7285, 0.6792, 0.6205, 0.5548, 0.4839, 0.4091,\n", + " 0.3314, 0.2515, 0.1700, 0.0873])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(9.3366e-07, grad_fn=) , base rewards= tensor([7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052,\n", + " 7.6052, 7.6052, 7.6052, 6.9968, 6.4116, 5.8435, 5.2880, 4.7419, 4.2028,\n", + " 3.6689, 3.1389, 2.6118, 2.0869, 1.5637, 1.0416, 0.5205]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.8655, 0.8691, 0.8496, 0.8129, 0.7636, 0.7049, 0.6392, 0.5683, 0.4935,\n", + " 0.4158, 0.3359, 0.2543, 0.1716, 0.0879])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(9.3366e-07, grad_fn=) , base rewards= tensor([7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052, 7.6052,\n", + " 7.6052, 7.6052, 7.6052, 6.9968, 6.4116, 5.8435, 5.2880, 4.7419, 4.2028,\n", + " 3.6689, 3.1389, 2.6118, 2.0869, 1.5637, 1.0416, 0.5205]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.8655, 0.8691, 0.8496, 0.8129, 0.7636, 0.7049, 0.6392, 0.5683, 0.4935,\n", + " 0.4158, 0.3359, 0.2543, 0.1716, 0.0879])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbR0lEQVR4nO3df5BV9Z3m8fcTQLfdrNAC7pgGt1HRGTEZDB1kJ6tFdAccUxtIVie4mZKdpYbRSlKbteKMbqzBgrFGx50iZc2KxYQuf2QGcdVFthJDqGVWUzOANiMKuMPa/hhpYEJrg+tGRGg/+8f5tt7u3Hvu7e57+97ufl5Vt7z9Oed8+3Nbbj99zvfccxQRmJmZlfKpejdgZmaNzUFhZma5HBRmZpbLQWFmZrkcFGZmlmtivRuotmnTpkVra2u92zAzG1V27979dkRML7ZszAVFa2srHR0d9W7DzGxUkfQPpZb50JOZmeVyUJiZWS4HhZmZ5XJQmJlZLgeFmZnlGnNnPQ3VnZv3snHXQXojmCBx4xUz+eOln613W2ZmdeegIAuJH+586+OveyM+/tphYWbjnQ89ARt3HRxU3cxsPHFQkO1BDKZuZjaeOCjMzCyXg8LMzHI5KIApTZMGVTczG08cFIA0uLqZ2XjioACOv39qUHUzs/HEQQFMLnGIqVTdzGw8KRsUktolHZW0r6C2SdKe9HhT0p6CZXdI6pR0QNLigvo8SXvTsvul7MCOpDPTeJ2SdklqLdhmuaRX02N5tV70QKd6PxpU3cxsPKlkj+Ih4NrCQkR8PSLmRsRc4EngKQBJlwLLgDlpmwckTUibrQNWArPTo2/MFcCxiLgIWAvcm8Y6B1gFXAHMB1ZJah7SqyzjFx/2DqpuZjaelA2KiHgO6Cm2LO0V/DawMZWWAI9FxMmIeAPoBOZLOg84OyJ2REQAjwBLC7Z5OD1/ArgmjbsY2BYRPRFxDNjGgMAyM7PaG+4cxZXAzyPi1fR1C1B43YuuVGtJzwfW+20TEaeBd4GpOWP9EkkrJXVI6uju7h7WCzIzs/6GGxQ38sneBECxE0ojpz7UbfoXI9ZHRFtEtE2fXvTe4GZmNkRDDgpJE4GvAZsKyl3AzIKvZwCHU31GkXq/bdKYk8kOdZUaq+pKfVzCH6MwMxveHsW/Bv4+IgoPKW0BlqUzmWaRTVo/HxFHgPckLUjzDzcBTxds03dG0/XA9jSPsRVYJKk5TWIvSrWqK3XpP18S0MysgvtRSNoILASmSeoCVkXEBrKzmwoPOxER+yU9DrwCnAa+GRF9pw7dQnYGVRPwTHoAbAAeldRJtiexLI3VI2kN8EJab3VEFJ1UNzOz2ikbFBFxY4n6vy9Rvxu4u0i9A7isSP0D4IYSY7UD7eV6NDOz2vEns83MLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsV9mgkNQu6aikfQPq35Z0QNJ+SX+aaq2STkjakx4PFqw/T9JeSZ2S7pekVD9T0qZU3yWptWCb5ZJeTY/lVXvVZmZWsYkVrPMQ8OfAI30FSV8ClgCfi4iTks4tWP+1iJhbZJx1wEpgJ/Bj4FrgGWAFcCwiLpK0DLgX+Lqkc4BVQBsQwG5JWyLi2OBeopmZDUfZPYqIeA7oGVC+BbgnIk6mdY7mjSHpPODsiNgREUEWOkvT4iXAw+n5E8A1aW9jMbAtInpSOGwjCxczMxtBQ52juBi4Mh0qelbSFwqWzZL0YqpfmWotQFfBOl2p1rfsIEBEnAbeBaYW1ots04+klZI6JHV0d3cP8SWZmVkxlRx6KrVdM7AA+ALwuKQLgCPA+RHxjqR5wGZJcwAVGSPSf0sty9umfzFiPbAeoK2treg6ZmY2NEPdo+gCnorM88BHwLSIOBkR7wBExG7gNbK9jy5gRsH2M4DDBWPNBJA0EZhMdqjr43qRbczMbIQMNSg2A1cDSLoYOAN4W9J0SRNS/QJgNvB6RBwB3pO0IM0/3AQ8ncbaAvSd0XQ9sD3NY2wFFklqltQMLEo1MzMbQWUPPUnaCCwEpknqIjsTqR1oT6fMfggsj4iQdBWwWtJpoBe4OSL6JsJvITuDqonsbKdnUn0D8KikTrI9iWUAEdEjaQ3wQlpvdcFYZmY2QsoGRUTcWGLR7xRZ90ngyRLjdACXFal/ANxQYpt2slAyM7M68Sezzcwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHKVDQpJ7ZKOSto3oP5tSQck7Zf0pwX1OyR1pmWLC+rzJO1Ny+6XpFQ/U9KmVN8lqbVgm+WSXk2P5VV5xWZmNiiV7FE8BFxbWJD0JWAJ8LmImAP8l1S/FFgGzEnbPCBpQtpsHbASmJ0efWOuAI5FxEXAWuDeNNY5wCrgCmA+sEpS85BepZmZDVnZoIiI54CeAeVbgHsi4mRa52iqLwEei4iTEfEG0AnMl3QecHZE7IiIAB4BlhZs83B6/gRwTdrbWAxsi4ieiDgGbGNAYJmZWe0NdY7iYuDKdKjoWUlfSPUW4GDBel2p1pKeD6z32yYiTgPvAlNzxvolklZK6pDU0d3dPcSXZGZmxQw1KCYCzcAC4Dbg8bQXoCLrRk6dIW7TvxixPiLaIqJt+vTp5Xo3M7NBGGpQdAFPReZ54CNgWqrPLFhvBnA41WcUqVO4jaSJwGSyQ12lxjIzsxE01KDYDFwNIOli4AzgbWALsCydyTSLbNL6+Yg4ArwnaUHa87gJeDqNtQXoO6PpemB7msfYCiyS1JwmsRelmpmZjaCJ5VaQtBFYCEyT1EV2JlI70J5Omf0QWJ5+ue+X9DjwCnAa+GZE9KahbiE7g6oJeCY9ADYAj0rqJNuTWAYQET2S1gAvpPVWR8TASXUzM6uxskERETeWWPQ7Jda/G7i7SL0DuKxI/QPghhJjtZOFkpmZ1Yk/mW1mZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmuRwUZmaWy0FhZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmucoGhaR2SUcl7Suo3SXpkKQ96XFdqrdKOlFQf7Bgm3mS9krqlHS/JKX6mZI2pfouSa0F2yyX9Gp6LK/qKzczs4pUskfxEHBtkfraiJibHj8uqL9WUL+5oL4OWAnMTo++MVcAxyLiImAtcC+ApHOAVcAVwHxglaTmyl+amZlVQ9mgiIjngJ7hfBNJ5wFnR8SOiAjgEWBpWrwEeDg9fwK4Ju1tLAa2RURPRBwDtlE8sMzMrIaGM0fxLUkvp0NThX/pz5L0oqRnJV2Zai1AV8E6XanWt+wgQEScBt4FphbWi2zTj6SVkjokdXR3dw/jJZmZ2UBDDYp1wIXAXOAI8GepfgQ4PyIuB24F/krS2YCKjBHpv6WW5W3TvxixPiLaIqJt+vTpFb8IMzMrb0hBERE/j4jeiPgI+AuyOQQi4mREvJOe7wZeAy4m2xuYUTDEDOBwet4FzASQNBGYTHao6+N6kW3MzGyEDCko0pxDn68C+1J9uqQJ6fkFZJPWr0fEEeA9SQvS/MNNwNNp+y1A3xlN1wPb0zzGVmCRpOZ0aGtRqpmZ2QiaWG4FSRuBhcA0SV1kZyItlDSX7FDQm8Dvp9WvAlZLOg30AjdHRN9E+C1kZ1A1Ac+kB8AG4FFJnWR7EssAIqJH0hrghbTe6oKxzMxshJQNioi4sUh5Q4l1nwSeLLGsA7isSP0D4IYS27QD7eV6NDOz2vEns83MLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLFfZe2Zbddy5eS8bdx2kN+LjWsuUJm5bfAlLL2+pY2dmZvm8RzEC7ty8lx/ufKtfSAAcOn6C72zaw+Wrf8rmFw/VqTszs3wOihGwcdfB3OXH3j/Ff9q0hzs37x2hjszMKlc2KCS1SzoqaV9B7S5JhyTtSY/rCpbdIalT0gFJiwvq8yTtTcvul6RUP1PSplTfJam1YJvlkl5Nj+VVe9UjbOCeRDEB/HDnWw4LM2s4lexRPARcW6S+NiLmpsePASRdCiwD5qRtHpA0Ia2/DlgJzE6PvjFXAMci4iJgLXBvGuscYBVwBTAfWCWpedCvcJT5y51v+TCUmTWUskEREc8BPRWOtwR4LCJORsQbQCcwX9J5wNkRsSMiAngEWFqwzcPp+RPANWlvYzGwLSJ6IuIYsI3igTWmBHDf1gP1bsPM7GPDmaP4lqSX06Gpvr/0W4DCA/JdqdaSng+s99smIk4D7wJTc8b6JZJWSuqQ1NHd3T2Ml9QYDh8/Ue8WzMw+NtTTY9cBa8j+AF4D/BnwHwAVWTdy6gxxm/7FiPXAeoC2trbyEwINLoDW239U7zbMbBR7854vV22sIe1RRMTPI6I3Ij4C/oJsDgGyv/pnFqw6Azic6jOK1PttI2kiMJnsUFepsUYV/8I3s3qo5u+eIQVFmnPo81Wg74yoLcCydCbTLLJJ6+cj4gjwnqQFaf7hJuDpgm36zmi6Htie5jG2AoskNadDW4tSbdTwpLSZjQVlDz1J2ggsBKZJ6iI7E2mhpLlkR0neBH4fICL2S3oceAU4DXwzInrTULeQnUHVBDyTHgAbgEcldZLtSSxLY/VIWgO8kNZbHRGVTqo3BE9Km9lYUDYoIuLGIuUNOevfDdxdpN4BXFak/gFwQ4mx2oH2cj02qkOelDazMcCfzK6hCSo2H29mNro4KGqokk9km5nVQjXPevLVY2tIlDifd5RomdLE39x+dcnlX7xne9HDa+W2G65aft96vaZG62G08c+strxHUcZwzlwazSHRNGkCty2+JHed2xZfQtOkCf1qlWw3XLX8vvV6TY3Ww2jjn1lteY+ijPu2Hhj194s4Y4L4sLd8bJ058VN8ePojPlPhfTL6lt+39QCHj5+oeLvhquX3rddrarQeRhv/zGpLMcaOo7e1tUVHR8egtin3wZShHusb6Q/bVfOYpJmNL5J2R0RbsWU+9GRmZrkcFGZmlstBYWZmuRwUZfgjc2Y23jkoyhhbU/1mZoPnoDAzs1wOCjMzy+WgMDOzXA4KMzPL5aAYI5rPmlTvFsxsjHJQjBGr/s2cerdgZmOUg6KBTGmaxFmTBv+/ZErTJF/8zMxqxlePbQDFLua3+cVD3PHUXk6c6i2yxSeaJk3grq94b8LMasd7FBUYzj0phmrp5S38ydc+S8uUJuCT26pOaZpE81mTENlNWf7ka5/13oSZ1ZT3KCpQr3tSLL28xSFgZnVXdo9CUruko5L2FVn2XUkhaVr6ulXSCUl70uPBgnXnSdorqVPS/VL2J7KkMyVtSvVdkloLtlku6dX0WF6VVzwEh4vcYrFavnjhOTUb28ysGio59PQQcO3AoqSZwG8Cbw1Y9FpEzE2Pmwvq64CVwOz06BtzBXAsIi4C1gL3pvHPAVYBVwDzgVWSmit8XVX1mXT4p9pmn/tP+cvf+5c1GdvMrFrKBkVEPAf0FFm0FvgDKrhunqTzgLMjYkdkt9R7BFiaFi8BHk7PnwCuSXsbi4FtEdETEceAbRQJrJFQq/vubrt1YU3GNTOrpiFNZkv6CnAoIl4qsniWpBclPSvpylRrAboK1ulKtb5lBwEi4jTwLjC1sF5km4H9rJTUIamju7t7KC8pl+cJzGw8G/RktqSzgO8Bi4osPgKcHxHvSJoHbJY0h+K3dejbEym1LG+b/sWI9cB6yO6Znf8KzMxsMIayR3EhMAt4SdKbwAzg7yT9SkScjIh3ACJiN/AacDHZ3sCMgjFmAIfT8y5gJoCkicBkskNdH9eLbGNmZiNk0EEREXsj4tyIaI2IVrJf6J+PiH+UNF3SBABJF5BNWr8eEUeA9yQtSPMPNwFPpyG3AH1nNF0PbE/zGFuBRZKa0yT2olQzM7MRVMnpsRuBHcAlkrokrchZ/SrgZUkvkU1M3xwRfRPhtwA/ADrJ9jSeSfUNwFRJncCtwO0Aabs1wAvpsbpgrBF15+a99fi2ZmYNoewcRUTcWGZ5a8HzJ4EnS6zXAVxWpP4BcEOJbdqB9nI91trGXQf546WfrXcbZmZ14Ut4VKA3PD9uZuOXg8LMzHI5KCrkeQozG68cFBX64c6BVyoxMxsfHBSDUM3LjRf7NKGZWSNyUAzCfVsPVG2sbyw4v2pjmZnVkoNiEKp5uXGfbmtmo4VvXDQIAVy++qccf/8Un5nSxG2LL/EFA81szPMexSAde/8UARw6foLvbNrD5at/WpdbpZqZjRQHxTAde/8Udzy112FhZmOWg6IKTpzqrepEt5lZI3FQVEkt76ttZlZPDooqqdV9tc3M6s1BUQVNkybU7L7aZmb15qCoghOnevnef9/LrNt/xBfv2e6JbTMbUxwUVfKLD3v7nTbbevuP6t2SmVlVOCjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMwsl4PCzMxylQ0KSe2SjkraV2TZdyWFpGkFtTskdUo6IGlxQX2epL1p2f2SlOpnStqU6rsktRZss1zSq+mxfNivtoQpTZNqNbSZ2ahXyR7FQ8C1A4uSZgK/CbxVULsUWAbMSds8IGlCWrwOWAnMTo++MVcAxyLiImAtcG8a6xxgFXAFMB9YJal5cC+vMnd9ZU4thjUzGxPKBkVEPAf0FFm0FvgDsvv59FkCPBYRJyPiDaATmC/pPODsiNgREQE8Aiwt2Obh9PwJ4Jq0t7EY2BYRPRFxDNhGkcCqBt98yMystCHNUUj6CnAoIl4asKgFOFjwdVeqtaTnA+v9tomI08C7wNScsYr1s1JSh6SO7u7uobwkMzMrYdBBIeks4HvAHxVbXKQWOfWhbtO/GLE+Itoiom369OnFVjEzsyEayh7FhcAs4CVJbwIzgL+T9Ctkf/XPLFh3BnA41WcUqVO4jaSJwGSyQ12lxjIzsxE06KCIiL0RcW5EtEZEK9kv9M9HxD8CW4Bl6UymWWST1s9HxBHgPUkL0vzDTcDTacgtQN8ZTdcD29M8xlZgkaTmNIm9KNXMzGwEVXJ67EZgB3CJpC5JK0qtGxH7gceBV4CfAN+MiN60+BbgB2QT3K8Bz6T6BmCqpE7gVuD2NFYPsAZ4IT1Wp1pNfP/rc2s1tJnZqKbsj/exo62tLTo6Ooa07eYXD/GdTXuq21ARb97z5Zp/DzOzwZC0OyLaii2bONLNNLK+02RvfXwPH1WQn02TJvBv57Xw13/fzeHjJ5jcNAkJjr9/is9MaeK2xZf41FszG/UcFAP0/WK/a8t+jp841W/ZpE+JT/+TiQ4CMxtXHBRFLL28haWXt7D5xUPct/UAh4+fcDCY2bjloMjRFxhmZuOZrx5rZma5HBRmZpbLQWFmZrkcFGZmlstBYWZmucbcJ7MldQP/MIwhpgFvV6mdWhtNvcLo6nc09Qqjq9/R1CuMrn6H0+u/iIiil98ec0ExXJI6Sn2MvdGMpl5hdPU7mnqF0dXvaOoVRle/terVh57MzCyXg8LMzHI5KH7Z+no3MAijqVcYXf2Opl5hdPU7mnqF0dVvTXr1HIWZmeXyHoWZmeVyUJiZWa5xGRSSrpV0QFKnpNuLLJek+9PylyV9vh59FvRTrt9vpD5flvS3kn69Hn2mXnJ7LVjvC5J6JV0/kv0V6aNsv5IWStojab+kZ0e6x4I+yv07mCzpf0h6KfX6u/XoM/XSLumopH0lljfae6xcv430HsvttWC96r3HImJcPYAJZPfsvgA4A3gJuHTAOteR3dNbwAJgV4P3+xtAc3r+W/Xqt5JeC9bbDvwYuL7Bf7ZTyO4Bf376+twG7vU/A/em59OBHuCMOvV7FfB5YF+J5Q3zHquw34Z4j1XSa8G/l6q9x8bjHsV8oDMiXo+ID4HHgCUD1lkCPBKZncAUSeeNdKNJ2X4j4m8j4lj6cicwY4R77FPJzxbg28CTwNGRbK6ISvr9d8BTEfEWQETUq+dKeg3gn0kS8GmyoDg9sm2mRiKeS9+/lEZ6j5Xtt4HeY5X8bKHK77HxGBQtwMGCr7tSbbDrjJTB9rKC7C+1eijbq6QW4KvAgyPYVymV/GwvBpol/S9JuyXdNGLd9VdJr38O/BpwGNgL/MeI+Ghk2hu0RnqPDVY932Nl1eI9Nh7vcKcitYHnCFeyzkipuBdJXyL7R/yvatpRaZX0+n3gDyOiN/vDt64q6XciMA+4BmgCdkjaGRH/p9bNDVBJr4uBPcDVwIXANkk/i4j/W+PehqKR3mMVa4D3WCW+T5XfY+MxKLqAmQVfzyD7C2yw64yUinqR9DngB8BvRcQ7I9TbQJX02gY8lv4BTwOuk3Q6IjaPSIf9Vfpv4e2I+AXwC0nPAb8OjHRQVNLr7wL3RHaQulPSG8CvAs+PTIuD0kjvsYo0yHusEtV/j9VrQqaOE0ETgdeBWXwyKThnwDpfpv9E2/MN3u/5QCfwG43+sx2w/kPUdzK7kp/trwH/M617FrAPuKxBe10H3JWe/3PgEDCtjj/fVkpPDjfMe6zCfhviPVZJrwPWq8p7bNztUUTEaUnfAraSnRnQHhH7Jd2clj9IdqbAdWT/MN4n+0utkfv9I2Aq8ED6K+J01OFqlxX22jAq6Tci/reknwAvAx8BP4iI3NMS69UrsAZ4SNJesl/AfxgRdbk8tqSNwEJgmqQuYBUwqaDXhnmPQUX9NsR7rMJeq/89U+qYmZkVNR7PejIzs0FwUJiZWS4HhZmZ5XJQmJlZLgeFmdkoV+mFAgvW/21Jr6SLR/5V2fV91pOZ2egm6Srg/5FdP+uyMuvOBh4Hro6IY5LOjTLXMPMehZnZKBdFLhQo6UJJP0nXKPuZpF9Ni34P+K+RLnJYLiTAQWFmNlatB74dEfOA7wIPpPrFwMWS/kbSTknXlhto3H0y28xsrJP0abJ7aPy3ggsDnpn+OxGYTfbp7hnAzyRdFhHHS43noDAzG3s+BRyPiLlFlnUBOyPiFPCGpANkwfFC3mBmZjaGRHZp+Tck3QAf33q27/atm4Evpfo0skNRr+eN56AwMxvl0oUCdwCXSOqStAL4BrBC0kvAfj65I+JW4B1JrwB/DdwWZS6b7tNjzcwsl/cozMwsl4PCzMxyOSjMzCyXg8LMzHI5KMzMLJeDwszMcjkozMws1/8HhI/rbRDJpNkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.0858e-06, grad_fn=) , base rewards= tensor([8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250,\n", + " 8.1250, 8.1250, 7.5167, 6.9315, 6.3634, 5.8079, 5.2618, 4.7227, 4.1889,\n", + " 3.6589, 3.1318, 2.6069, 2.0836, 1.5615, 1.0404, 0.5199]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.9504, 0.9540, 0.9344, 0.8978, 0.8484, 0.7897, 0.7240, 0.6531, 0.5783,\n", + " 0.5006, 0.4207, 0.3392, 0.2565, 0.1728, 0.0885])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.0858e-06, grad_fn=) , base rewards= tensor([8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250, 8.1250,\n", + " 8.1250, 8.1250, 7.5167, 6.9315, 6.3634, 5.8079, 5.2618, 4.7227, 4.1889,\n", + " 3.6589, 3.1318, 2.6069, 2.0836, 1.5615, 1.0404, 0.5199]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([0.9504, 0.9540, 0.9344, 0.8978, 0.8484, 0.7897, 0.7240, 0.6531, 0.5783,\n", + " 0.5006, 0.4207, 0.3392, 0.2565, 0.1728, 0.0885])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.2488e-06, grad_fn=) , base rewards= tensor([8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444,\n", + " 8.6444, 8.0362, 7.4510, 6.8830, 6.3275, 5.7814, 5.2423, 4.7084, 4.1784,\n", + " 3.6513, 3.1264, 2.6031, 2.0811, 1.5600, 1.0395, 0.5196]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.0356, 1.0392, 1.0197, 0.9830, 0.9337, 0.8750, 0.8093, 0.7384, 0.6636,\n", + " 0.5859, 0.5060, 0.4245, 0.3417, 0.2580, 0.1737, 0.0888])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.2488e-06, grad_fn=) , base rewards= tensor([8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444, 8.6444,\n", + " 8.6444, 8.0362, 7.4510, 6.8830, 6.3275, 5.7814, 5.2423, 4.7084, 4.1784,\n", + " 3.6513, 3.1264, 2.6031, 2.0811, 1.5600, 1.0395, 0.5196]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.0356, 1.0392, 1.0197, 0.9830, 0.9337, 0.8750, 0.8093, 0.7384, 0.6636,\n", + " 0.5859, 0.5060, 0.4245, 0.3417, 0.2580, 0.1737, 0.0888])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.4226e-06, grad_fn=) , base rewards= tensor([9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632,\n", + " 8.5552, 7.9702, 7.4022, 6.8467, 6.3007, 5.7616, 5.2277, 4.6977, 4.1706,\n", + " 3.6457, 3.1224, 2.6004, 2.0792, 1.5588, 1.0388, 0.5193]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.1212, 1.1248, 1.1052, 1.0685, 1.0192, 0.9605, 0.8948, 0.8239, 0.7491,\n", + " 0.6714, 0.5915, 0.5100, 0.4272, 0.3436, 0.2592, 0.1744, 0.0891])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.4226e-06, grad_fn=) , base rewards= tensor([9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632, 9.1632,\n", + " 8.5552, 7.9702, 7.4022, 6.8467, 6.3007, 5.7616, 5.2277, 4.6977, 4.1706,\n", + " 3.6457, 3.1224, 2.6004, 2.0792, 1.5588, 1.0388, 0.5193]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.1212, 1.1248, 1.1052, 1.0685, 1.0192, 0.9605, 0.8948, 0.8239, 0.7491,\n", + " 0.6714, 0.5915, 0.5100, 0.4272, 0.3436, 0.2592, 0.1744, 0.0891])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.6070e-06, grad_fn=) , base rewards= tensor([9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.0739,\n", + " 8.4891, 7.9211, 7.3657, 6.8197, 6.2806, 5.7467, 5.2167, 4.6896, 4.1647,\n", + " 3.6415, 3.1194, 2.5983, 2.0778, 1.5579, 1.0383, 0.5190]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.2069, 1.2105, 1.1909, 1.1543, 1.1050, 1.0463, 0.9806, 0.9097, 0.8349,\n", + " 0.7572, 0.6773, 0.5957, 0.5130, 0.4293, 0.3450, 0.2601, 0.1749, 0.0894])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.6070e-06, grad_fn=) , base rewards= tensor([9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.6815, 9.0739,\n", + " 8.4891, 7.9211, 7.3657, 6.8197, 6.2806, 5.7467, 5.2167, 4.6896, 4.1647,\n", + " 3.6415, 3.1194, 2.5983, 2.0778, 1.5579, 1.0383, 0.5190]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.2069, 1.2105, 1.1909, 1.1543, 1.1050, 1.0463, 0.9806, 0.9097, 0.8349,\n", + " 0.7572, 0.6773, 0.5957, 0.5130, 0.4293, 0.3450, 0.2601, 0.1749, 0.0894])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8020e-06, grad_fn=) , base rewards= tensor([10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 9.5920,\n", + " 9.0076, 8.4398, 7.8845, 7.3385, 6.7995, 6.2656, 5.7356, 5.2085,\n", + " 4.6836, 4.1603, 3.6383, 3.1172, 2.5967, 2.0768, 1.5572, 1.0379,\n", + " 0.5189]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.2928, 1.2964, 1.2768, 1.2402, 1.1909, 1.1322, 1.0665, 0.9956, 0.9208,\n", + " 0.8431, 0.7632, 0.6817, 0.5989, 0.5152, 0.4309, 0.3460, 0.2608, 0.1753,\n", + " 0.0895])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(1.8020e-06, grad_fn=) , base rewards= tensor([10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 10.1988, 9.5920,\n", + " 9.0076, 8.4398, 7.8845, 7.3385, 6.7995, 6.2656, 5.7356, 5.2085,\n", + " 4.6836, 4.1603, 3.6383, 3.1172, 2.5967, 2.0768, 1.5572, 1.0379,\n", + " 0.5189]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.2928, 1.2964, 1.2768, 1.2402, 1.1909, 1.1322, 1.0665, 0.9956, 0.9208,\n", + " 0.8431, 0.7632, 0.6817, 0.5989, 0.5152, 0.4309, 0.3460, 0.2608, 0.1753,\n", + " 0.0895])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(2.0076e-06, grad_fn=) , base rewards= tensor([10.7145, 10.7145, 10.7145, 10.7145, 10.7145, 10.7145, 10.1093, 9.5256,\n", + " 8.9582, 8.4031, 7.8572, 7.3182, 6.7843, 6.2544, 5.7273, 5.2024,\n", + " 4.6791, 4.1571, 3.6359, 3.1155, 2.5955, 2.0760, 1.5567, 1.0377,\n", + " 0.5188]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.3788, 1.3824, 1.3628, 1.3262, 1.2769, 1.2182, 1.1525, 1.0816, 1.0068,\n", + " 0.9291, 0.8492, 0.7677, 0.6849, 0.6013, 0.5169, 0.4321, 0.3468, 0.2613,\n", + " 0.1755, 0.0896])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(2.0076e-06, grad_fn=) , base rewards= tensor([10.7145, 10.7145, 10.7145, 10.7145, 10.7145, 10.7145, 10.1093, 9.5256,\n", + " 8.9582, 8.4031, 7.8572, 7.3182, 6.7843, 6.2544, 5.7273, 5.2024,\n", + " 4.6791, 4.1571, 3.6359, 3.1155, 2.5955, 2.0760, 1.5567, 1.0377,\n", + " 0.5188]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.3788, 1.3824, 1.3628, 1.3262, 1.2769, 1.2182, 1.1525, 1.0816, 1.0068,\n", + " 0.9291, 0.8492, 0.7677, 0.6849, 0.6013, 0.5169, 0.4321, 0.3468, 0.2613,\n", + " 0.1755, 0.0896])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(2.2236e-06, grad_fn=) , base rewards= tensor([11.2269, 11.2269, 11.2269, 11.2269, 11.2269, 10.6249, 10.0427, 9.4761,\n", + " 8.9214, 8.3757, 7.8368, 7.3030, 6.7730, 6.2460, 5.7211, 5.1978,\n", + " 4.6757, 4.1546, 3.6341, 3.1142, 2.5946, 2.0754, 1.5563, 1.0374,\n", + " 0.5187]) return= 149264.33339377245\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5552, 0.5797, 0.5922, 0.5985, 0.6016, 0.6032, 0.6040, 0.6044,\n", + " 0.6046, 0.6047, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048,\n", + " 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6048, 0.6084])\n", + "finalReturns: tensor([1.4648, 1.4684, 1.4489, 1.4123, 1.3630, 1.3043, 1.2386, 1.1677, 1.0929,\n", + " 1.0152, 0.9353, 0.8538, 0.7711, 0.6874, 0.6031, 0.5182, 0.4330, 0.3474,\n", + " 0.2617, 0.1758, 0.0897])\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 4\u001b[0m ep\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100_000\u001b[39m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(game\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m----> 7\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mep\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m50_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mclc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperParams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\Find the problem\\Actor critic\\learningBase.py:461\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage\u001b[1;34m(self, stage, episodes, print_step, prob_break_limit_ln, clc, options, lr, just_stage)\u001b[0m\n\u001b[0;32m 458\u001b[0m probs_lst_pre \u001b[38;5;241m=\u001b[39m probs_lst\n\u001b[0;32m 460\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolicy\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m--> 461\u001b[0m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 462\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim\u001b[38;5;241m.\u001b[39mstep()\n\u001b[0;32m 464\u001b[0m \u001b[38;5;66;03m# if episode != 0:\u001b[39;00m\n\u001b[0;32m 465\u001b[0m \u001b[38;5;66;03m# self.meanStageValue = (\u001b[39;00m\n\u001b[0;32m 466\u001b[0m \u001b[38;5;66;03m# (self.meanStageValue*episode)+rewards)/(episode+1)\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 469\u001b[0m \u001b[38;5;66;03m# self.returns[iteration][episode] = returns\u001b[39;00m\n\u001b[0;32m 470\u001b[0m \u001b[38;5;66;03m# self.loss[iteration][episode] = loss\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m 477\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m 478\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[0;32m 479\u001b[0m Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[0;32m 480\u001b[0m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 485\u001b[0m inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[0;32m 486\u001b[0m )\n\u001b[1;32m--> 487\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 488\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[0;32m 489\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\autograd\\__init__.py:197\u001b[0m, in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m 192\u001b[0m retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[0;32m 194\u001b[0m \u001b[38;5;66;03m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[0;32m 195\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[0;32m 196\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[1;32m--> 197\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess-lr 0.000005.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess-lr 0.000005.ipynb new file mode 100644 index 0000000..d0037c5 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess-lr 0.000005.ipynb @@ -0,0 +1,1415 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[10]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.000005, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 0, 4, 2, 3, 6, 6, 2, 5, 4, 5, 0, 0, 3, 3, 37, 1, 0, 5,\n", + " 4, 4, 12, 2, 3, 6, 4])\n", + "loss= tensor(-0.0041, grad_fn=) , base rewards= tensor([0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641,\n", + " 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641,\n", + " 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641, 0.0641]) return= 99177.45554069476\n", + "probs of actions: tensor([0.1769, 0.0849, 0.1461, 0.1454, 0.0396, 0.0377, 0.1560, 0.0634, 0.0820,\n", + " 0.0578, 0.1771, 0.1707, 0.1439, 0.1486, 0.0016, 0.2034, 0.1790, 0.0582,\n", + " 0.0830, 0.0832, 0.0090, 0.1251, 0.1347, 0.0393, 0.0770],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5222, 0.5477, 0.5582, 0.5676, 0.5617, 0.5604, 0.5402, 0.5386,\n", + " 0.5322, 0.5343, 0.5158, 0.5013, 0.5018, 0.3661, 0.6310, 0.4079, 0.2673,\n", + " 0.1941, 0.1445, 0.0992, 0.1040, 0.0819, 0.0659, 0.0625])\n", + "finalReturns: tensor([-0.0016])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([1, 2, 2, 1, 0, 0, 1, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 3, 0, 1,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739,\n", + " 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739,\n", + " 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739, 0.4739]) return= 126919.37248405868\n", + "probs of actions: tensor([0.3551, 0.1303, 0.1281, 0.3517, 0.3609, 0.3817, 0.3463, 0.0219, 0.3727,\n", + " 0.3534, 0.3841, 0.3594, 0.3400, 0.3724, 0.3876, 0.3679, 0.3919, 0.3727,\n", + " 0.3886, 0.3449, 0.3949, 0.0528, 0.3974, 0.3398, 0.4969],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5270, 0.5430, 0.5555, 0.5611, 0.5614, 0.5616, 0.5640, 0.5535,\n", + " 0.5336, 0.5190, 0.5044, 0.4973, 0.4920, 0.4845, 0.4789, 0.4748, 0.4717,\n", + " 0.4693, 0.4675, 0.4697, 0.4670, 0.4768, 0.4731, 0.4739])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 2, 13, 1, 2, 0, 1, 1, 1, 0, 3, 1, 1, 0, 2, 3, 2, 2, 6,\n", + " 2, 3, 3, 3, 2, 6, 2])\n", + "loss= tensor(0.0754, grad_fn=) , base rewards= tensor([0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183,\n", + " 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183,\n", + " 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.6183, 0.3054]) return= 90373.82186963504\n", + "probs of actions: tensor([0.1943, 0.0031, 0.2556, 0.2163, 0.1269, 0.2706, 0.2555, 0.2437, 0.1299,\n", + " 0.1510, 0.2788, 0.2601, 0.1410, 0.2076, 0.1597, 0.1900, 0.2015, 0.0299,\n", + " 0.2086, 0.1636, 0.1658, 0.1675, 0.2175, 0.0344, 0.1401],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5142, 0.5875, 0.5045, 0.4503, 0.4049, 0.3756, 0.3543, 0.3389,\n", + " 0.3237, 0.3224, 0.3152, 0.3100, 0.3029, 0.3029, 0.3065, 0.3061, 0.3026,\n", + " 0.3167, 0.3132, 0.3138, 0.3142, 0.3150, 0.3093, 0.3218])\n", + "finalReturns: tensor([0.0128, 0.0164])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([3, 4, 1, 2, 3, 0, 2, 5, 3, 4, 3, 8, 6, 4, 1, 7, 1, 0, 1, 6, 3, 5, 4, 5,\n", + " 0])\n", + "loss= tensor(0.0470, grad_fn=) , base rewards= tensor([1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159,\n", + " 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159,\n", + " 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 1.0159, 0.5013]) return= 130823.96693736671\n", + "probs of actions: tensor([0.1332, 0.1166, 0.1465, 0.1172, 0.1442, 0.0835, 0.1278, 0.1269, 0.1455,\n", + " 0.1274, 0.1411, 0.0461, 0.0938, 0.1160, 0.1624, 0.0603, 0.1582, 0.0662,\n", + " 0.1770, 0.0931, 0.1382, 0.1103, 0.1075, 0.1716, 0.3267],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.5331, 0.5563, 0.5613, 0.5685, 0.5527, 0.5290, 0.5169, 0.5219,\n", + " 0.5165, 0.5172, 0.5082, 0.5264, 0.5328, 0.5303, 0.5116, 0.5277, 0.5147,\n", + " 0.5012, 0.4914, 0.5070, 0.5044, 0.5118, 0.5121, 0.5192])\n", + "finalReturns: tensor([0.0154, 0.0179])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 9, 7, 6, 3, 2, 1, 7, 6, 6, 7, 7, 5, 3, 6, 3, 7, 39, 2,\n", + " 7, 1, 3, 7, 23, 8, 0])\n", + "loss= tensor(0.3852, grad_fn=) , base rewards= tensor([0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253,\n", + " 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.4253,\n", + " 0.4253, 0.4253, 0.4253, 0.4253, 0.4253, 0.2570, 0.1183]) return= 102213.34233681732\n", + "probs of actions: tensor([0.0542, 0.1056, 0.1595, 0.0707, 0.0480, 0.0658, 0.1157, 0.1408, 0.1364,\n", + " 0.1052, 0.1117, 0.1286, 0.0715, 0.1352, 0.0709, 0.1185, 0.0007, 0.0511,\n", + " 0.0992, 0.0644, 0.0689, 0.0999, 0.0038, 0.1850, 0.3666],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.5520, 0.5811, 0.5510, 0.5166, 0.4880, 0.4587, 0.4622, 0.4605,\n", + " 0.4579, 0.4604, 0.4646, 0.4608, 0.4473, 0.4520, 0.4395, 0.2993, 0.5708,\n", + " 0.4003, 0.3130, 0.2362, 0.1864, 0.1154, 0.1784, 0.1658])\n", + "finalReturns: tensor([0.0342, 0.0871, 0.0474])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 4, 2, 8, 3, 2, 12, 7, 11, 8, 8, 8, 7, 4, 7, 8, 8, 11, 8,\n", + " 9, 0, 1, 5, 10, 7, 0])\n", + "loss= tensor(0.3711, grad_fn=) , base rewards= tensor([1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408,\n", + " 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 1.2408,\n", + " 1.2408, 1.2408, 1.2408, 1.2408, 1.2408, 0.8124, 0.4002]) return= 119651.61623007145\n", + "probs of actions: tensor([0.0670, 0.0342, 0.1689, 0.0479, 0.0376, 0.0533, 0.1097, 0.0371, 0.1842,\n", + " 0.1713, 0.1777, 0.1057, 0.0625, 0.1019, 0.1737, 0.1735, 0.0368, 0.1733,\n", + " 0.0741, 0.0296, 0.0486, 0.0835, 0.0712, 0.1240, 0.4035],\n", + " grad_fn=)\n", + "rewards: tensor([0.5096, 0.5380, 0.5454, 0.5837, 0.5355, 0.4828, 0.4991, 0.4794, 0.4898,\n", + " 0.4827, 0.4775, 0.4751, 0.4720, 0.4538, 0.4513, 0.4539, 0.4502, 0.4677,\n", + " 0.4646, 0.4750, 0.4461, 0.4260, 0.4184, 0.4400, 0.4474])\n", + "finalReturns: tensor([0.0650, 0.0750, 0.0472])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 7, 8, 9, 8, 8, 28, 6, 6, 8, 5, 10, 19, 11, 15, 11, 9, 5, 10,\n", + " 16, 18, 3, 10, 10, 8, 1])\n", + "loss= tensor(0.6463, grad_fn=) , base rewards= tensor([0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650,\n", + " 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650, 0.8650,\n", + " 0.8650, 0.8650, 0.8650, 0.8650, 0.6164, 0.3940, 0.1902]) return= 87331.56326370737\n", + "probs of actions: tensor([0.0813, 0.1563, 0.0933, 0.1813, 0.1762, 0.0013, 0.0833, 0.0719, 0.1699,\n", + " 0.0560, 0.0761, 0.0090, 0.0641, 0.0060, 0.0550, 0.0923, 0.0548, 0.0865,\n", + " 0.0119, 0.0104, 0.0308, 0.0801, 0.0775, 0.2282, 0.3597],\n", + " grad_fn=)\n", + "rewards: tensor([0.5063, 0.5431, 0.5747, 0.5515, 0.5296, 0.4414, 0.5779, 0.4651, 0.3856,\n", + " 0.3423, 0.2931, 0.2508, 0.2869, 0.2640, 0.2759, 0.2703, 0.2636, 0.2371,\n", + " 0.2199, 0.2269, 0.2743, 0.2386, 0.2366, 0.2387, 0.2390])\n", + "finalReturns: tensor([0.0880, 0.0980, 0.0838, 0.0488])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([20, 8, 11, 17, 1, 6, 8, 8, 34, 30, 13, 19, 30, 10, 8, 11, 11, 10,\n", + " 24, 12, 8, 4, 10, 7, 0])\n", + "loss= tensor(0.6870, grad_fn=) , base rewards= tensor([1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402,\n", + " 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402, 1.0402,\n", + " 1.0402, 1.0402, 1.0402, 1.0402, 0.7372, 0.4691, 0.2256]) return= 84034.2890702168\n", + "probs of actions: tensor([0.0098, 0.1224, 0.0705, 0.0343, 0.0240, 0.0595, 0.1390, 0.1186, 0.0016,\n", + " 0.0034, 0.0297, 0.0132, 0.0038, 0.0739, 0.1233, 0.0698, 0.0700, 0.0882,\n", + " 0.0089, 0.0995, 0.1280, 0.0162, 0.0669, 0.0697, 0.5045],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5923, 0.4854, 0.4087, 0.4141, 0.3447, 0.3102, 0.2928, 0.1709,\n", + " 0.2598, 0.3719, 0.3301, 0.2777, 0.3930, 0.3609, 0.3238, 0.3096, 0.3012,\n", + " 0.2432, 0.3177, 0.3154, 0.3014, 0.2686, 0.2716, 0.2672])\n", + "finalReturns: tensor([0.0686, 0.0702, 0.0698, 0.0415])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 3, 8, 1, 6, 11, 9, 14, 12, 11, 5, 1, 8, 10, 9, 44, 12, 2, 12,\n", + " 3, 12, 9, 32, 12, 40, 1])\n", + "loss= tensor(-0.7836, grad_fn=) , base rewards= tensor([0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487,\n", + " 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487, 0.2487,\n", + " 0.2487, 0.2487, 0.2487, 0.1539, 0.0921, 0.0504, 0.0213]) return= 92658.1714471995\n", + "probs of actions: tensor([0.0159, 0.0886, 0.0092, 0.0452, 0.0731, 0.0787, 0.0426, 0.1268, 0.0822,\n", + " 0.0326, 0.0113, 0.0929, 0.0722, 0.0669, 0.0008, 0.1148, 0.0106, 0.1259,\n", + " 0.0177, 0.1069, 0.0536, 0.0135, 0.0947, 0.0009, 0.3425],\n", + " grad_fn=)\n", + "rewards: tensor([ 0.5103, 0.5283, 0.5713, 0.5240, 0.5014, 0.5130, 0.4999, 0.5221,\n", + " 0.5299, 0.5400, 0.5209, 0.4846, 0.4834, 0.4941, 0.3118, 0.6257,\n", + " 0.4191, 0.2441, 0.1832, 0.1060, 0.0867, -0.0289, 0.0762, -0.0852,\n", + " 0.1041])\n", + "finalReturns: tensor([-0.0958, -0.0877, 0.0030, -0.0316, 0.0828])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([18, 7, 17, 12, 16, 10, 6, 11, 39, 17, 13, 21, 16, 12, 14, 21, 15, 21,\n", + " 1, 21, 39, 21, 12, 13, 0])\n", + "loss= tensor(5.1126, grad_fn=) , base rewards= tensor([1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406,\n", + " 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406, 1.5406,\n", + " 1.5406, 1.5406, 1.5406, 1.1639, 0.8329, 0.5342, 0.2587]) return= 97421.89912845095\n", + "probs of actions: tensor([0.0371, 0.0347, 0.0781, 0.1109, 0.0306, 0.0704, 0.0343, 0.0629, 0.0032,\n", + " 0.0658, 0.0413, 0.0368, 0.0357, 0.0988, 0.0516, 0.0416, 0.0125, 0.0343,\n", + " 0.0146, 0.0367, 0.0070, 0.0542, 0.0813, 0.0390, 0.4979],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5861, 0.4739, 0.4607, 0.4126, 0.4144, 0.3916, 0.3497, 0.2003,\n", + " 0.4037, 0.4066, 0.3599, 0.3894, 0.3928, 0.3693, 0.3375, 0.3754, 0.3473,\n", + " 0.4053, 0.3099, 0.2246, 0.4086, 0.4373, 0.4044, 0.4024])\n", + "finalReturns: tensor([0.3367, 0.4888, 0.4112, 0.2726, 0.1436])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([10, 11, 5, 15, 17, 0, 13, 17, 12, 12, 17, 29, 27, 14, 17, 4, 17, 14,\n", + " 6, 18, 21, 29, 18, 14, 0])\n", + "loss= tensor(7.2306, grad_fn=) , base rewards= tensor([2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820,\n", + " 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820, 2.1820,\n", + " 2.1820, 2.1820, 1.7470, 1.3529, 0.9881, 0.6446, 0.3166]) return= 116472.7649252669\n", + "probs of actions: tensor([0.0483, 0.0555, 0.0127, 0.0114, 0.0831, 0.0056, 0.0413, 0.0946, 0.0970,\n", + " 0.0941, 0.0837, 0.0157, 0.0337, 0.0538, 0.0916, 0.0096, 0.0855, 0.0542,\n", + " 0.0227, 0.0584, 0.0665, 0.0281, 0.0827, 0.0564, 0.5697],\n", + " grad_fn=)\n", + "rewards: tensor([0.5012, 0.5485, 0.6005, 0.5076, 0.4847, 0.5085, 0.4293, 0.4155, 0.4420,\n", + " 0.4342, 0.4140, 0.3712, 0.4336, 0.5197, 0.4879, 0.5094, 0.4325, 0.4497,\n", + " 0.4614, 0.4026, 0.4086, 0.3923, 0.4907, 0.4997, 0.5021])\n", + "finalReturns: tensor([0.5139, 0.5463, 0.5319, 0.5044, 0.3572, 0.1855])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([11, 20, 22, 12, 9, 13, 11, 4, 5, 13, 7, 12, 20, 10, 11, 12, 7, 17,\n", + " 24, 48, 21, 20, 10, 10, 1])\n", + "loss= tensor(7.4756, grad_fn=) , base rewards= tensor([1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505,\n", + " 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505, 1.5505,\n", + " 1.5505, 1.5505, 1.0779, 0.6561, 0.3862, 0.2081, 0.0864]) return= 103950.18148310391\n", + "probs of actions: tensor([0.0522, 0.0397, 0.0205, 0.0842, 0.0406, 0.0395, 0.0570, 0.0072, 0.0110,\n", + " 0.0395, 0.0215, 0.0791, 0.0398, 0.0382, 0.0473, 0.0749, 0.0184, 0.0953,\n", + " 0.0354, 0.0018, 0.0747, 0.0453, 0.0256, 0.0463, 0.2868],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5244, 0.5344, 0.5510, 0.5217, 0.4763, 0.4683, 0.4625, 0.4263,\n", + " 0.3896, 0.4106, 0.3886, 0.3696, 0.4308, 0.4194, 0.4134, 0.4234, 0.3836,\n", + " 0.3755, 0.2422, 0.5480, 0.3982, 0.3251, 0.2316, 0.1814])\n", + "finalReturns: tensor([0.3760, 0.6064, 0.4802, 0.3518, 0.2048, 0.0949])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 21, 6, 7, 21, 28, 12, 12, 17, 13, 21, 23, 27, 24, 20, 27, 25, 10,\n", + " 27, 18, 17, 23, 17, 14, 0])\n", + "loss= tensor(5.5775, grad_fn=) , base rewards= tensor([1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294,\n", + " 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294, 1.0294,\n", + " 1.0294, 0.7981, 0.6126, 0.4582, 0.3251, 0.2071, 0.0997]) return= 62162.43694131766\n", + "probs of actions: tensor([0.0690, 0.0814, 0.0112, 0.0175, 0.0726, 0.0095, 0.0652, 0.0640, 0.0946,\n", + " 0.0357, 0.0791, 0.0329, 0.0601, 0.0463, 0.0442, 0.0604, 0.0253, 0.0377,\n", + " 0.0718, 0.0644, 0.0789, 0.0474, 0.1101, 0.0572, 0.6809],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5820, 0.5090, 0.3819, 0.2628, 0.2110, 0.2810, 0.2433, 0.2022,\n", + " 0.2069, 0.1650, 0.1637, 0.1542, 0.1874, 0.2112, 0.1730, 0.1970, 0.2548,\n", + " 0.1584, 0.2158, 0.2099, 0.1765, 0.2080, 0.2085, 0.2145])\n", + "finalReturns: tensor([0.3622, 0.4351, 0.4048, 0.3493, 0.3059, 0.2159, 0.1148])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([17, 32, 12, 17, 21, 8, 17, 30, 23, 5, 20, 24, 12, 19, 0, 18, 11, 13,\n", + " 29, 21, 44, 14, 23, 12, 0])\n", + "loss= tensor(10.3920, grad_fn=) , base rewards= tensor([1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170,\n", + " 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170, 1.2170,\n", + " 1.2170, 0.9824, 0.7798, 0.5996, 0.4354, 0.2827, 0.1383]) return= 75789.24186500885\n", + "probs of actions: tensor([0.0891, 0.0136, 0.0485, 0.0933, 0.0843, 0.0216, 0.0910, 0.0154, 0.0332,\n", + " 0.0074, 0.0456, 0.0543, 0.0568, 0.0392, 0.0032, 0.0625, 0.0296, 0.0314,\n", + " 0.0346, 0.0851, 0.0027, 0.0319, 0.0455, 0.0736, 0.7183],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.4847, 0.5857, 0.4582, 0.3820, 0.3892, 0.3059, 0.2273, 0.2886,\n", + " 0.3370, 0.2477, 0.2331, 0.2895, 0.2451, 0.2831, 0.2037, 0.2343, 0.2199,\n", + " 0.1505, 0.2290, 0.0887, 0.3349, 0.2702, 0.3113, 0.2969])\n", + "finalReturns: tensor([0.4646, 0.5487, 0.5222, 0.6137, 0.4430, 0.3255, 0.1586])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAfVklEQVR4nO3df5DU9Z3n8eeLYcQBIz90tHAggUTKnGgSdArJeZVKwq6Qn1JZzWLFk9pwRZ3n5eLunjnYWEt+sRvX2zXn7emuFY34YxVCXGSTGEOhqex5ihlFg6gs44/AACuTBYwliAO874/+tPY03T39nZ6e6YbXo6prvv3u7+fb7+ZHv/r7/Xz7O4oIzMzMqjVqpBswM7Pm4uAwM7NMHBxmZpaJg8PMzDJxcJiZWSajR7qBoXb66afHtGnTRroNM7Om8tRTT/02ItqrWfe4C45p06bR1dU10m2YmTUVSb+pdl0fqjIzs0wGDA5Jd0jaI+m5Eo/9d0kh6fSC2jJJ3ZK2SppXUL9Q0ub02M2SlOpjJK1K9Y2SphWMWSRpW7otqvnVmplZzarZ47gTmF9clDQV+H1ge0HtXGAhMDONuUVSS3r4VmAJMCPd8ttcDOyLiLOBm4Ab0rYmAcuBi4DZwHJJE7O9PDMzG2oDBkdE/BLYW+Khm4CvAYXXLLkUuD8iDkXEK0A3MFvSZODUiHg8ctc4uQtYUDBmZVpeA8xNeyPzgPURsTci9gHrKRFgZmY2vAY1xyHp88DOiHi26KEOYEfB/Z5U60jLxfV+YyLiMPA6cFqFbZXqZ4mkLkldvb29g3lJZmZWpcxnVUkaC3wduKTUwyVqUaE+2DH9ixG3AbcBdHZ2+qqNJ6i1m3Zy48Nb2bX/IGdNaOO6eeewYFbJzxpmVoPBnI77AWA68Gya354CPC1pNrm9gqkF604BdqX6lBJ1Csb0SBoNjCd3aKwH+HjRmF8Mol9rcMVv+J/4YDuPvth7TACUCoau3+zlvo07OFJ0leed+w9y7apnuHbVM+/URgmOBnRU2GaW564llBxy1sxUzWXV05lOP46I80o89irQGRG/lTQT+Adyk9lnARuAGRFxRNKvgK8AG4GfAv87In4q6Rrg/Ij4z5IWAl+IiC+myfGngAvSUz0NXBgRpeZb3tHZ2Rn+HkdjKnyzHN/Wyu8O9nF0pJsawCjgox+YxGMvlf5n1zGIN/21m3ay7IHNHOw78k6trbWFv/zC+Q4PGzGSnoqIzqrWHSg4JN1H7pP/6cBrwPKIuL3g8VdJwZHufx34MnAYuDYiHkr1TnJnaLUBDwFfiYiQdDJwNzCL3J7Gwoh4OY35MvBn6alWRMQPBnpBx3twNPIn1cLeTm4dxaHDRzl6Ah04nNDWigT7D/SV/btZu2knf7r62WP2kPLjx40Z3ZB/t3b8G9LgaDYjGRz1flNvtE+qxXsQbxw6zJETKSkymDi2lc98aDKrntxBX5V/Rq2jxI2Xf9jhYcPCwVHn4Mi/Ye7cfxBRZsY+GXdSCwfePlLV8fKBjrcfePsw+w70HfMcHRPaeGzpJ+v2euHYkHjzUB99jX6c6Tg0tnUUY1pb2Hegr9+/vXwwlZqfMauGg6OOwXH92s3c+8T2imGR1SjgA2eMY9ueNwe9jRap3+GP/P1qj8Gv3bSTb6zbwv6DuWDKv0HtP9DH+LZWXj/YN6Sv2eqvdZQ45eTRFQ+dmeU5OOoUHGs37ex3lk6zGSX4my9+pN+bR+7w16856N2H456AL815L99ZcH6/ej0OsTbyXJyV5uCoU3DM+tbPSx4qMms2Eyqc1ZY/BFZpr7VSMJSaiysXWtY4HBx1Co5pS39Sl+2aNbrCifpywRCkQHqrr+zZdBPHtrL8czO999GAsgTHcff7OOpl7aadI92C2YjpOxrHfKGyUD4n8nNk5ew70MeyBzYD9NtDyZ9sUryXA/iQVwPyHkcV1m7ayXU/fLbq0yjNrLL8mYBZTzZphC9KHq/zNz5UNcTBcfF3H2Hn/oNDuk2zE92EttYB91DKqfaswXpcKqaRvks1lBwcQxwc05f+xKeimjWZsa2j6Dsa9B15939vuVOUr1+7+Z1rnrVIXHHR1JIT+eU+RLZI/PUXs39Zs5H2Xhwc3uMwsyqNgpJnl11Z4iywSh8is+55lNp7KQ62chfdrAcHRx3mOJr5+xtmNngntYjRo8SBKr7rVHgVhyxXc65WPQ+LOTgcHGY2gkodJhsq9boYZpbgGNRvADzRfPOftox0C2bWRA70Ha1LaEDulOed+w8S5H7vzB+veobr126uy3OV4+9xVMHfFjezRhXAPU9s554ntg/q98MMhvc4BuAv/plZs8j/5st674E4OCrIn/VgZtZM7nlie10/9Do4Krjx4a39TpUzM2sW9ZybdXBU4O9umFmzqufcrIOjghZppFswM2s4Do4y1m7aOegv6ZiZHc8GDA5Jd0jaI+m5gtqNkl6U9GtJ/yhpQsFjyyR1S9oqaV5B/UJJm9NjN0u5j/OSxkhaleobJU0rGLNI0rZ0WzRUL3ognhQ3Myuvmj2OO4H5RbX1wHkR8SHgX4BlAJLOBRYCM9OYWyS1pDG3AkuAGemW3+ZiYF9EnA3cBNyQtjUJWA5cBMwGlkuamP0lZudJcTOz8gYMjoj4JbC3qPbziDic7j4BTEnLlwL3R8ShiHgF6AZmS5oMnBoRj0fuGid3AQsKxqxMy2uAuWlvZB6wPiL2RsQ+cmFVHGB1scuT4mZmZQ3FHMeXgYfScgewo+CxnlTrSMvF9X5jUhi9DpxWYVvHkLREUpekrt7e3ppeDMD4ttaat2FmdryqKTgkfR04DNybL5VYLSrUBzumfzHitojojIjO9vb2yk1XwSdTmZmVN+jgSJPVnwW+FO9eYrcHmFqw2hRgV6pPKVHvN0bSaGA8uUNj5bZVd/t9bSozs7IGFRyS5gP/A/h8RBwoeGgdsDCdKTWd3CT4kxGxG3hD0pw0f3EV8GDBmPwZU5cBj6Qgehi4RNLENCl+SarV3VkT2objaczMmlI1p+PeBzwOnCOpR9Ji4G+B9wDrJT0j6e8AImILsBp4HvgZcE1E5E9Puhr4PrkJ85d4d17kduA0Sd3AnwBL07b2At8GfpVu30q1urtu3jnD8TRmZk1pwMuqR8QVJcq3V1h/BbCiRL0LOK9E/S3g8jLbugO4Y6Aeh1rXb4Yln8zMmpK/OV7k+rWbueeJ7SPdhplZw3JwFFi7aSf3OjTMzCpycBS48eGtpc/3NTOzdzg4krWbdvoy6mZmVXBw4Isampll4eDAFzU0M8vCwYEvamhmloWDA39T3MwsCwcHuW+Kt7W2DLyimZk5OAAWzOrggveOH+k2zMyagoOD3FlVj73ky4yYmVXDwQEse+DXI92CmVnTcHAAB/uOjnQLZmZNw8FhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMhkwOCTdIWmPpOcKapMkrZe0Lf2cWPDYMkndkrZKmldQv1DS5vTYzZKU6mMkrUr1jZKmFYxZlJ5jm6RFQ/aqzcxs0KrZ47gTmF9UWwpsiIgZwIZ0H0nnAguBmWnMLZLyF4G6FVgCzEi3/DYXA/si4mzgJuCGtK1JwHLgImA2sLwwoMzMbGQMGBwR8Uug+HoclwIr0/JKYEFB/f6IOBQRrwDdwGxJk4FTI+LxiAjgrqIx+W2tAeamvZF5wPqI2BsR+4D1HBtgZmY2zAY7x3FmROwGSD/PSPUOYEfBej2p1pGWi+v9xkTEYeB14LQK2zqGpCWSuiR19fb2DvIlmZlZNYZ6clwlalGhPtgx/YsRt0VEZ0R0tre3V9WomZkNzmCD47V0+In0c0+q9wBTC9abAuxK9Skl6v3GSBoNjCd3aKzctszMbAQNNjjWAfmznBYBDxbUF6YzpaaTmwR/Mh3OekPSnDR/cVXRmPy2LgMeSfMgDwOXSJqYJsUvSTUzMxtBowdaQdJ9wMeB0yX1kDvT6bvAakmLge3A5QARsUXSauB54DBwTUQcSZu6mtwZWm3AQ+kGcDtwt6RucnsaC9O29kr6NvCrtN63IsK/NMPMbIQNGBwRcUWZh+aWWX8FsKJEvQs4r0T9LVLwlHjsDuCOgXo0M7Ph42+Om5lZJg4OMzPLxMFhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMnFwmJlZJg4OMzPLxMFhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMnFwmJlZJg4OMzPLxMFhZmaZODjMzCyTmoJD0h9L2iLpOUn3STpZ0iRJ6yVtSz8nFqy/TFK3pK2S5hXUL5S0OT12sySl+hhJq1J9o6RptfRrZma1G3RwSOoA/hvQGRHnAS3AQmApsCEiZgAb0n0knZsenwnMB26R1JI2dyuwBJiRbvNTfTGwLyLOBm4Cbhhsv2ZmNjRqPVQ1GmiTNBoYC+wCLgVWpsdXAgvS8qXA/RFxKCJeAbqB2ZImA6dGxOMREcBdRWPy21oDzM3vjZiZ2cgYdHBExE7gfwLbgd3A6xHxc+DMiNid1tkNnJGGdAA7CjbRk2odabm43m9MRBwGXgdOK+5F0hJJXZK6ent7B/uSzMysCrUcqppIbo9gOnAWME7SlZWGlKhFhXqlMf0LEbdFRGdEdLa3t1du3MzMalLLoarfA16JiN6I6AMeAP498Fo6/ET6uSet3wNMLRg/hdyhrZ60XFzvNyYdDhsP7K2hZzMzq1EtwbEdmCNpbJp3mAu8AKwDFqV1FgEPpuV1wMJ0ptR0cpPgT6bDWW9ImpO2c1XRmPy2LgMeSfMgZmY2QkYPdmBEbJS0BngaOAxsAm4DTgFWS1pMLlwuT+tvkbQaeD6tf01EHEmbuxq4E2gDHko3gNuBuyV1k9vTWDjYfs3MbGgMOjgAImI5sLyofIjc3kep9VcAK0rUu4DzStTfIgWPmZk1Bn9z3MzMMnFwmJlZJg4OMzPLxMFhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMnFwmJlZJg4OMzPLxMFhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMnFwmJlZJg4OMzPLpKbgkDRB0hpJL0p6QdJHJU2StF7StvRzYsH6yyR1S9oqaV5B/UJJm9NjN0tSqo+RtCrVN0qaVku/ZmZWu1r3OP4X8LOI+CDwYeAFYCmwISJmABvSfSSdCywEZgLzgVsktaTt3AosAWak2/xUXwzsi4izgZuAG2rs18zMajTo4JB0KvAx4HaAiHg7IvYDlwIr02orgQVp+VLg/og4FBGvAN3AbEmTgVMj4vGICOCuojH5ba0B5ub3RszMbGTUssfxfqAX+IGkTZK+L2kccGZE7AZIP89I63cAOwrG96RaR1ourvcbExGHgdeB02ro2czMalRLcIwGLgBujYhZwJukw1JllNpTiAr1SmP6b1haIqlLUldvb2/lrs3MrCa1BEcP0BMRG9P9NeSC5LV0+In0c0/B+lMLxk8BdqX6lBL1fmMkjQbGA3uLG4mI2yKiMyI629vba3hJZmY2kEEHR0T8K7BD0jmpNBd4HlgHLEq1RcCDaXkdsDCdKTWd3CT4k+lw1huS5qT5i6uKxuS3dRnwSJoHMTOzETK6xvFfAe6VdBLwMvBH5MJotaTFwHbgcoCI2CJpNblwOQxcExFH0nauBu4E2oCH0g1yE+93S+omt6exsMZ+zcysRjUFR0Q8A3SWeGhumfVXACtK1LuA80rU3yIFj5mZNQZ/c9zMzDJxcJiZWSYODjMzy8TBYWZmmTg4zMwsEweHmZll4uAwM7NMHBxmZpaJg8PMzDJxcJiZWSYODjMzy8TBYWZmmTg4zMwsEweHmZll4uAwM7NMHBxmZpaJg8PMzDJxcJiZWSYODjMzy8TBYWZmmdQcHJJaJG2S9ON0f5Kk9ZK2pZ8TC9ZdJqlb0lZJ8wrqF0ranB67WZJSfYykVam+UdK0Wvs1M7PaDMUex1eBFwruLwU2RMQMYEO6j6RzgYXATGA+cIukljTmVmAJMCPd5qf6YmBfRJwN3ATcMAT9mplZDWoKDklTgM8A3y8oXwqsTMsrgQUF9fsj4lBEvAJ0A7MlTQZOjYjHIyKAu4rG5Le1Bpib3xsxM7ORUesex/eArwFHC2pnRsRugPTzjFTvAHYUrNeTah1pubjeb0xEHAZeB04rbkLSEkldkrp6e3trfElmZs2vtY4z2IPetKTPAnsi4qlqh5SoRYV6pTH9CxG3RURnRHS2t7dX2Y6Z2fFr1Kj6JcfoGsZeDHxe0qeBk4FTJd0DvCZpckTsToeh9qT1e4CpBeOnALtSfUqJeuGYHkmjgfHA3hp6NjM7IRw6fHTglQZp0JEUEcsiYkpETCM36f1IRFwJrAMWpdUWAQ+m5XXAwnSm1HRyk+BPpsNZb0iak+Yvrioak9/WZek5jtnjMDOz4VPLHkc53wVWS1oMbAcuB4iILZJWA88Dh4FrIuJIGnM1cCfQBjyUbgC3A3dL6ia3p7GwDv2amVkGQxIcEfEL4Bdp+d+AuWXWWwGsKFHvAs4rUX+LFDxmZtYY/M1xMzPLxMFhZmaZODjMzCwTB4eZmWXi4DAzs0wcHGZmlomDw8zMMnFwmJlZJg4OMzPLxMFhZnYcqucvLnJwmJkdh84+Y1zdtu3gMDM7DnXvebNu23ZwmJkdh+r5+yccHGZmlomDw8zMMnFwmJlZJg4OMzPLxMFhZmaZODjMzCwTB4eZmWUy6OCQNFXSo5JekLRF0ldTfZKk9ZK2pZ8TC8Ysk9QtaaukeQX1CyVtTo/dLEmpPkbSqlTfKGlaDa/VzMyGQC17HIeBP42IfwfMAa6RdC6wFNgQETOADek+6bGFwExgPnCLpJa0rVuBJcCMdJuf6ouBfRFxNnATcEMN/ZqZ2RAYdHBExO6IeDotvwG8AHQAlwIr02orgQVp+VLg/og4FBGvAN3AbEmTgVMj4vGICOCuojH5ba0B5ub3RszMrLyWOr5TDskcRzqENAvYCJwZEbshFy7AGWm1DmBHwbCeVOtIy8X1fmMi4jDwOnBaiedfIqlLUldvb+9QvCQzs6Z2pI7XHKk5OCSdAvwIuDYifldp1RK1qFCvNKZ/IeK2iOiMiM729vaBWjYzsxrUFBySWsmFxr0R8UAqv5YOP5F+7kn1HmBqwfApwK5Un1Ki3m+MpNHAeGBvLT2bmVltajmrSsDtwAsR8TcFD60DFqXlRcCDBfWF6Uyp6eQmwZ9Mh7PekDQnbfOqojH5bV0GPJLmQczMbISMrmHsxcB/BDZLeibV/gz4LrBa0mJgO3A5QERskbQaeJ7cGVnXRMSRNO5q4E6gDXgo3SAXTHdL6ia3p7Gwhn7NzGwIDDo4IuL/Uv63E84tM2YFsKJEvQs4r0T9LVLwmJlZY/A3x83MLBMHh5mZZeLgMDOzTBwcZmaWiYPD6q7wDIqJY1u5cs57aWttKbu+mTW2Wk7HteNcx4Q2PvHBdu7duJ3BfnumrbWFv/zC+SyY1dGv3vm+Sdz48FZ27T/IWel5Hn2x95371807B4BvrNvC/oN9mZ7zyjnvpfN9kzKNFTBhbCv7DpRev611FAf7jg64nRlnjOPV375JFauaNS0Hxwmg8M177aadA76hFr/Zd75vEsse2MzBviMDjgH6BcJ18845JjQAFszqKFkvtd7aTTvf2eb4tlbefPswfRUuxPPoi718Z8GxYQWwdtPOY16LgC+lsCl+rPDP4vq1m7lv4w6OVEjRA28fZdtffIaZf/4z3ny7/J+XWb21tdbvgJKOty9id3Z2RldXV6Yx05b+pE7dDN7FH5jE9PZT3nmjapG44qKpFd+4BGU/vVd6ky58Yy63fvE6WZ9jKOV72bn/YMnHBbzy3c8MOL5U79X8WQBMX/qTYy+aVvDcpQLKbDh97w8/kun/pKSnIqKzqnUdHI0VHBPHtrL8czPL/oVfv3Yz9zyx/Zj6lXPey3cWnF/v9hrKxd99pGR4dExo47Glnxzx5y4MOFHi6pxlTBzbymc+NJlHX+wtG46lZHkOO/69WuHDUylZgsOHqhrEQIGRlw+H4j2REy00AK6bd07JQ0v5+ZGRfu7Cw3GFezLl3txL7SmV2nOp5rBgqT0ngOt++Cx9R4/toDCsire3dtPOkuNaW8SNl32YH3Zt57GXSl979KQWMW7MaPYd6HOwDaNRdf6tRd7jYGT2OAY6nGLVqfbQUiM9d9Y9paF8jcVzXNV+YBloXLXbHegwY7UnIQCMbR3FmNaWsic0nMgGcwTCh6qaIDiG43CKNaZKexHDFXojrZo9qUqH6Yo/eM361s8dIElb6yhe+PanMo/LEhz+HkedjDup/PcUBMNyOMUa04JZHfzlF86nY0IbIvch4kQKDaj8Z7BgVgePLf0k3/vDj5S9iupZE9r63V/+uZk1fzdI5PZi8sa2jmLi2NaatlnqOcoZ2zqKjqLXlVUufD9U0zaq4TmOIVZ4aue1q54puU7ACfUmYceq9nTk49lAfwYLZnXQ9Zu93PvE9n5zI6XmsfLbqWYeCcrPtTxf4pP6QGfItbW28AcXdvSbH/rEB9v50VM7j9mj+oMLO0qe3AJwsO8of1Fm7qzwdPr83liL9M4855EIOobxUK2DYwgV/8V985+2lNx9rvVThdmJ4jsLzj/my6LVfDeo3DxSfk+l0mOltgv0+y6RBPsP9FXsp1zf5c6WO2tC2zHPVbz9RvnA4TkOhm6Oo/j0Nx/LNhsZA82hjOT/y0Z9X/DpuCOg1F7EQJ8ezKw+qvm/N1L/L4+H9wXvcVD7HkcjfFowM6uFz6oaRi2SQ8PMTihNERyS5kvaKqlb0tKR7ievrbWFv/7ihx0aZnZCafjgkNQC/B/gU8C5wBWSzh2JXmacMe6EPvfezAyaY3J8NtAdES8DSLofuBR4frgbOfD2UX/b28xOeA2/xwF0ADsK7vek2jskLZHUJamrt7e3bo3synClUjOz41UzBEepb+n3OxUsIm6LiM6I6Gxvb69bI+W+IGRmdiJphuDoAaYW3J8C7BruJobrct1mZo2uGYLjV8AMSdMlnQQsBNYN5RMMdAkQT4Sbmb2r4SfHI+KwpP8KPAy0AHdExJahfI5yv5THYWFmdqyGDw6AiPgp8NN6bf94uASAmdlwaYrgGA6NctVJM7NG1wxzHGZm1kAcHGZmlomDw8zMMnFwmJlZJg4OMzPL5Lj7RU6SeoHf1LCJ04HfDlE79dZMvUJz9dtMvUJz9dtMvUJz9VtLr++LiKqu2XTcBUetJHVV+1uwRloz9QrN1W8z9QrN1W8z9QrN1e9w9epDVWZmlomDw8zMMnFwHOu2kW4gg2bqFZqr32bqFZqr32bqFZqr32Hp1XMcZmaWifc4zMwsEweHmZll4uBIJM2XtFVSt6SldX6uOyTtkfRcQW2SpPWStqWfEwseW5b62ippXkH9Qkmb02M3S1Kqj5G0KtU3SppWMGZReo5tkhZV0etUSY9KekHSFklfbfB+T5b0pKRnU7/fbOR+05gWSZsk/bgJen01Pc8zkroauV9JEyStkfRi+vf70Qbu9Zz0Z5q//U7StY3aLxFxwt/I/YKol4D3AycBzwLn1vH5PgZcADxXUPsrYGlaXgrckJbPTf2MAaanPlvSY08CHyX3e9kfAj6V6v8F+Lu0vBBYlZYnAS+nnxPT8sQBep0MXJCW3wP8S+qpUfsVcEpabgU2AnMatd807k+AfwB+3Mj/FtK4V4HTi2oN2S+wEvhPafkkYEKj9lri/ehfgfc1ar8j/qbdCLf0h/xwwf1lwLI6P+c0+gfHVmByWp4MbC3VC7nfhPjRtM6LBfUrgL8vXCctjyb3TVIVrpMe+3vgiox9Pwj8fjP0C4wFngYuatR+gSnABuCTvBscDdlrWu9Vjg2OhusXOBV4hXQCUCP3WqL3S4DHGrlfH6rK6QB2FNzvSbXhdGZE7AZIP88YoLeOtFxc7zcmIg4DrwOnVdhWVdKu7Sxyn+Ibtt906OcZYA+wPiIaud/vAV8DjhbUGrVXgAB+LukpSUsauN/3A73AD9JhwO9LGtegvRZbCNyXlhuyXwdHjkrUYti7KK1cb5V6HsyYyk1IpwA/Aq6NiN9VWnUQzz2k/UbEkYj4CLlP87MlnVdh9RHrV9JngT0R8VSF/voNGcTzDvW/hYsj4gLgU8A1kj5WYd2R7Hc0ucPBt0bELOBNcod6ymmEP1sknQR8HvjhQKsO4rmHrF8HR04PMLXg/hRg1zD38JqkyQDp554BeutJy8X1fmMkjQbGA3srbKsiSa3kQuPeiHig0fvNi4j9wC+A+Q3a78XA5yW9CtwPfFLSPQ3aKwARsSv93AP8IzC7QfvtAXrS3ibAGnJB0oi9FvoU8HREvJbuN2a/1R53O55v5D6dvExukik/OT6zzs85jf5zHDfSfxLsr9LyTPpPgr3Mu5NgvyI38ZufBPt0ql9D/0mw1Wl5ErnjvhPT7RVg0gB9CrgL+F5RvVH7bQcmpOU24J+BzzZqvwV9f5x35zgasldgHPCeguX/Ry6UG7XffwbOScvfSH02ZK8FPd8P/FHD/z+r1xtjs92AT5M7Y+gl4Ot1fq77gN1AH7m0X0zuWOMGYFv6Oalg/a+nvraSzpBI9U7gufTY3/LulQBOJrer203uDIv3F4z5cqp3F/4DrdDrfyC32/pr4Jl0+3QD9/shYFPq9zngz1O9IfstGPdx3g2OhuyV3LzBs+m2hfT/pIH7/QjQlf4trCX3ptiQvaYxY4F/A8YX1BqyX19yxMzMMvEch5mZZeLgMDOzTBwcZmaWiYPDzMwycXCYmVkmDg4zM8vEwWFmZpn8f/65YaDspee1AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([16, 21, 18, 18, 25, 31, 23, 10, 8, 27, 27, 17, 30, 31, 10, 21, 27, 21,\n", + " 25, 31, 27, 20, 27, 12, 0])\n", + "loss= tensor(13.3220, grad_fn=) , base rewards= tensor([2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852,\n", + " 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852, 2.0852,\n", + " 1.6842, 1.3529, 1.0696, 0.8197, 0.5936, 0.3845, 0.1878]) return= 101669.50207833895\n", + "probs of actions: tensor([0.0321, 0.0945, 0.0594, 0.0623, 0.0301, 0.0295, 0.0420, 0.0148, 0.0146,\n", + " 0.1045, 0.1117, 0.0763, 0.0166, 0.0335, 0.0166, 0.0963, 0.1149, 0.0892,\n", + " 0.0399, 0.0502, 0.1268, 0.0485, 0.1261, 0.0567, 0.6787],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5392, 0.5306, 0.5239, 0.4888, 0.4777, 0.5266, 0.5215, 0.4458,\n", + " 0.3177, 0.3327, 0.3881, 0.3037, 0.3215, 0.4293, 0.3437, 0.3117, 0.3569,\n", + " 0.3320, 0.3061, 0.3545, 0.3936, 0.3424, 0.4100, 0.3835])\n", + "finalReturns: tensor([0.7937, 0.8378, 0.8371, 0.8144, 0.7097, 0.5423, 0.4090, 0.1957])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([30, 14, 11, 25, 17, 27, 25, 17, 31, 21, 29, 29, 24, 34, 16, 8, 20, 6,\n", + " 16, 28, 42, 17, 21, 19, 0])\n", + "loss= tensor(8.2201, grad_fn=) , base rewards= tensor([0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104,\n", + " 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104, 0.8104,\n", + " 0.6286, 0.4882, 0.3752, 0.2809, 0.1995, 0.1272, 0.0613]) return= 52969.51627539582\n", + "probs of actions: tensor([0.0196, 0.0299, 0.0204, 0.0383, 0.0656, 0.1196, 0.0391, 0.0650, 0.0392,\n", + " 0.1022, 0.0415, 0.0451, 0.0879, 0.0088, 0.0275, 0.0104, 0.0452, 0.0046,\n", + " 0.0212, 0.0172, 0.0055, 0.0459, 0.0939, 0.0351, 0.7124],\n", + " grad_fn=)\n", + "rewards: tensor([ 0.4212, 0.6184, 0.4627, 0.2967, 0.2926, 0.2003, 0.2023, 0.2245,\n", + " 0.1296, 0.1948, 0.1407, 0.1493, 0.1823, 0.1171, 0.2262, 0.2157,\n", + " 0.1436, 0.1782, 0.1263, 0.0716, -0.0038, 0.1935, 0.1595, 0.1627,\n", + " 0.1909])\n", + "finalReturns: tensor([0.2686, 0.2722, 0.2864, 0.3277, 0.4258, 0.3136, 0.2265, 0.1296])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 11, 21, 23, 32, 25, 25, 27, 24, 12, 29, 6, 21, 23, 32, 27, 23,\n", + " 27, 17, 27, 31, 17, 21, 0])\n", + "loss= tensor(8.0572, grad_fn=) , base rewards= tensor([0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418,\n", + " 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.8418, 0.6497,\n", + " 0.5062, 0.3946, 0.3043, 0.2284, 0.1626, 0.1039, 0.0501]) return= 51500.619709822255\n", + "probs of actions: tensor([0.0505, 0.0504, 0.0157, 0.1062, 0.0453, 0.0177, 0.0453, 0.0438, 0.1457,\n", + " 0.0927, 0.0285, 0.0487, 0.0044, 0.0925, 0.0512, 0.0199, 0.1700, 0.0535,\n", + " 0.1960, 0.0362, 0.1791, 0.0625, 0.0534, 0.1183, 0.6531],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.5185, 0.3451, 0.2724, 0.1841, 0.2199, 0.1987, 0.1729,\n", + " 0.1819, 0.2132, 0.1075, 0.1996, 0.1184, 0.1110, 0.0666, 0.1192, 0.1462,\n", + " 0.1226, 0.1728, 0.1114, 0.0971, 0.1801, 0.1454, 0.1841])\n", + "finalReturns: tensor([0.4372, 0.5101, 0.5073, 0.4963, 0.4138, 0.3782, 0.3469, 0.2256, 0.1339])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 27, 21, 20, 27, 32, 19, 27, 27, 27, 27, 24, 12, 30, 14, 27, 38, 28,\n", + " 25, 19, 34, 31, 18, 9, 0])\n", + "loss= tensor(21.6827, grad_fn=) , base rewards= tensor([1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122,\n", + " 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.3122, 1.0489,\n", + " 0.8420, 0.6729, 0.5298, 0.4046, 0.2922, 0.1888, 0.0920]) return= 69457.65943587266\n", + "probs of actions: tensor([0.2122, 0.1922, 0.0955, 0.0416, 0.1775, 0.0184, 0.0256, 0.2100, 0.1818,\n", + " 0.1886, 0.2026, 0.0956, 0.0205, 0.0223, 0.0243, 0.1832, 0.0007, 0.0167,\n", + " 0.0466, 0.0219, 0.0123, 0.0781, 0.0416, 0.0110, 0.6337],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5532, 0.4902, 0.4098, 0.3153, 0.2633, 0.3282, 0.2522, 0.2465,\n", + " 0.2422, 0.2390, 0.2520, 0.2851, 0.1706, 0.2590, 0.1780, 0.1189, 0.2240,\n", + " 0.2427, 0.2629, 0.1628, 0.2072, 0.2818, 0.2785, 0.2441])\n", + "finalReturns: tensor([0.7106, 0.8550, 0.8379, 0.7643, 0.6446, 0.6070, 0.5122, 0.3338, 0.1521])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 27, 27, 23, 23, 27, 17, 29, 36, 18, 27, 40, 40, 27, 21, 25, 25, 25,\n", + " 27, 34, 23, 29, 20, 27, 0])\n", + "loss= tensor(18.7541, grad_fn=) , base rewards= tensor([1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788,\n", + " 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.5788, 1.2572, 1.0118,\n", + " 0.8169, 0.6560, 0.5184, 0.3972, 0.2876, 0.1863, 0.0909]) return= 71441.67491543088\n", + "probs of actions: tensor([0.2576, 0.2345, 0.2339, 0.0485, 0.0470, 0.2334, 0.0312, 0.0536, 0.0028,\n", + " 0.0313, 0.2498, 0.0074, 0.0085, 0.2073, 0.0793, 0.0499, 0.0455, 0.0475,\n", + " 0.2908, 0.0132, 0.0454, 0.0654, 0.0314, 0.2035, 0.6584],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5532, 0.4614, 0.4173, 0.3590, 0.2978, 0.3241, 0.2274, 0.1852,\n", + " 0.3049, 0.2303, 0.1430, 0.1797, 0.2957, 0.3074, 0.2591, 0.2487, 0.2410,\n", + " 0.2249, 0.1833, 0.2664, 0.2198, 0.2691, 0.2154, 0.2919])\n", + "finalReturns: tensor([0.8408, 0.9033, 0.9000, 0.8540, 0.7900, 0.7442, 0.5990, 0.4888, 0.3210,\n", + " 0.2009])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([18, 29, 29, 31, 40, 14, 36, 24, 21, 44, 31, 14, 21, 23, 23, 27, 21, 31,\n", + " 21, 25, 27, 18, 27, 13, 0])\n", + "loss= tensor(14.9813, grad_fn=) , base rewards= tensor([1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276,\n", + " 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.4276, 1.1491, 0.9332,\n", + " 0.7591, 0.6134, 0.4872, 0.3749, 0.2724, 0.1769, 0.0866]) return= 77980.90640713443\n", + "probs of actions: tensor([2.7012e-02, 6.3017e-02, 5.8051e-02, 1.0465e-01, 7.9897e-03, 1.3273e-02,\n", + " 1.8397e-03, 9.8149e-02, 6.7199e-02, 6.2596e-04, 9.1716e-02, 1.3948e-02,\n", + " 6.4990e-02, 5.1106e-02, 5.0795e-02, 2.7289e-01, 5.2761e-02, 1.1251e-01,\n", + " 5.0593e-02, 4.5280e-02, 2.9045e-01, 1.9979e-02, 2.9324e-01, 1.2556e-02,\n", + " 6.8308e-01], grad_fn=)\n", + "rewards: tensor([0.4788, 0.5069, 0.4997, 0.4682, 0.4149, 0.5744, 0.3353, 0.3916, 0.3547,\n", + " 0.1603, 0.2945, 0.3587, 0.2753, 0.2443, 0.2335, 0.2056, 0.2390, 0.1747,\n", + " 0.2439, 0.2118, 0.2018, 0.2479, 0.1881, 0.2530, 0.2410])\n", + "finalReturns: tensor([0.7793, 0.8522, 0.8290, 0.8284, 0.7303, 0.6446, 0.5551, 0.4097, 0.3171,\n", + " 0.1544])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 21, 27, 27, 27, 23, 20, 25, 31, 20, 17, 27, 27, 23, 25, 34, 27, 22,\n", + " 32, 30, 27, 27, 23, 17, 1])\n", + "loss= tensor(24.5587, grad_fn=) , base rewards= tensor([1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.5326,\n", + " 1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.5326, 1.2545, 1.0378, 0.8622,\n", + " 0.7144, 0.5861, 0.4714, 0.3664, 0.2684, 0.1755, 0.0864]) return= 70141.43022166056\n", + "probs of actions: tensor([0.3531, 0.0520, 0.3274, 0.3073, 0.3067, 0.0395, 0.0308, 0.0453, 0.1032,\n", + " 0.0294, 0.0222, 0.3298, 0.3189, 0.0456, 0.0481, 0.0110, 0.3648, 0.0188,\n", + " 0.0291, 0.0259, 0.3387, 0.3477, 0.0401, 0.0456, 0.3397],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5820, 0.4397, 0.3820, 0.3410, 0.3315, 0.3111, 0.2560, 0.2128,\n", + " 0.2785, 0.2662, 0.1974, 0.2053, 0.2313, 0.2156, 0.1632, 0.2307, 0.2549,\n", + " 0.1871, 0.2164, 0.2409, 0.2380, 0.2559, 0.2673, 0.2710])\n", + "finalReturns: tensor([1.0085, 1.0710, 1.1245, 1.0695, 0.9623, 0.9035, 0.8018, 0.6660, 0.5259,\n", + " 0.3629, 0.1846])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 31, 24, 22, 31, 21, 31, 27, 29, 30, 28, 32, 20, 31, 27, 27, 31, 17,\n", + " 27, 22, 14, 27, 18, 24, 0])\n", + "loss= tensor(18.5256, grad_fn=) , base rewards= tensor([1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.6562,\n", + " 1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.6562, 1.3379, 1.0948, 0.9013,\n", + " 0.7414, 0.6046, 0.4839, 0.3746, 0.2736, 0.1784, 0.0876]) return= 71432.63411057487\n", + "probs of actions: tensor([0.4025, 0.1170, 0.0888, 0.0151, 0.1120, 0.0484, 0.1180, 0.3931, 0.0731,\n", + " 0.0227, 0.0134, 0.0204, 0.0239, 0.1079, 0.3476, 0.3654, 0.1256, 0.0116,\n", + " 0.4426, 0.0156, 0.0039, 0.3897, 0.0197, 0.0934, 0.6554],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5300, 0.4914, 0.4218, 0.3126, 0.3490, 0.2552, 0.2776, 0.2541,\n", + " 0.2448, 0.2568, 0.2274, 0.2972, 0.2125, 0.2453, 0.2414, 0.2152, 0.2914,\n", + " 0.2154, 0.2434, 0.2615, 0.1797, 0.2323, 0.1933, 0.2557])\n", + "finalReturns: tensor([0.9185, 0.9914, 0.9931, 0.9714, 0.8399, 0.7613, 0.6385, 0.4863, 0.4077,\n", + " 0.2705, 0.1681])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 27, 27, 29, 27, 31, 21, 12, 23, 14, 21, 27, 23, 27, 22, 38, 21, 31,\n", + " 21, 27, 31, 29, 24, 31, 0])\n", + "loss= tensor(21.6933, grad_fn=) , base rewards= tensor([0.9710, 0.9710, 0.9710, 0.9710, 0.9710, 0.9710, 0.9710, 0.9710, 0.9710,\n", + " 0.9710, 0.9710, 0.9710, 0.9710, 0.9710, 0.7815, 0.6398, 0.5293, 0.4397,\n", + " 0.3644, 0.2990, 0.2405, 0.1869, 0.1369, 0.0896, 0.0441]) return= 52935.39228622602\n", + "probs of actions: tensor([1.3135e-01, 3.9508e-01, 4.0618e-01, 7.2963e-02, 3.7632e-01, 1.2127e-01,\n", + " 3.9684e-02, 4.7581e-03, 2.8660e-02, 7.0627e-03, 4.2338e-02, 3.8748e-01,\n", + " 3.4503e-02, 3.4157e-01, 1.5862e-02, 4.2852e-04, 2.9781e-02, 1.5134e-01,\n", + " 2.5701e-02, 3.7414e-01, 1.5954e-01, 8.2157e-02, 7.2119e-02, 8.8884e-02,\n", + " 6.5561e-01], grad_fn=)\n", + "rewards: tensor([0.4151, 0.5691, 0.4433, 0.3467, 0.3050, 0.2386, 0.2711, 0.2597, 0.1705,\n", + " 0.1938, 0.1421, 0.1087, 0.1382, 0.1166, 0.1487, 0.0474, 0.1801, 0.1133,\n", + " 0.1775, 0.1346, 0.1147, 0.1386, 0.1694, 0.1223, 0.2285])\n", + "finalReturns: tensor([0.7206, 0.7935, 0.7865, 0.8495, 0.7590, 0.7210, 0.6090, 0.5329, 0.4717,\n", + " 0.3832, 0.2612, 0.1844])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([29, 31, 27, 27, 31, 27, 27, 25, 27, 27, 27, 40, 27, 29, 27, 27, 19, 27,\n", + " 31, 34, 31, 27, 27, 24, 0])\n", + "loss= tensor(18.7539, grad_fn=) , base rewards= tensor([1.4664, 1.4664, 1.4664, 1.4664, 1.4664, 1.4664, 1.4664, 1.4664, 1.4664,\n", + " 1.4664, 1.4664, 1.4664, 1.4664, 1.4664, 1.1708, 0.9520, 0.7832, 0.6477,\n", + " 0.5348, 0.4374, 0.3509, 0.2722, 0.1991, 0.1300, 0.0639]) return= 64406.03212817425\n", + "probs of actions: tensor([0.0823, 0.1579, 0.4232, 0.3954, 0.1491, 0.4178, 0.4054, 0.0370, 0.4010,\n", + " 0.4133, 0.4319, 0.0079, 0.4110, 0.0824, 0.3963, 0.3923, 0.0056, 0.4349,\n", + " 0.1728, 0.0144, 0.1852, 0.4240, 0.4315, 0.0843, 0.6716],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5379, 0.4669, 0.3875, 0.3089, 0.3051, 0.2735, 0.2612, 0.2287,\n", + " 0.2181, 0.2102, 0.1172, 0.2350, 0.2115, 0.2190, 0.2109, 0.2417, 0.1799,\n", + " 0.1585, 0.1506, 0.1869, 0.2149, 0.2078, 0.2179, 0.2638])\n", + "finalReturns: tensor([0.9969, 1.0810, 1.0808, 1.0387, 0.9326, 0.8657, 0.8046, 0.7404, 0.6323,\n", + " 0.4905, 0.3517, 0.1999])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 29, 25, 27, 27, 27, 27, 27, 31, 27, 25, 27, 27, 27, 22, 27, 31, 27,\n", + " 29, 27, 31, 31, 27, 27, 1])\n", + "loss= tensor(19.9044, grad_fn=) , base rewards= tensor([1.8126, 1.8126, 1.8126, 1.8126, 1.8126, 1.8126, 1.8126, 1.8126, 1.8126,\n", + " 1.8126, 1.8126, 1.8126, 1.8126, 1.4983, 1.2578, 1.0661, 0.9074, 0.7714,\n", + " 0.6513, 0.5425, 0.4417, 0.3468, 0.2561, 0.1686, 0.0835]) return= 72315.8865070777\n", + "probs of actions: tensor([0.4264, 0.0900, 0.0361, 0.3809, 0.3864, 0.4072, 0.3918, 0.4200, 0.2000,\n", + " 0.4061, 0.0338, 0.4095, 0.4025, 0.3631, 0.0119, 0.3804, 0.2086, 0.4185,\n", + " 0.0833, 0.3702, 0.2321, 0.2195, 0.4070, 0.3533, 0.2681],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5420, 0.4791, 0.3956, 0.3507, 0.3185, 0.2952, 0.2782, 0.2425,\n", + " 0.2681, 0.2686, 0.2453, 0.2413, 0.2384, 0.2607, 0.2208, 0.1998, 0.2357,\n", + " 0.2229, 0.2386, 0.2131, 0.2226, 0.2530, 0.2471, 0.3155])\n", + "finalReturns: tensor([1.2969, 1.3698, 1.3719, 1.3030, 1.2408, 1.1770, 1.0615, 0.9474, 0.8096,\n", + " 0.6914, 0.5595, 0.3939, 0.2320])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 31, 27, 21, 27, 27, 27, 31, 17, 24, 31, 31, 27, 31, 35, 27, 27, 31,\n", + " 27, 31, 31, 18, 27, 12, 0])\n", + "loss= tensor(26.2656, grad_fn=) , base rewards= tensor([1.8285, 1.8285, 1.8285, 1.8285, 1.8285, 1.8285, 1.8285, 1.8285, 1.8285,\n", + " 1.8285, 1.8285, 1.8285, 1.8285, 1.5091, 1.2652, 1.0713, 0.9110, 0.7740,\n", + " 0.6531, 0.5437, 0.4425, 0.3473, 0.2565, 0.1688, 0.0835]) return= 72698.53410919756\n", + "probs of actions: tensor([0.4098, 0.2314, 0.3963, 0.0228, 0.3753, 0.3930, 0.3768, 0.2191, 0.0092,\n", + " 0.0667, 0.2092, 0.2115, 0.3923, 0.2258, 0.0021, 0.3662, 0.4119, 0.2573,\n", + " 0.4310, 0.2887, 0.2757, 0.0049, 0.3897, 0.0176, 0.7174],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5300, 0.4761, 0.4364, 0.3398, 0.3106, 0.2895, 0.2508, 0.3183,\n", + " 0.2498, 0.2018, 0.2140, 0.2465, 0.2190, 0.2007, 0.2680, 0.2582, 0.2277,\n", + " 0.2569, 0.2268, 0.2330, 0.3014, 0.2277, 0.2867, 0.2617])\n", + "finalReturns: tensor([1.3859, 1.4588, 1.4837, 1.4769, 1.3691, 1.2480, 1.1411, 0.9936, 0.8680,\n", + " 0.7302, 0.5197, 0.3796, 0.1781])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([30, 29, 27, 27, 21, 34, 24, 31, 27, 24, 31, 24, 27, 31, 25, 27, 27, 21,\n", + " 24, 31, 31, 29, 27, 27, 0])\n", + "loss= tensor(22.5994, grad_fn=) , base rewards= tensor([1.3878, 1.3878, 1.3878, 1.3878, 1.3878, 1.3878, 1.3878, 1.3878, 1.3878,\n", + " 1.3878, 1.3878, 1.3878, 1.1221, 0.9271, 0.7780, 0.6592, 0.5609, 0.4767,\n", + " 0.4024, 0.3351, 0.2728, 0.2142, 0.1582, 0.1041, 0.0515]) return= 59191.70354429475\n", + "probs of actions: tensor([0.0260, 0.0879, 0.3660, 0.3325, 0.0228, 0.0120, 0.0570, 0.2872, 0.3387,\n", + " 0.0595, 0.2735, 0.0504, 0.3624, 0.2916, 0.0277, 0.3297, 0.3628, 0.0132,\n", + " 0.0370, 0.3627, 0.3524, 0.0879, 0.3395, 0.3189, 0.7695],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5539, 0.4550, 0.3726, 0.3441, 0.2148, 0.2686, 0.1991, 0.2187,\n", + " 0.2207, 0.1646, 0.2081, 0.1787, 0.1526, 0.1941, 0.1745, 0.1727, 0.2001,\n", + " 0.1710, 0.1282, 0.1417, 0.1642, 0.1783, 0.1755, 0.2463])\n", + "finalReturns: tensor([1.0981, 1.1557, 1.1720, 1.1686, 1.0933, 1.0171, 0.9286, 0.8028, 0.6991,\n", + " 0.6332, 0.5501, 0.4419, 0.3177, 0.1948])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([21, 27, 27, 30, 27, 27, 27, 29, 17, 31, 31, 31, 31, 27, 27, 29, 31, 27,\n", + " 27, 31, 31, 31, 27, 21, 0])\n", + "loss= tensor(26.7384, grad_fn=) , base rewards= tensor([3.3104, 3.3104, 3.3104, 3.3104, 3.3104, 3.3104, 3.3104, 3.3104, 3.3104,\n", + " 3.3104, 3.3104, 3.3104, 2.8445, 2.4701, 2.1577, 1.8882, 1.6487, 1.4305,\n", + " 1.2278, 1.0362, 0.8527, 0.6753, 0.5023, 0.3327, 0.1654]) return= 103182.56122575839\n", + "probs of actions: tensor([0.0172, 0.3092, 0.3332, 0.0289, 0.3181, 0.3375, 0.3149, 0.0779, 0.0050,\n", + " 0.3144, 0.3320, 0.3495, 0.3503, 0.2980, 0.3014, 0.0876, 0.4035, 0.3287,\n", + " 0.3382, 0.4360, 0.4240, 0.3990, 0.3129, 0.0500, 0.7629],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5297, 0.4891, 0.4426, 0.4489, 0.4301, 0.4163, 0.3949, 0.4493,\n", + " 0.3410, 0.3573, 0.3697, 0.3792, 0.4095, 0.4010, 0.3835, 0.3736, 0.4053,\n", + " 0.3979, 0.3692, 0.3787, 0.3860, 0.4146, 0.4336, 0.4501])\n", + "finalReturns: tensor([2.2415, 2.3376, 2.3329, 2.2358, 2.1043, 1.9603, 1.8048, 1.6023, 1.3960,\n", + " 1.2103, 1.0090, 0.7960, 0.5510, 0.2847])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAgPklEQVR4nO3df5DcdZ3n8ecrkyFOYMkPMlAwCSZCFCEoyGyIcmWpuSVR1EQLJBwcKS9lSo511VvRZLUOV00Jxd7CcbewxQpHQBcSIxfiD8RcwNNjSWAwgRAwxwhKJuHMaBJkSYCZyfv+6M+E7k7Pd3q6e2Z6Zl6Pqq7pfn8/n0+/e2a63/39fr4/FBGYmZn1ZdxwJ2BmZvXNhcLMzDK5UJiZWSYXCjMzy+RCYWZmmcYPdwK1Nm3atJg5c+Zwp2FmNqI88cQTf4iI5lLLRl2hmDlzJm1tbcOdhpnZiCLpd30t86YnMzPL1G+hkHSHpL2Sni6x7EuSQtK0vNhKSe2SdkpakBc/T9L2tOxmSUrxCZLWpPgWSTPz+iyV9Fy6La361ZqZ2YCVs0ZxJ7CwOChpBvAXwIt5sTOBJcBZqc8tkhrS4luB5cDsdOsdcxmwPyJOB24Erk9jTQWuBc4H5gLXSpoysJdnZmbV6rdQRMQvgH0lFt0IfBnIPwfIIuDeiHg9Il4A2oG5kk4Gjo+IRyN3zpC7gMV5fVan++uA+WltYwGwMSL2RcR+YCMlCpaZmQ2uiuYoJH0c2B0RTxYtagF25T3uSLGWdL84XtAnIrqBl4ETMsYqlc9ySW2S2jo7Oyt5SWZm1ocB7/UkaSLwVeDCUotLxCIjXmmfwmDEbcBtAK2trT7LYQnrt+7mhgd3sufAIU6Z3MQ1C97B4nNL1l0zswKV7B57GjALeDLNR08HfiVpLrlv/TPy2k4H9qT49BJx8vp0SBoPTCK3qasD+EBRn59XkO+o11sEdh84RINETwSTmxqR4MDBLsaPg67Db7bffeAQX1izjS+s2QbAxMZxTGhsYP/BrpL9swqLC5DZ6KdyTjOe9kT6UUTMKbHst0BrRPxB0lnAP5ObfD4F2ATMjogeSY8DnwO2AD8B/ltE/ETS1cDZEfFZSUuAT0bEp9Jk9hPAe9JT/Qo4LyJKzZcc0draGmPhOIr84jBUpkxs5NqPnXWkEKzfupuV923nUFfPkTZNjQ18+5Nnu1iYjTCSnoiI1lLL+l2jkHQPuW/20yR1ANdGxO2l2kbEDklrgWeAbuDqiOj9FLmK3B5UTcAD6QZwO3C3pHZyaxJL0lj7JH0TeDy1+0Z/RaLe1Prbdu6D+SkO5a8eDKH9B7v4wpptfPV/bmfVJ87mb3+4o6BIABzq6uGv1+amrlwszEaHstYoRpLBXKMYyAd/rb5tD8eaQy0IuHzeqXxr8dnDnYqZlSFrjcKFIsP6rbv5+oYdHDjU1WebY49p4OAbPUxK2/Tzt/OX0jK5iUdWfKis5x7OtYfB1OK5DLO640JRgfVbd/Of1m7j8CD9eo49poFVnzi7YHt/f0VptCme8zCz4eNCUYFzv/Ez9h8cmg/t2Scey3N7Xx2S56pHF5w2ld/+8VDZm/S8l5VZ7blQVGDmih/XIBurxpSJjVz0rpN5+Ned7DlwiElNjfzpta6CtbzGceKGS97tYmFWpaxC4bPHWt3af7CL725+kd0HDhHAgUNdR20K7DocrLzvqWHJz2ysGHXXo7Cx51DXYS7/p0fZ/Px+eiIQMDHtZODNU2bVc6Eo4Wvrtw93CjZAj/zmzUNsAnj1jdxuybsPHGLlfbm/ZyXFwnMiZi4UJX1384v9N7IR41BXD19cuw3IFYtyP/yLj4WptuiYjVSezC7BE9ljT+M46Ak4HNAgcdn5M3j4150lD3QsPhbGax02GlR1Cg+zsSD/uMaeiMy1yvziUWqt4wtrth05BscHF9po4EJhVoFZK37MWxrH9XnkfO/eWd5cZaOBd48toaHUlTDM8gSUfXqV3hMlrt+6e3CTMhskXqMooWd0TdtYHeiJ4ItrttH2u32ZJ0osnu/44BnNRw44HK75D8/BmCezS/Bktg22lhJF4INnNLPm8V109fNNpfdCU/1dVKpXNR/0vubI2OFTeAyQC4WNJPmnMSm1RvKDJ3Yfdd2Qck/IeMF1D5W155eNfC4UA7B+6+4jlwg1G83GCSY1NRasmQAFhaav66AIeOG6i4YwWxtsLhQD0Nc3KLOxYJwo69T6DRKHI/osMH3FvLmqfrlQDIA3O5lVr3GcQBw131Lquuu9xaT34l8HDnbxlsZxvN59+MgBkPPeNuXIqehLXSRsoMer9DVvUyoOY6PguVAMgAuF2dBoHFd4oGP144nj3jKeAwe7CorOKZObmHlCU8FJIyG3i3N+30vnzuCex3bR088qVe9kPlB3e6hVw4ViAFwozKwWsvYO+9r67dyzZRc9EUdOGTPc15ev6hQeku4APgrsjYg5KXYD8DHgDeA3wKcj4kBathJYBvQAfxURD6b4ecCdQBPwE+DzERGSJgB3AecBfwQujYjfpj5Lga+lVL4VEasH+uIHwgdEmVmt9J6Msu13+wrWNCYeM67gipa9p4y5Z8uLBcdwFV8uuZShOsal3zUKSe8H/hW4K69QXAg8FBHdkq4HiIivSDoTuAeYC5wC/C/g7RHRI+kx4PPAZnKF4uaIeEDSfwTeFRGflbQE+EREXCppKtAGtJJbS3wCOC8i9mflW80ahSeyzawelXvcTWODuOHiyq74WNUV7iLiF8C+otjPIqI7PdwMTE/3FwH3RsTrEfEC0A7MlXQycHxEPBq5ynQXsDivT++awjpgviQBC4CNEbEvFYeNwMKyXnGF9rhImFkd2n3gUMHVHnsfF+8s0NUTXPP9bTV//lqc6+k/AA+k+y3ArrxlHSnWku4Xxwv6pOLzMnBCxlhHkbRcUpukts7OzopfyKSmxor7mpnVg67DcPk/PVrTMasqFJK+CnQD3+sNlWgWGfFK+xQGI26LiNaIaG1ubs5OOoN8MkAzGwUe+c2+ms65Vlwo0kTzR4HL482Jjg5gRl6z6cCeFJ9eIl7QR9J4YBK5TV19jTVo9h/sGszhzcyGzJe+/2TNxqqoUEhaCHwF+HhEHMxbtAFYImmCpFnAbOCxiHgJeEXSvDT/cCVwf16fpen+xeQmyQN4ELhQ0hRJU4ALU8zMzPrRXc4h9mUqZ/fYe4APANMkdQDXAiuBCcDG3Oc+myPisxGxQ9Ja4Blym6Sujojes5FdxZu7xz7Am/MatwN3S2ontyaxBCAi9kn6JvB4aveNiCiYVDczs8HXb6GIiMtKhG/PaL8KWFUi3gbMKRF/Dbikj7HuAO7oL0czMxs8vsKdmZllcqFIfFS2mVlpLhTJDQ/uHO4UzMzqkgtF4lN3mJmV5kJBbrOTj7UzMyvNhYLcZqfRdbJ1M7PacaHAJwM0M8viQgGcMrlpuFMwM6tbLhRw5Lq4ZmZ2NBcKMzPL5EIB/O0Pdwx3CmZmdcuFAp9e3MwsiwuFmZllcqEwM7NMLhRmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmfotFJLukLRX0tN5samSNkp6Lv2ckrdspaR2STslLciLnydpe1p2sySl+ARJa1J8i6SZeX2Wpud4TtLSmr1qMzMrWzlrFHcCC4tiK4BNETEb2JQeI+lMYAlwVupzi6SG1OdWYDkwO916x1wG7I+I04EbgevTWFOBa4HzgbnAtfkFyczMhka/hSIifgHsKwovAlan+6uBxXnxeyPi9Yh4AWgH5ko6GTg+Ih6NiADuKurTO9Y6YH5a21gAbIyIfRGxH9jI0QXLzMwGWaVzFCdFxEsA6eeJKd4C7Mpr15FiLel+cbygT0R0Ay8DJ2SMdRRJyyW1SWrr7Oys8CWZmVkptZ7MLnVF0ciIV9qnMBhxW0S0RkRrc3NzWYmamVl5Ki0Uv0+bk0g/96Z4BzAjr910YE+KTy8RL+gjaTwwidymrr7GMjOzIVRpodgA9O6FtBS4Py++JO3JNIvcpPVjafPUK5LmpfmHK4v69I51MfBQmsd4ELhQ0pQ0iX1hipmZ2RAa318DSfcAHwCmSeogtyfSdcBaScuAF4FLACJih6S1wDNAN3B1RPSkoa4itwdVE/BAugHcDtwtqZ3cmsSSNNY+Sd8EHk/tvhERxZPqZmY2yPotFBFxWR+L5vfRfhWwqkS8DZhTIv4aqdCUWHYHcEd/OZqZ2eDxkdlmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmVwozMwskwuFmZllcqEwM7NMLhRmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmVwozMwskwuFmZllcqEwM7NMLhRmZpbJhcLMzDK5UJiZWSYXCjMzy1RVoZD0RUk7JD0t6R5Jb5E0VdJGSc+ln1Py2q+U1C5pp6QFefHzJG1Py26WpBSfIGlNim+RNLOafM3MbOAqLhSSWoC/AlojYg7QACwBVgCbImI2sCk9RtKZaflZwELgFkkNabhbgeXA7HRbmOLLgP0RcTpwI3B9pfmamVllqt30NB5okjQemAjsARYBq9Py1cDidH8RcG9EvB4RLwDtwFxJJwPHR8SjERHAXUV9esdaB8zvXdswM7OhUXGhiIjdwN8BLwIvAS9HxM+AkyLipdTmJeDE1KUF2JU3REeKtaT7xfGCPhHRDbwMnFCci6TlktoktXV2dlb6kszMrIRqNj1NIfeNfxZwCnCspCuyupSIRUY8q09hIOK2iGiNiNbm5ubsxM3MbECq2fT0b4EXIqIzIrqA+4D3Ab9Pm5NIP/em9h3AjLz+08ltqupI94vjBX3S5q1JwL4qcjYzswGqplC8CMyTNDHNG8wHngU2AEtTm6XA/en+BmBJ2pNpFrlJ68fS5qlXJM1L41xZ1Kd3rIuBh9I8hpmZDZHxlXaMiC2S1gG/ArqBrcBtwHHAWknLyBWTS1L7HZLWAs+k9ldHRE8a7irgTqAJeCDdAG4H7pbUTm5NYkml+ZqZWWUqLhQAEXEtcG1R+HVyaxel2q8CVpWItwFzSsRfIxUaMzMbHj4y28zMMrlQmJlZJhcKMzPL5EJhZmaZXCjMzCyTC4WZmWVyoTAzs0wuFGZmlsmFwszMMrlQmJlZJhcKMzPL5EJhZmaZXCjMzCyTC4WZmWVyoTAzs0wuFGZmlsmFwszMMrlQmJlZJhcKMzPLVFWhkDRZ0jpJv5b0rKT3SpoqaaOk59LPKXntV0pql7RT0oK8+HmStqdlN0tSik+QtCbFt0iaWU2+ZmY2cNWuUfxX4KcRcQbwbuBZYAWwKSJmA5vSYySdCSwBzgIWArdIakjj3AosB2an28IUXwbsj4jTgRuB66vM18zMBqjiQiHpeOD9wO0AEfFGRBwAFgGrU7PVwOJ0fxFwb0S8HhEvAO3AXEknA8dHxKMREcBdRX16x1oHzO9d2zAzs6FRzRrF24BO4H9I2irpO5KOBU6KiJcA0s8TU/sWYFde/44Ua0n3i+MFfSKiG3gZOKGKnM3MbICqKRTjgfcAt0bEucCrpM1MfSi1JhAZ8aw+hQNLyyW1SWrr7OzMztrMzAakmkLRAXRExJb0eB25wvH7tDmJ9HNvXvsZef2nA3tSfHqJeEEfSeOBScC+4kQi4raIaI2I1ubm5ipekpmZFau4UETE/wN2SXpHCs0HngE2AEtTbClwf7q/AViS9mSaRW7S+rG0eeoVSfPS/MOVRX16x7oYeCjNY5iZ2RAZX2X/zwHfk3QM8DzwaXLFZ62kZcCLwCUAEbFD0lpyxaQbuDoietI4VwF3Ak3AA+kGuYnyuyW1k1uTWFJlvmZmNkBVFYqI2Aa0llg0v4/2q4BVJeJtwJwS8ddIhcbMzIaHj8w2M7NMLhRmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmVwozMwskwuFmZllcqEwM7NMLhRmZpbJhcLMbBS6Yt6pNRvLhcLMbBT61uKzazaWC4WZmWVyoTAzG4X+4u9/XrOxXCjMzEah5/a+WrOxXCjMzCyTC4WZmWVyoTAzs0wuFGZmlsmFwszMMlVdKCQ1SNoq6Ufp8VRJGyU9l35OyWu7UlK7pJ2SFuTFz5O0PS27WZJSfIKkNSm+RdLMavM1M7OBqcUaxeeBZ/MerwA2RcRsYFN6jKQzgSXAWcBC4BZJDanPrcByYHa6LUzxZcD+iDgduBG4vgb5mpnZAFRVKCRNBy4CvpMXXgSsTvdXA4vz4vdGxOsR8QLQDsyVdDJwfEQ8GhEB3FXUp3esdcD83rUNMzPr2wWnTa3ZWNWuUdwEfBk4nBc7KSJeAkg/T0zxFmBXXruOFGtJ94vjBX0ioht4GTihOAlJyyW1SWrr7Oys8iWZmY1sAr73mffWbLyKC4WkjwJ7I+KJcruUiEVGPKtPYSDitohojYjW5ubmMtMxMxudAli/dXfNxqtmjeIC4OOSfgvcC3xI0neB36fNSaSfe1P7DmBGXv/pwJ4Un14iXtBH0nhgErCvipzNzMaEL697smZjVVwoImJlREyPiJnkJqkfiogrgA3A0tRsKXB/ur8BWJL2ZJpFbtL6sbR56hVJ89L8w5VFfXrHujg9x1FrFGZmVuiNntp9VI6v2Uhvug5YK2kZ8CJwCUBE7JC0FngG6Aaujoie1Ocq4E6gCXgg3QBuB+6W1E5uTWLJIORrZmYZalIoIuLnwM/T/T8C8/totwpYVSLeBswpEX+NVGjMzGx4+MhsMzPL5EJhZmaZXCjMzCyTC4WZmWVyoTAzs0wuFGZmo1BjDT/dXSjMzEahGy45p2ZjuVCYmY1Ci89t6b9RmVwozMxGoZkrflyzsVwozMwskwuFmZllcqEwM7NMLhRmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmVwozMwskwuFmdkodNOl59RsLBcKM7NRRjUer+JCIWmGpIclPStph6TPp/hUSRslPZd+Tsnrs1JSu6Sdkhbkxc+TtD0tu1mSUnyCpDUpvkXSzCpeq5nZmBDADQ/urNl41axRdAN/HRHvBOYBV0s6E1gBbIqI2cCm9Ji0bAlwFrAQuEVSQxrrVmA5MDvdFqb4MmB/RJwO3AhcX0W+ZmZjxu4Dh2o2VsWFIiJeiohfpfuvAM8CLcAiYHVqthpYnO4vAu6NiNcj4gWgHZgr6WTg+Ih4NCICuKuoT+9Y64D5vWsbZmbWt4YaflTWZI4ibRI6F9gCnBQRL0GumAAnpmYtwK68bh0p1pLuF8cL+kREN/AycEKJ518uqU1SW2dnZy1ekpnZiNYTUbOxqi4Uko4DfgB8ISL+lNW0RCwy4ll9CgMRt0VEa0S0Njc395eymdmoN7GG10KtaiRJjeSKxPci4r4U/n3anET6uTfFO4AZed2nA3tSfHqJeEEfSeOBScC+anI2MxsLDnUfrtlY1ez1JOB24NmI+Pu8RRuApen+UuD+vPiStCfTLHKT1o+lzVOvSJqXxryyqE/vWBcDD6V5DDMzy1DLT8rxVfS9APj3wHZJ21Lsb4DrgLWSlgEvApcARMQOSWuBZ8jtMXV1RPSkflcBdwJNwAPpBrlCdLekdnJrEkuqyNfMbMyo5WR2xYUiIv4PfR/XMb+PPquAVSXibcCcEvHXSIXGzMzKd9n5M/pvVCYfmW1mNgq1vnVqzcZyoTAzG4W+vmFHzcZyoTAzG4UOHOqq2VguFGZmlsmFwsxsFJoysbFmY7lQjGCNDeKKeafSMrkJqO3ucGY2cjU2iGs/dlbNxqvmOAobJI3jBIKunqOPmBG5c5i0TG7imgXvYPG5LUe1Wb91Nzc8uDPz7JGTmxp5vfswh7p6+mxjZiOLgFMyPhsq5UIxDKZMbOTAwa4jf1DInTt+z4FDR8V2HzhEg0RPRGZxyLf43JYjbWau+HHJNi8f6uLGS88peN4PntHMw7/uPPK4lqcpNrPBdewxDez4xsL+G1bAhWIQXHDaVGY1H8d3N7941LIr5p3KtxaffVS81Id/Lb4RtPTxgX/K5KaCglLKBdc9VLJv71qNmQ2O3i+FX9+wo6y9lxrGiVWfOPpzpVY8R1FD45QrBN/7zHv51uKzuWLeqUfmDRqkPovEYLpmwTtoamwoiDU1NhxZa6mk742XnjOg6/H2zpy0TG4qmFMpZfw4z7PY2Nb7/lx8bgvbrr2Qmy49h5bJTYjce+im9P7Lj/2XS95d001NxTTazrHX2toabW1tA+rT1+aZgfrtdRfVZJxa652zyN+0Ve4/VVbfvtY4Jjc1cuyE8f0+39fWb+eeLbvoiaBB4rLzZxwppMXL3tY8kec7Dxa0/fFTL7H/YO32FTerBzddes6gfuj3RdITEdFacpkLRW0KxWBuH6xX67fuZuV92wsmxJsaG/j2J88ekn/0Us9v1tfm1sHSO4dYCy2Tm3hkxYdqMtZAZRUKb3qqkcaGsferXHxuC9/+5NkFq8BDVST6ev5jj2not5+9qYbXtqkLxx6T22zTOESbMJsaG7js/BlHbaItZXJTY2a7cjcJDwdPZtfIyzU8XH4k6W9CfKiff/3W3Vyz7smCXYsbG8Slfz6Dh3/dWfY3zabGhqrXVBrHicYGcbCrsgvITJnYyEXvOpk1j+2i63Bl31inTGw8sj99/sRob3zxuS0Fm/mK+5558p/xyG8Gfq2w3qur5b/2iY3jmNDYwP6DXZk7RExsHMdr3YcZ6EvundDt/X/Imgju/d3+6MmXjrQp53kbx4nj3jK+YK/Fxee20PrWqUc20U5qauTVN7oL/gebGhv4+sdzf4f8dhJHjVWPvOmJ2mx6Gs5VRitUybxKvt49Tkrtnpy/C/G4jE0O5ezK3Nems/wP8d52/e39csW8Uws+rGr5wdPfHFclc2CVjAlk7s5di9db/LyVPkc184LDxXMU/RhooSj+tjmU2+WtOv3Nawzkb1mLOZrB+JA1q0RWofCmpwFqkPj2J8/2G3WE6v071WL1v3isSv4XKtl0N9yb+2zs8RoFA1+jqNfdYM3MKuW9nmoo62AxM7PRaEQUCkkLJe2U1C5pxXDlUc+7r5mZDZa6LxSSGoB/AD4MnAlcJunMoc5jqI8RMDOrFyNhMnsu0B4RzwNIuhdYBDwzVAlMmdjoXV/NbMyq+zUKoAXYlfe4I8WOkLRcUpukts7OzponcMDnEzKzMWwkFIpSx+IX7KoVEbdFRGtEtDY3N9c8gVM8gW1mY9hIKBQdwIy8x9OBPUP15I0N8gS2mY1pI6FQPA7MljRL0jHAEmBDLZ+gr11eJbjh4sE9z7uZWb2r+0IREd3AXwIPAs8CayNiRy2fo88L9HxqeM4Lb2ZWT0bCXk9ExE+AnwzW+LU4FYOZ2Wg1IgrFUPD5c8zMSqv7TU9mZja8XCjMzCyTC4WZmWVyoTAzs0wuFGZmlmnUXbhIUifwuyqGmAb8oUbpDLaRlCuMrHxHUq4wsvIdSbnCyMq3mlzfGhElz4E06gpFtSS19XWVp3ozknKFkZXvSMoVRla+IylXGFn5Dlau3vRkZmaZXCjMzCyTC8XRbhvuBAZgJOUKIyvfkZQrjKx8R1KuMLLyHZRcPUdhZmaZvEZhZmaZXCjMzCzTmCwUkhZK2impXdKKEssl6ea0/ClJ7xmOPPPy6S/fy1OeT0n6F0nvHo48Uy6Zuea1+3NJPZIuHsr8SuTRb76SPiBpm6Qdkv73UOeYl0d//weTJP1Q0pMp108PR54plzsk7ZX0dB/L6+091l++9fQey8w1r13t3mMRMaZuQAPwG+BtwDHAk8CZRW0+AjxA7nrd84AtdZ7v+4Ap6f6HhyvfcnLNa/cQuWuMXFznv9vJwDPAqenxiXWc698A16f7zcA+4Jhhyvf9wHuAp/tYXjfvsTLzrYv3WDm55v2/1Ow9NhbXKOYC7RHxfES8AdwLLCpqswi4K3I2A5MlnTzUiSb95hsR/xIR+9PDzeSuKz4cyvndAnwO+AGwdyiTK6GcfP8dcF9EvAgQEcOVczm5BvBnkgQcR65QdA9tmimRiF+k5+9LPb3H+s23jt5j5fxuocbvsbFYKFqAXXmPO1JsoG2GykBzWUbum9pw6DdXSS3AJ4B/HMK8+lLO7/btwBRJP5f0hKQrhyy7QuXk+t+BdwJ7gO3A5yPi8NCkN2D19B4bqOF8j/VrMN5jY/EKdyoRK95HuJw2Q6XsXCR9kNw/8b8Z1Iz6Vk6uNwFfiYie3BffYVVOvuOB84D5QBPwqKTNEfF/Bzu5IuXkugDYBnwIOA3YKOmXEfGnQc6tEvX0HitbHbzHynETNX6PjcVC0QHMyHs8ndw3sIG2GSpl5SLpXcB3gA9HxB+HKLdi5eTaCtyb/oGnAR+R1B0R64ckw0Ll/i/8ISJeBV6V9Avg3cBQF4pycv00cF3kNlK3S3oBOAN4bGhSHJB6eo+VpU7eY+Wo/XtsuCZkhnEiaDzwPDCLNycFzypqcxGFE22P1Xm+pwLtwPvq/Xdb1P5Ohncyu5zf7TuBTantROBpYE6d5nor8PV0/yRgNzBtGH+/M+l7crhu3mNl5lsX77Fyci1qV5P32Jhbo4iIbkl/CTxIbs+AOyJih6TPpuX/SG5PgY+Q+8c4SO6bWj3n+5+BE4Bb0reI7hiGs12WmWvdKCffiHhW0k+Bp4DDwHciInO3xOHKFfgmcKek7eQ+gL8SEcNyemxJ9wAfAKZJ6gCuBRrzcq2b9xiUlW9dvMfKzLX2z5mqjpmZWUljca8nMzMbABcKMzPL5EJhZmaZXCjMzCyTC4WZ2QhX7okC89p/StIz6eSR/9xve+/1ZGY2skl6P/Cv5M6fNaeftrOBtcCHImK/pBOjn3OYeY3CzGyEixInCpR0mqSfpnOU/VLSGWnRZ4B/iHSSw/6KBLhQmJmNVrcBn4uI84AvAbek+NuBt0t6RNJmSQv7G2jMHZltZjbaSTqO3DU0vp93YsAJ6ed4YDa5o7unA7+UNCciDvQ1nguFmdnoMw44EBHnlFjWAWyOiC7gBUk7yRWOx7MGMzOzUSRyp5Z/QdIlcOTSs72Xb10PfDDFp5HbFPV81nguFGZmI1w6UeCjwDskdUhaBlwOLJP0JLCDN6+I+CDwR0nPAA8D10Q/p0337rFmZpbJaxRmZpbJhcLMzDK5UJiZWSYXCjMzy+RCYWZmmVwozMwskwuFmZll+v9UjEW9pcYCrwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([29, 27, 31, 29, 27, 31, 27, 16, 27, 27, 27, 27, 27, 27, 31, 39, 17, 27,\n", + " 31, 21, 27, 31, 34, 18, 0])\n", + "loss= tensor(32.3768, grad_fn=) , base rewards= tensor([1.5781, 1.5781, 1.5781, 1.5781, 1.5781, 1.5781, 1.5781, 1.5781, 1.5781,\n", + " 1.5781, 1.5781, 1.3062, 1.1027, 0.9441, 0.8154, 0.7072, 0.6130, 0.5289,\n", + " 0.4519, 0.3799, 0.3117, 0.2463, 0.1828, 0.1209, 0.0600]) return= 63398.45815361886\n", + "probs of actions: tensor([0.0874, 0.2764, 0.3659, 0.0814, 0.2828, 0.3559, 0.2766, 0.0020, 0.2765,\n", + " 0.3013, 0.2999, 0.2901, 0.2900, 0.2586, 0.4018, 0.0119, 0.0022, 0.2802,\n", + " 0.4352, 0.0115, 0.2519, 0.4196, 0.0126, 0.0288, 0.7476],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5611, 0.4291, 0.3797, 0.3409, 0.2759, 0.2811, 0.3036, 0.2083,\n", + " 0.2030, 0.1990, 0.1960, 0.1938, 0.1921, 0.1677, 0.1211, 0.2731, 0.1920,\n", + " 0.1676, 0.2290, 0.1816, 0.1598, 0.1516, 0.2513, 0.2545])\n", + "finalReturns: tensor([1.3521, 1.4250, 1.4324, 1.3973, 1.3338, 1.2744, 1.2474, 1.0584, 0.9435,\n", + " 0.8479, 0.6870, 0.5709, 0.4746, 0.3850, 0.1945])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 27, 31, 27, 31, 27, 27, 31, 27, 27, 19, 29, 29, 30, 31, 31, 31, 27,\n", + " 23, 31, 31, 31, 39, 8, 0])\n", + "loss= tensor(30.4513, grad_fn=) , base rewards= tensor([1.2917, 1.2917, 1.2917, 1.2917, 1.2917, 1.2917, 1.2917, 1.2917, 1.2917,\n", + " 1.2917, 1.2917, 1.0375, 0.8542, 0.7164, 0.6086, 0.5209, 0.4468, 0.3822,\n", + " 0.3243, 0.2712, 0.2215, 0.1744, 0.1291, 0.0851, 0.0422]) return= 56091.234312968976\n", + "probs of actions: tensor([0.4656, 0.2351, 0.4493, 0.2263, 0.4393, 0.2570, 0.2366, 0.4501, 0.2361,\n", + " 0.2655, 0.0039, 0.0853, 0.0743, 0.0300, 0.4808, 0.4822, 0.5093, 0.2286,\n", + " 0.0071, 0.5400, 0.5299, 0.5037, 0.0076, 0.0026, 0.7902],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5691, 0.4201, 0.3711, 0.2849, 0.2757, 0.2411, 0.1931, 0.2089,\n", + " 0.1929, 0.2181, 0.1421, 0.1456, 0.1423, 0.1405, 0.1463, 0.1507, 0.1772,\n", + " 0.1897, 0.1313, 0.1393, 0.1454, 0.0940, 0.2635, 0.2113])\n", + "finalReturns: tensor([1.1455, 1.1816, 1.2228, 1.2149, 1.1805, 1.1277, 1.0555, 0.9694, 0.8502,\n", + " 0.7136, 0.6319, 0.5397, 0.4397, 0.3896, 0.1691])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 29, 31, 31, 31, 31, 31, 27, 31, 31, 29, 31, 31, 27, 31, 31, 27,\n", + " 31, 29, 27, 31, 31, 29, 0])\n", + "loss= tensor(17.6833, grad_fn=) , base rewards= tensor([1.4062, 1.4062, 1.4062, 1.4062, 1.4062, 1.4062, 1.4062, 1.4062, 1.4062,\n", + " 1.4062, 1.1272, 0.9281, 0.7801, 0.6656, 0.5732, 0.4960, 0.4292, 0.3698,\n", + " 0.3155, 0.2651, 0.2173, 0.1716, 0.1273, 0.0841, 0.0418]) return= 57625.70350633702\n", + "probs of actions: tensor([0.5254, 0.5365, 0.0773, 0.5474, 0.4957, 0.4917, 0.5284, 0.5085, 0.2207,\n", + " 0.4711, 0.5105, 0.0778, 0.5243, 0.5131, 0.2109, 0.5437, 0.5767, 0.2099,\n", + " 0.5852, 0.0647, 0.1906, 0.5649, 0.5696, 0.0737, 0.8116],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4465, 0.3512, 0.2997, 0.2631, 0.2368, 0.2178, 0.2271,\n", + " 0.1830, 0.1782, 0.1866, 0.1668, 0.1661, 0.1888, 0.1550, 0.1573, 0.1821,\n", + " 0.1502, 0.1656, 0.1744, 0.1444, 0.1493, 0.1649, 0.2468])\n", + "finalReturns: tensor([1.3531, 1.4492, 1.4701, 1.4315, 1.3793, 1.3055, 1.1940, 1.1057, 1.0079,\n", + " 0.8800, 0.7803, 0.6624, 0.5338, 0.4336, 0.3275, 0.2050])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([27, 31, 31, 31, 31, 31, 31, 39, 31, 27, 31, 27, 31, 31, 31, 31, 31, 31,\n", + " 31, 27, 31, 31, 31, 31, 0])\n", + "loss= tensor(16.3241, grad_fn=) , base rewards= tensor([2.2920, 2.2920, 2.2920, 2.2920, 2.2920, 2.2920, 2.2920, 2.2920, 2.2920,\n", + " 2.2920, 1.9012, 1.6109, 1.3861, 1.2049, 1.0534, 0.9224, 0.8059, 0.6996,\n", + " 0.6006, 0.5070, 0.4174, 0.3306, 0.2459, 0.1629, 0.0810]) return= 76050.11060785275\n", + "probs of actions: tensor([0.1863, 0.6206, 0.5911, 0.6317, 0.5827, 0.5832, 0.6199, 0.0090, 0.6179,\n", + " 0.1993, 0.6145, 0.1713, 0.6189, 0.6144, 0.6447, 0.6398, 0.6812, 0.6750,\n", + " 0.6822, 0.1357, 0.6919, 0.6564, 0.6682, 0.3447, 0.7568],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5300, 0.4529, 0.3984, 0.3594, 0.3312, 0.3106, 0.2395, 0.3095,\n", + " 0.3179, 0.2716, 0.2898, 0.2511, 0.2513, 0.2515, 0.2516, 0.2517, 0.2518,\n", + " 0.2518, 0.2751, 0.2402, 0.2431, 0.2453, 0.2470, 0.3443])\n", + "finalReturns: tensor([1.9431, 2.0160, 2.0348, 1.9698, 1.8999, 1.8001, 1.6796, 1.5445, 1.3992,\n", + " 1.2463, 1.0881, 0.9027, 0.7492, 0.5907, 0.4285, 0.2633])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 29, 31, 31, 31, 27, 27, 31, 31,\n", + " 31, 31, 31, 31, 31, 25, 0])\n", + "loss= tensor(16.1819, grad_fn=) , base rewards= tensor([1.5122, 1.5122, 1.5122, 1.5122, 1.5122, 1.5122, 1.5122, 1.5122, 1.5122,\n", + " 1.2109, 0.9978, 0.8408, 0.7203, 0.6239, 0.5439, 0.4753, 0.4145, 0.3593,\n", + " 0.3081, 0.2599, 0.2137, 0.1692, 0.1258, 0.0833, 0.0414]) return= 58091.06761554499\n", + "probs of actions: tensor([0.6676, 0.6758, 0.6473, 0.6814, 0.6298, 0.6306, 0.6638, 0.6450, 0.6744,\n", + " 0.6083, 0.0558, 0.6726, 0.6657, 0.6623, 0.1382, 0.1387, 0.7263, 0.7154,\n", + " 0.7250, 0.7264, 0.7315, 0.6966, 0.7091, 0.0386, 0.7263],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1988, 0.1758, 0.1728, 0.1706, 0.1921, 0.1807, 0.1491, 0.1528,\n", + " 0.1556, 0.1577, 0.1592, 0.1604, 0.1613, 0.1956, 0.2436])\n", + "finalReturns: tensor([1.5137, 1.6098, 1.6283, 1.5865, 1.5313, 1.4549, 1.3642, 1.2408, 1.1209,\n", + " 1.0269, 0.9253, 0.8180, 0.7064, 0.5917, 0.4746, 0.3559, 0.2022])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 27, 31, 31, 31, 31, 31, 29, 27, 31, 27, 31, 31, 27, 31, 31, 31,\n", + " 27, 31, 27, 21, 31, 18, 0])\n", + "loss= tensor(24.9285, grad_fn=) , base rewards= tensor([1.5047, 1.5047, 1.5047, 1.5047, 1.5047, 1.5047, 1.5047, 1.5047, 1.5047,\n", + " 1.2060, 0.9945, 0.8386, 0.7187, 0.6228, 0.5432, 0.4747, 0.4141, 0.3590,\n", + " 0.3079, 0.2597, 0.2137, 0.1691, 0.1258, 0.0833, 0.0414]) return= 57599.17264698916\n", + "probs of actions: tensor([0.7397, 0.7455, 0.1266, 0.7501, 0.6977, 0.7015, 0.7321, 0.7163, 0.0445,\n", + " 0.1329, 0.7224, 0.1171, 0.7466, 0.7306, 0.1055, 0.7474, 0.7937, 0.7855,\n", + " 0.0975, 0.7950, 0.0860, 0.0034, 0.7727, 0.0341, 0.7005],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4577, 0.3446, 0.2950, 0.2597, 0.2344, 0.2160, 0.2146,\n", + " 0.2105, 0.1710, 0.1924, 0.1577, 0.1593, 0.1837, 0.1513, 0.1544, 0.1568,\n", + " 0.1818, 0.1499, 0.1766, 0.1981, 0.1263, 0.1992, 0.2078])\n", + "finalReturns: tensor([1.4868, 1.5709, 1.5718, 1.5568, 1.4843, 1.4224, 1.3428, 1.2276, 1.1369,\n", + " 1.0376, 0.9318, 0.7982, 0.6943, 0.5623, 0.4075, 0.3237, 0.1664])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 31, 31, 31, 29, 31, 31,\n", + " 31, 31, 31, 31, 31, 30, 0])\n", + "loss= tensor(16.6724, grad_fn=) , base rewards= tensor([1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.2793,\n", + " 1.0571, 0.8942, 0.7699, 0.6710, 0.5892, 0.5193, 0.4577, 0.4019, 0.3503,\n", + " 0.3017, 0.2554, 0.2106, 0.1671, 0.1245, 0.0826, 0.0411]) return= 58286.72735101802\n", + "probs of actions: tensor([0.7850, 0.7893, 0.7652, 0.7909, 0.7438, 0.7489, 0.7762, 0.7680, 0.7911,\n", + " 0.7465, 0.7632, 0.0144, 0.7943, 0.7811, 0.7935, 0.0443, 0.8382, 0.8309,\n", + " 0.8338, 0.8314, 0.8323, 0.8108, 0.8141, 0.0179, 0.7230],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1747, 0.1793, 0.1754, 0.1726, 0.1824, 0.1637, 0.1638,\n", + " 0.1638, 0.1639, 0.1639, 0.1639, 0.1639, 0.1701, 0.2575])\n", + "finalReturns: tensor([1.6701, 1.7662, 1.7832, 1.7514, 1.6890, 1.6132, 1.5156, 1.4101, 1.2992,\n", + " 1.1726, 1.0605, 0.9453, 0.8278, 0.7087, 0.5883, 0.4670, 0.3450, 0.2164])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 29, 29, 27, 31, 31, 31, 31, 27, 31,\n", + " 29, 31, 31, 31, 31, 25, 1])\n", + "loss= tensor(26.0252, grad_fn=) , base rewards= tensor([1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.5949, 1.2793,\n", + " 1.0571, 0.8942, 0.7699, 0.6710, 0.5892, 0.5193, 0.4577, 0.4019, 0.3503,\n", + " 0.3017, 0.2554, 0.2106, 0.1671, 0.1245, 0.0826, 0.0411]) return= 57954.033617826586\n", + "probs of actions: tensor([0.8325, 0.8357, 0.8141, 0.8359, 0.7933, 0.7992, 0.8229, 0.8172, 0.8352,\n", + " 0.0415, 0.0380, 0.0604, 0.8413, 0.8241, 0.8457, 0.8438, 0.0498, 0.8735,\n", + " 0.0293, 0.8692, 0.8685, 0.8513, 0.8562, 0.0411, 0.3214],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.2066, 0.1935, 0.1951, 0.1597, 0.1608, 0.1616, 0.1622, 0.1858, 0.1529,\n", + " 0.1676, 0.1527, 0.1555, 0.1576, 0.1592, 0.1940, 0.2423])\n", + "finalReturns: tensor([1.6368, 1.7329, 1.7499, 1.7062, 1.6370, 1.5409, 1.4629, 1.3721, 1.2722,\n", + " 1.1658, 1.0316, 0.9273, 0.8060, 0.6980, 0.5860, 0.4710, 0.3537, 0.2012])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAheUlEQVR4nO3df3Sc1X3n8ffHsnBkJ/gHFlksm5gElyyGJAQdxy17cpKywW7TxG4WGtOw+GR96hOWtknaurW3bJ220ELZDV26hT2cwgbyA+xS6jghxPECPekSMBExxDHggwjEls3GSmwRghQsyd/9Y67s0Xjm0UgzGo1Gn9c5Opr5Ps+9czV+PN+59z7PfRQRmJmZlTJtohtgZmb1zYnCzMwyOVGYmVkmJwozM8vkRGFmZpmmT3QDqm3+/PmxePHiiW6Gmdmk8tRTT/0kIlqLbWu4RLF48WI6OjomuhlmZpOKpB+V2uahJzMzyzRiopB0l6TDkn5QZNsfSQpJ8/NimyR1StonaUVe/GJJe9K2WyUpxWdI2pLiuyQtziuzVtIL6WdtxX+tmZmNWjk9ii8AKwuDkhYBHwL258XOB9YAS1OZ2yQ1pc23A+uBJelnqM51wNGIOBe4Bbgp1TUP2Ay8D1gGbJY0d3R/npmZVWrERBER3waOFNl0C/DHQP4aIKuA+yLijYh4CegElkk6Czg9Ih6P3Joh9wCr88rcnR7fD1yaehsrgJ0RcSQijgI7KZKwzMxsfI1pjkLSR4GDEfFMwaY24EDe864Ua0uPC+PDykTEAPAqcEZGXcXas15Sh6SO7u7usfxJZmZWwqjPepI0E/hT4LJim4vEIiM+1jLDgxF3AHcAtLe3T4lVDrftPsjNO/ZxqKePBXNa2LDiPFZfVDSPmplVZCynx74DOAd4Js1HLwS+J2kZuW/9i/L2XQgcSvGFReLklemSNB2YTW6oqwv4QEGZfxlDeyetbbsP8rnte+np6wdgmuB4kTR4sKePz2x5ms9seXpYfGbzNGY0N9HT239KMnGiMbNyjTpRRMQe4Myh55JeBtoj4ieStgNfkfR5YAG5SesnI2JQ0muSlgO7gKuBv0tVbAfWAo8DlwOPRERI2gH8Vd4E9mXAprH8kZPJ0Af4wZ6+U7YVSxJZevuP09t/HDiZTDp+dIT2t81j0wN76OsfPLFt0wN7AJwszOwUIyYKSfeS+2Y/X1IXsDki7iy2b0TslbQVeBYYAK6NiMG0+RpyZ1C1AA+lH4A7gS9K6iTXk1iT6joi6S+B76b9/iIiik2q14VKvqEX9hzG05ee2M+Xn9h/yhheX/8gf7g1N+XkZGFm+dRoNy5qb2+Pal+ZPVIS2Lb74LBv6AAtzU389ccuHPFD97pte/jSE/sz96m1q5afzfWrL5zoZphZDUl6KiLai25zoigu9+H/ffrS0E0xc1qaOTYweGJ4p1DbnBYe2/irJevf8I9Pk1F9XWnzPIZZQ3OiGKVtuw+eMjFcibkzm9n8kaV0/OhI0WGfyULAJ9zbMGtIThSjdP5/fahkL8Fg1mlN9B4bLDkM57OpzCYfJ4pRWrzxwSq1Zmo4rUnMmjGdo739iOEXu7gXYjY5ZCUKrx5rFTs2GBztzZ2xVfi1I8idabVt98Gat8vMqqPh7kdh9anwgkBPjptNHk4UBa7btmeimzAljPYiP899mE0cJ4oC9XZNQyPr6x/ks1ufPvG8VCIovE7FV5Kb1ZYnswt4Iru+NEm8qXkarx8bPGXb0HUq7m2YVc6T2TZpDUYUTRKQ61kM9TYO9vQRnFzTavHGB7nkxkc8iW5WBR56skkt68LIgz19bLjf61eZVco9igJNxe6CYZNW/2DwB1ufds/CrALuURQYbKwpGyO3PPtn0xLrhRf+5c9vzG5pRqLo/TuqxfMpNhl5MruAJ7Mb29BV5D29/cxuaea1NwYYzLjRx9DNokpd9zGaD/5KVhk2G29ewmMUnCislOZp4uPLFvHo890neiCvHxugv6AbOrQIZOGH/yU3PlL0hlRZqwyb1UpWovDQUx6PY1uW/uMx7DqbUjeaOtrbz2fTlehtc1r44DtbefT57qJJAuBQibhZvXCiyHPzjn0T3QRrEEN9jIM9fSNexDlN4pyND7IgL6nUas7ErBweesrjYSerd/nDWvn3V2+SGIwYtnrv0PzKnJRwjvb2n9hvpLW2is29wPCr5/OTmhPZ5Oc5ijK9Y9M3GGyw98OsHDObc2fKV3IflpbmJv7DxW0nhtnKTUpWHzxHUSYnCZuqqnGjrr7+wWHDbEP/n0qtzXXdtj3cu+sAgxE0SVz5vkW+b0mdGrFHIeku4DeAwxFxQYrdDHwEOAa8CHwyInrStk3AOmAQ+P2I2JHiFwNfAFqAbwCfjoiQNAO4B7gY+Cnw8Yh4OZVZC1yXmnJ9RNw90h801h5FtW9/amanmjuzmZ7efqZPY8T7xV/yjnl8+Xd++ZS4r0UZHxUNPUl6P/Bz4J68RHEZ8EhEDEi6CSAi/kTS+cC9wDJgAfB/gF+KiEFJTwKfBp4glyhujYiHJP1n4F0R8SlJa4DfjIiPS5oHdADt5IZdnwIujoijWe0da6IodeqimU2sOXmT+lnXvgydYfb1Z145cUZaqVOV7VQVDT1FxLclLS6IfSvv6RPA5enxKuC+iHgDeElSJ7BM0svA6RHxeGrQPcBq4KFU5nOp/P3A/5QkYAWwMyKOpDI7gZXkElHV+RRFs/qUfxpyqVOSofgZZkd7+/nMlqf586/t5fyz3sJ3XjxyYrJ/aOK/2nMoWT2eYicgFP4ejcJbD0PpnlglqjFH8Z+ALelxG7nEMaQrxfrT48L4UJkDAKmH8ipwRn68SJlhJK0H1gOcffbZY/ojFsxpcY/CrEEd7e3nsRePDIvln8JceAfGasmqeygpFP4ejWIlHnvxCOdsfJCXbvzwqOsrpaJFASX9KTAAfHkoVGS3yIiPtczwYMQdEdEeEe2tra3ZjS5h6PQ/M7PJLoB3bf5m1eobc6JIE82/AXwiTk50dAGL8nZbCBxK8YVF4sPKSJoOzAaOZNQ1LjyGaWaN5GdvFL+Py1iMKVFIWgn8CfDRiOjN27QdWCNphqRzgCXAkxHxCvCapOVp/uFq4Kt5Zdamx5eTmyQPYAdwmaS5kuYCl6WYmZnV0IhzFJLuBT4AzJfUBWwGNgEzgJ25z32eiIhPRcReSVuBZ8kNSV0bEUNp7RpOnh77UPoBuBP4Ypr4PgKsAYiII5L+Evhu2u8vhia2zcysdso56+nKIuE7M/a/AbihSLwDuKBI/BfAFSXqugu4a6Q2mpnZ+PEd7hKvHGtmVpwTRfLnX9s70U0wM6tLThTJ0d7SF/KYmU1lThRmZpbJiQLPT5iZZXGiwHe2MzPL4kSBFwQ0M8viREFuQUAzMyvOiQIvCGhmlsWJAuj4kVcGMTMrxYkC+Mqu/SPvZGY2RTlRAEXuqmhmZokThZmZZXKiMDOzTE4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZplGTBSS7pJ0WNIP8mLzJO2U9EL6PTdv2yZJnZL2SVqRF79Y0p607VZJSvEZkrak+C5Ji/PKrE2v8YKktVX7q83MGlxzFbsB5VT1BWBlQWwj8HBELAEeTs+RdD6wBliaytwmqSmVuR1YDyxJP0N1rgOORsS5wC3ATamuecBm4H3AMmBzfkIyM7PS3vym5qrVNWKiiIhvA4WLIa0C7k6P7wZW58Xvi4g3IuIloBNYJuks4PSIeDwiArinoMxQXfcDl6bexgpgZ0QciYijwE5OTVhmZlZETxVv7zzWzslbI+IVgPT7zBRvAw7k7deVYm3pcWF8WJmIGABeBc7IqOsUktZL6pDU0d3dPcY/ycysccyZWcMexSipSCwy4mMtMzwYcUdEtEdEe2tra1kNNTNrZFHFNezGmih+nIaTSL8Pp3gXsChvv4XAoRRfWCQ+rIyk6cBsckNdpeoyM7MR9PRN/NDTdmDoLKS1wFfz4mvSmUznkJu0fjINT70maXmaf7i6oMxQXZcDj6R5jB3AZZLmpknsy1LMzMxqaPpIO0i6F/gAMF9SF7kzkW4EtkpaB+wHrgCIiL2StgLPAgPAtRExmKq6htwZVC3AQ+kH4E7gi5I6yfUk1qS6jkj6S+C7ab+/iAjfYcjMrMZGTBQRcWWJTZeW2P8G4IYi8Q7ggiLxX5ASTZFtdwF3jdRGMzMbrtgk71j5ymwzswbU3FS9VOFEYWbWgI4NVu+0JycKMzPL5ERhZmaZnCjMzBpQSxVXBXSiMDNrQIPHPUdhZmYZPJltZmY140RhZmaZnCjMzCyTE4WZWQOa6bOezMwsS1//8arV5URhZtaAqnjfIicKMzPL5kRhZmaZnCjMzCyTE4WZmWVyojAzs0xOFGZmDcirx5qZWaa//ti7qlZXRYlC0mcl7ZX0A0n3SnqTpHmSdkp6If2em7f/JkmdkvZJWpEXv1jSnrTtVklK8RmStqT4LkmLK2mvmdlUcNXys1l9UVvV6htzopDUBvw+0B4RFwBNwBpgI/BwRCwBHk7PkXR+2r4UWAncJqkpVXc7sB5Ykn5Wpvg64GhEnAvcAtw01vaamU0Vjz7fXdX6Kh16mg60SJoOzAQOAauAu9P2u4HV6fEq4L6IeCMiXgI6gWWSzgJOj4jHIyKAewrKDNV1P3DpUG/DzMyKO9TTV9X6xpwoIuIg8N+A/cArwKsR8S3grRHxStrnFeDMVKQNOJBXRVeKtaXHhfFhZSJiAHgVOKOwLZLWS+qQ1NHdXd1MamY22SyY01LV+ioZeppL7hv/OcACYJakq7KKFIlFRjyrzPBAxB0R0R4R7a2trdkNNzNrcIvPqJNEAfx74KWI6I6IfuAB4FeAH6fhJNLvw2n/LmBRXvmF5IaqutLjwviwMml4azZwpII2m5k1vMdePMJ12/ZUrb5KEsV+YLmkmWne4FLgOWA7sDbtsxb4anq8HViTzmQ6h9yk9ZNpeOo1SctTPVcXlBmq63LgkTSPYWZmGb70xP6q1TV9rAUjYpek+4HvAQPAbuAO4M3AVknryCWTK9L+eyVtBZ5N+18bEYOpumuALwAtwEPpB+BO4IuSOsn1JNaMtb1mZjY2Y04UABGxGdhcEH6DXO+i2P43ADcUiXcAFxSJ/4KUaMzMbGL4ymwzM8vkRGFmZpmcKMzMLJMThZmZZXKiMDOzTE4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFm1oBmTPc9s83MLMMbA8erVpcThZmZZXKiMDOzTE4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZpmcKMzMLFNFiULSHEn3S3pe0nOSflnSPEk7Jb2Qfs/N23+TpE5J+yStyItfLGlP2narJKX4DElbUnyXpMWVtNfMzEav0h7F/wC+GRHvBN4NPAdsBB6OiCXAw+k5ks4H1gBLgZXAbZKaUj23A+uBJelnZYqvA45GxLnALcBNFbbXzMxGacyJQtLpwPuBOwEi4lhE9ACrgLvTbncDq9PjVcB9EfFGRLwEdALLJJ0FnB4Rj0dEAPcUlBmq637g0qHehpmZ1UYlPYq3A93A/5a0W9I/SJoFvDUiXgFIv89M+7cBB/LKd6VYW3pcGB9WJiIGgFeBMypos5mZjVIliWI68F7g9oi4CHidNMxUQrGeQGTEs8oMr1haL6lDUkd3d3d2q83MbFQqSRRdQFdE7ErP7yeXOH6chpNIvw/n7b8or/xC4FCKLywSH1ZG0nRgNnCksCERcUdEtEdEe2trawV/kpmZFRpzooiI/wcckHReCl0KPAtsB9am2Frgq+nxdmBNOpPpHHKT1k+m4anXJC1P8w9XF5QZquty4JE0j2FmZjUyvcLyvwd8WdJpwA+BT5JLPlslrQP2A1cARMReSVvJJZMB4NqIGEz1XAN8AWgBHko/kJso/6KkTnI9iTUVttfMzEapokQREU8D7UU2XVpi/xuAG4rEO4ALisR/QUo0ZmY2MXxltpmZZXKiMDOzTE4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZpmcKMzMGtBVy8+uWl2VXpltZmZ1ZJrgt993NtevvrBqdTpRmJnVmSVnzqL32HEO9vTRJDEYwZyWZo4NDNLbfxyAuTOb2fyRpay+qG2E2irnRGFmVmde/snrpHzAYFoHtaevnyaJq5af7C1ct20Pn93y9Il7L8w6rYkbfvPCqicPNdpirO3t7dHR0TGqMos3PjhOrTEzmxgv3/jhUe0v6amIKLZ2nyezzcwa0TlV/ALsRGFm1oCqOVbkRGFmZpmcKMzMLJMThZmZZXKiMDOzTE4UZmYNaLSnx2ZxojAzazCqcn0VJwpJTZJ2S/p6ej5P0k5JL6Tfc/P23SSpU9I+SSvy4hdL2pO23SpJKT5D0pYU3yVpcaXtNTNrdAvmtFS1vmr0KD4NPJf3fCPwcEQsAR5Oz5F0PrAGWAqsBG6T1JTK3A6sB5akn5Upvg44GhHnArcAN1WhvWZmDW3DivOqWl9FiULSQuDDwD/khVcBd6fHdwOr8+L3RcQbEfES0Aksk3QWcHpEPB659UTuKSgzVNf9wKVDvQ0zM6uNSnsUfwv8MXA8L/bWiHgFIP0+M8XbgAN5+3WlWFt6XBgfViYiBoBXgTMKGyFpvaQOSR3d3d0V/klmZpPbn39tb1XrG3OikPQbwOGIeKrcIkVikRHPKjM8EHFHRLRHRHtra2uZzTEza0xHe/urWl8ly4xfAnxU0q8DbwJOl/Ql4MeSzoqIV9Kw0uG0fxewKK/8QuBQii8sEs8v0yVpOjAbOFJBm83MbJTG3KOIiE0RsTAiFpObpH4kIq4CtgNr025rga+mx9uBNelMpnPITVo/mYanXpO0PM0/XF1QZqiuy9NrNNa66GZmVdZc5QsfxuM6ihuBD0l6AfhQek5E7AW2As8C3wSujYjBVOYachPincCLwEMpfidwhqRO4A9IZ1CZmVlp/cdh2+6DVavPNy7CNy4ys8Yzd2Yzu//ssrL3942LzMymmGpOaDtRmJlZJicKM7MGNKeluWp1OVGYmTWgz310adXqcqIwM2sg06eJv/34e1h9UdvIO5dbZ9VqMjOzqpkmOB7QJDEYgTh1WYrTmsSsGdPp6e1nwZwWNqw4r6oJ4kRbql6jmZlV7HjKCoPpEoZiFzIcGwyO9vYTwMGePj6z5WkWb3yQD33+X6raFicKM7MG88Lh16uaLJwozMwa0AuHX69aXU4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZpmcKMzMLJMThZmZZXKiMDOzTE4UZmYN6G8//p6q1eVEYWbWQGad1uTVY83M7FQtzU389ccurK/VYyUtkvSopOck7ZX06RSfJ2mnpBfS77l5ZTZJ6pS0T9KKvPjFkvakbbdKUorPkLQlxXdJWlzB32pm1rD6+gf5w63PsG33warXXcnQ0wDwhxHxb4HlwLWSzgc2Ag9HxBLg4fSctG0NsBRYCdwmqSnVdTuwHliSflam+DrgaEScC9wC3FRBe83MGtpgBJse2FP1ZDHmRBERr0TE99Lj14DngDZgFXB32u1uYHV6vAq4LyLeiIiXgE5gmaSzgNMj4vGICOCegjJDdd0PXDrU2zAzs1P19Q9y8459Va2zKpPZaUjoImAX8NaIeAVyyQQ4M+3WBhzIK9aVYm3pcWF8WJmIGABeBc4o8vrrJXVI6uju7q7Gn2RmNmkd6umran0VJwpJbwb+CfhMRPwsa9cisciIZ5UZHoi4IyLaI6K9tbV1pCabmTW0BXNaqlpfRYlCUjO5JPHliHgghX+chpNIvw+neBewKK/4QuBQii8sEh9WRtJ0YDZwpJI2m5nVs6ZRDK7PbJ5Gc0GBluYmNqw4r6ptGvPpsWmu4E7guYj4fN6m7cBa4Mb0+6t58a9I+jywgNyk9ZMRMSjpNUnLyQ1dXQ38XUFdjwOXA4+keQwzs0mtbU4Lj2381Yrr2bb7IDfv2Mehnj4WzGlhw4rzqn6KbCXXUVwC/Edgj6SnU+y/kEsQWyWtA/YDVwBExF5JW4FnyZ0xdW1EDKZy1wBfAFqAh9IP5BLRFyV1kutJrKmgvWZm46Z5mkDQPzjyd9lqfutffVHbuFw7kW/MiSIi/i/F5xAALi1R5gbghiLxDuCCIvFfkBKNmdlEWXLmLF7+SS/9x4sngbb0TR7g5h37ONjThxg+oTr0vG2cvvWPJ1+ZbWaWzGlpZumCt/DYiyenQmdMn0bn4deZ3dLMsYFBevuPAzB3ZjObP7L0lA/81Re1sW33QTY98H360r7TBL/9vrO5fvWFtftjqsiJwswsaX3LacOSBMAbA7kP+56+fqB0ghiybfdBNvzjM8N6H8cDtnz3AO1vmzepehJDvCigmVnywuHXR9znaG9/5tXPN+/YV3SIqn8wqn4hXK04UZiZjVLW1c9ZF7tV+0K4WnGiMDMbg1If+lkXu1X7QrhacaKoU83TxMxm//OY1dJo/suV+tDfsOK83KmyhXU3qeoXwtWKJ7PrULHT57btPsjntu89MaFmZtV38xXvoeNHR7h31wEGIxC5D/hjBddGZF0HMfT/Nv//60gT4PVOjXahc3t7e3R0dIyqzOKND45Ta3La5rTwwXe28ujz3SeunvzgO1v5+jOvjPpAympr25wWDvX0MbulGSk36WZm5Xv5xg8Xjdfi6ueJJumpiGgvts09inHU3CRuvvzdJQ+osZxT3TanhYNFxkaLLQdwyY2PFN3XrN4VXqxWTNM08fb5M4edqbTkzFn0Hjt+4gtT/nUPkLueocQ1c7RlzB/U4urneuZEUQVXLT+b9rfNq0lXc8OK89j0wB76+gdPxEp1g0vtm/98JDObp9E/eJy8/2tm40rALR9/D8Cwb/GFvfKxfqvPXQxX3v8hy3GiqJA42TOoxTeOodcopxtcat+hJQYKzWlpZtaM6UXrvW7bnhPjtk0SV75vEdevvnBYHE5+ExyaymusgU2rheDksTse/6dG83/IcjxHQWVzFNVaAbKWSn2jqvaN2Yu9jtlIJuP/qUbgOYpxNBm7q7X6RpX/Op4rqT+nNYmBwaCeRhU9BFSfnCgqNFm7q7WanMt/neu27eHLT+yv2+Go5mmMei5GwLlnzuKH3b1Fh+UK/96xvMZ4aJom/ubydwMMW7zuxHaJ5W+fy95Dr5V1Snb+yqj5cwmzW5p5/djAsKW3m6eJN79pOj29/SfO0Ovp7fcQUB1zoqhA1lkSdqrrV19I+9vmDevJ9B4bGPE03ibpxIfwYMSJD6P8uZFCpa5FKTYUln/iwUjJ7JJ3zOPln/aV1RO7fvWFRc9sK3WqZbmnYI6mPJzs0eW/f/l1l/vBnF//aD7gp8KppY3OcxSMbY5iPMb0p6KR5jGy3uexzLWM5kPLH3A2lXiOokqaJI5H+EOjigrnS0bzTXUscy2jGXKb6ufOmw1xohiF//5bpS+es7Gr5APZH+Zm48+rzpVpZvM0fyCZ2ZQ0KRKFpJWS9knqlLSx1q/fNE381cfeVeuXNTOrC3WfKCQ1AX8P/BpwPnClpPNr2YYrly1yb8LMpqy6TxTAMqAzIn4YEceA+4BVtWzAo8931/LlzMzqymRIFG3AgbznXSl2gqT1kjokdXR3V/9DfbLevtDMrBomQ6I49VZRBWvNRcQdEdEeEe2tra1Vb8BkvX2hmVk1TIZE0QUsynu+EDhUqxefzLcvNDOrhsmQKL4LLJF0jqTTgDXA9mq+QKmlOCQybzxkZjYV1H2iiIgB4HeBHcBzwNaI2FvN19iw4jxampuGxVqam7jlt97jJGFmU96kuDI7Ir4BfGO86veNTMzMSpsUiaIWvBSEmVlxdT/0ZGZmE8uJwszMMjlRmJlZJicKMzPL5ERhZmaZGu5WqJK6gR9VUMV84CdVas54cjura7K0EyZPW93O6hvPtr4tIoqugdRwiaJSkjpK3Te2nrid1TVZ2gmTp61uZ/VNVFs99GRmZpmcKMzMLJMTxanumOgGlMntrK7J0k6YPG11O6tvQtrqOQozM8vkHoWZmWVyojAzs0xTJlFIWilpn6ROSRuLbJekW9P270t6b7lla9zOT6T2fV/SdyS9O2/by5L2SHpaUsd4trPMtn5A0qupPU9L+rNyy9a4nRvy2vgDSYOS5qVtNXtPJd0l6bCkH5TYXi/H6EjtrItjtIx21sXxWWZbJ/YYjYiG/wGagBeBtwOnAc8A5xfs8+vAQ+Tu0b0c2FVu2Rq381eAuenxrw21Mz1/GZhfR+/pB4Cvj6VsLdtZsP9HgEcm6D19P/Be4Acltk/4MVpmO+vlGB2pnRN+fJbb1ok+RqdKj2IZ0BkRP4yIY8B9wKqCfVYB90TOE8AcSWeVWbZm7YyI70TE0fT0CXL3EJ8IlbwvdfWeFrgSuHec2pIpIr4NHMnYpR6O0RHbWS/HaBnvZyk1fT9h1G2t+TE6VRJFG3Ag73lXipWzTzllq2W0r7WO3DfMIQF8S9JTktaPQ/vyldvWX5b0jKSHJC0dZdlqKPu1JM0EVgL/lBeu5Xs6kno4RkdrIo/Rckz08TkqE3WMTpU73KlIrPC84FL7lFO2Wsp+LUkfJPef8N/lhS+JiEOSzgR2Sno+fVMZD+W09Xvk1o/5uaRfB7YBS8osWy2jea2PAI9FRP43u1q+pyOph2O0bHVwjI6kHo7P0ZqQY3Sq9Ci6gEV5zxcCh8rcp5yy1VLWa0l6F/APwKqI+OlQPCIOpd+HgX8m14UeLyO2NSJ+FhE/T4+/ATRLml9O2Vq2M88aCrr0NX5PR1IPx2hZ6uQYzVQnx+doTcwxOp4TIPXyQ67n9EPgHE5OTi0t2OfDDJ8ofLLcsjVu59lAJ/ArBfFZwFvyHn8HWDnB7+m/4eRFncuA/en9rav3NO03m9wY8ayJek/T6yym9OTrhB+jZbazLo7RMto54cdnuW2d6GN0Sgw9RcSApN8FdpA7o+GuiNgr6VNp+/8CvkHurJJOoBf4ZFbZCWznnwFnALdJAhiI3GqSbwX+OcWmA1+JiG+ORztH0dbLgWskDQB9wJrIHdH19p4C/CbwrYh4Pa94Td9TSfeSOxNnvqQuYDPQnNfOCT9Gy2xnXRyjZbRzwo/PUbQVJvAY9RIeZmaWaarMUZiZ2Rg5UZiZWSYnCjMzy+REYWZmmZwozMwmuZEWFSyy/29JelbSXklfGXF/n/VkZja5SXo/8HNya4FdMMK+S4CtwK9GxFFJZ0buYr2S3KMwM5vkosiigpLeIembaQ2of5X0zrTpd4C/j7Rw40hJApwozMwa1R3A70XExcAfAbel+C8BvyTpMUlPSFo5UkVT4spsM7OpRNKbyd0X5B/TVdsAM9Lv6eQWP/wAuXWs/lXSBRHRU6o+Jwozs8YzDeiJiPcU2dYFPBER/cBLkvaRSxzfzarMzMwaSET8jFwSuAJO3EZ36Ja024APpvh8ckNRP8yqz4nCzGySS4sKPg6cJ6lL0jrgE8A6Sc8Aezl5l74dwE8lPQs8CmyIvKXgi9bv02PNzCyLexRmZpbJicLMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFmZll+v8qTcEu3r3kNQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 29, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 27, 31, 31, 1])\n", + "loss= tensor(5.2757, grad_fn=) , base rewards= tensor([1.6760, 1.6760, 1.6760, 1.6760, 1.6760, 1.6760, 1.6760, 1.3464, 1.1154,\n", + " 0.9469, 0.8189, 0.7175, 0.6341, 0.5631, 0.5006, 0.4442, 0.3922, 0.3433,\n", + " 0.2967, 0.2519, 0.2082, 0.1655, 0.1235, 0.0820, 0.0408]) return= 58180.61659464621\n", + "probs of actions: tensor([0.8774, 0.8800, 0.8614, 0.8784, 0.8430, 0.0356, 0.8700, 0.8659, 0.8779,\n", + " 0.8537, 0.8715, 0.8807, 0.8843, 0.8721, 0.8878, 0.8914, 0.9131, 0.9108,\n", + " 0.9102, 0.9068, 0.9042, 0.0376, 0.8956, 0.3902, 0.2982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2785, 0.2335, 0.2154, 0.2021,\n", + " 0.1923, 0.1851, 0.1798, 0.1758, 0.1728, 0.1706, 0.1689, 0.1677, 0.1668,\n", + " 0.1661, 0.1656, 0.1652, 0.1881, 0.1545, 0.1569, 0.2547])\n", + "finalReturns: tensor([1.8057, 1.9018, 1.9174, 1.8838, 1.8195, 1.7357, 1.6394, 1.5347, 1.4244,\n", + " 1.3102, 1.1932, 1.0744, 0.9542, 0.8330, 0.7111, 0.5886, 0.4426, 0.3296,\n", + " 0.2138])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 27, 31, 31, 37, 31, 31, 31, 31, 31, 31, 31, 31, 31, 40,\n", + " 31, 24, 31, 31, 31, 32, 0])\n", + "loss= tensor(27.8911, grad_fn=) , base rewards= tensor([1.6677, 1.6677, 1.6677, 1.6677, 1.6677, 1.6677, 1.6677, 1.3410, 1.1118,\n", + " 0.9445, 0.8172, 0.7164, 0.6333, 0.5625, 0.5002, 0.4439, 0.3920, 0.3432,\n", + " 0.2966, 0.2518, 0.2082, 0.1655, 0.1235, 0.0820, 0.0408]) return= 58265.43885686597\n", + "probs of actions: tensor([0.8874, 0.8895, 0.8716, 0.8875, 0.0482, 0.8610, 0.8822, 0.0011, 0.8882,\n", + " 0.8656, 0.8855, 0.8895, 0.8957, 0.8855, 0.8965, 0.9028, 0.9227, 0.0024,\n", + " 0.9179, 0.0052, 0.9160, 0.9033, 0.9021, 0.0167, 0.6180],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3276, 0.2545, 0.2306, 0.1725, 0.2171,\n", + " 0.2034, 0.1933, 0.1858, 0.1803, 0.1762, 0.1731, 0.1708, 0.1691, 0.1039,\n", + " 0.1904, 0.2222, 0.1607, 0.1615, 0.1621, 0.1563, 0.2616])\n", + "finalReturns: tensor([1.8232, 1.9193, 1.9760, 1.9261, 1.8501, 1.7576, 1.6549, 1.5454, 1.4316,\n", + " 1.3148, 1.1959, 1.0756, 1.0182, 0.8726, 0.6940, 0.5760, 0.4565, 0.3359,\n", + " 0.2208])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 27, 31, 31, 31, 31, 31, 29, 31, 31, 31, 31, 24, 27, 31,\n", + " 31, 39, 31, 31, 31, 25, 0])\n", + "loss= tensor(26.2829, grad_fn=) , base rewards= tensor([1.7770, 1.7770, 1.7770, 1.7770, 1.7770, 1.7770, 1.4263, 1.1822, 1.0053,\n", + " 0.8717, 0.7667, 0.6808, 0.6080, 0.5443, 0.4871, 0.4345, 0.3851, 0.3382,\n", + " 0.2931, 0.2493, 0.2065, 0.1643, 0.1227, 0.0816, 0.0407]) return= 57833.96628910951\n", + "probs of actions: tensor([0.9180, 0.9193, 0.9051, 0.9169, 0.0342, 0.9014, 0.9153, 0.9112, 0.9190,\n", + " 0.8999, 0.0201, 0.9197, 0.9241, 0.9130, 0.9241, 0.0051, 0.0184, 0.9439,\n", + " 0.9437, 0.0031, 0.9346, 0.9307, 0.9283, 0.0442, 0.6480],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3276, 0.2545, 0.2306, 0.2133, 0.2006,\n", + " 0.1912, 0.1963, 0.1739, 0.1714, 0.1695, 0.1682, 0.2056, 0.1719, 0.1426,\n", + " 0.1479, 0.0959, 0.1753, 0.1725, 0.1703, 0.2023, 0.2485])\n", + "finalReturns: tensor([1.9253, 2.0214, 2.0349, 1.9985, 1.9315, 1.8454, 1.7350, 1.6339, 1.5261,\n", + " 1.4138, 1.2983, 1.1420, 1.0170, 0.9195, 0.8155, 0.7625, 0.6293, 0.4984,\n", + " 0.3693, 0.2078])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 25, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(12.0034, grad_fn=) , base rewards= tensor([1.8111, 1.8111, 1.8111, 1.8111, 1.8111, 1.8111, 1.4485, 1.1969, 1.0152,\n", + " 0.8786, 0.7715, 0.6842, 0.6104, 0.5461, 0.4884, 0.4354, 0.3858, 0.3387,\n", + " 0.2935, 0.2495, 0.2066, 0.1644, 0.1228, 0.0816, 0.0407]) return= 58024.42135846493\n", + "probs of actions: tensor([0.9359, 0.9372, 0.9246, 0.9343, 0.9109, 0.9217, 0.9317, 0.9339, 0.9400,\n", + " 0.9226, 0.9344, 0.9392, 0.0023, 0.9339, 0.9421, 0.9472, 0.9599, 0.9588,\n", + " 0.9587, 0.9515, 0.9507, 0.9465, 0.9434, 0.2981, 0.6230],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.2103, 0.1581, 0.1596, 0.1607, 0.1615, 0.1621,\n", + " 0.1626, 0.1630, 0.1632, 0.1634, 0.1636, 0.1637, 0.2599])\n", + "finalReturns: tensor([1.9335, 2.0296, 2.0419, 2.0040, 1.9355, 1.8480, 1.7485, 1.6412, 1.4953,\n", + " 1.3949, 1.2883, 1.1771, 1.0627, 0.9458, 0.8271, 0.7071, 0.5860, 0.4643,\n", + " 0.3419, 0.2192])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 17, 1])\n", + "loss= tensor(2.9145, grad_fn=) , base rewards= tensor([1.9592, 1.9592, 1.9592, 1.9592, 1.9592, 1.5587, 1.2834, 1.0868, 0.9404,\n", + " 0.8268, 0.7352, 0.6584, 0.5920, 0.5328, 0.4787, 0.4284, 0.3807, 0.3350,\n", + " 0.2908, 0.2477, 0.2053, 0.1636, 0.1223, 0.0813, 0.0406]) return= 58608.19485133026\n", + "probs of actions: tensor([0.9404, 0.9414, 0.9293, 0.9381, 0.9158, 0.9273, 0.9372, 0.9422, 0.9422,\n", + " 0.9316, 0.9394, 0.9456, 0.9444, 0.9411, 0.9465, 0.9513, 0.9646, 0.9628,\n", + " 0.9621, 0.9547, 0.9518, 0.9511, 0.9455, 0.0722, 0.3653],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1735, 0.1711, 0.1693, 0.1680, 0.1670,\n", + " 0.1662, 0.1657, 0.1653, 0.1649, 0.1647, 0.2317, 0.2259])\n", + "finalReturns: tensor([2.1481, 2.2442, 2.2530, 2.2104, 2.1372, 2.0456, 1.9426, 1.8326, 1.7181,\n", + " 1.6006, 1.4811, 1.3604, 1.2387, 1.1164, 0.9936, 0.8705, 0.7472, 0.6237,\n", + " 0.5001, 0.3763, 0.1853])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 34, 31, 31, 31, 21, 0])\n", + "loss= tensor(7.6096, grad_fn=) , base rewards= tensor([1.9592, 1.9592, 1.9592, 1.9592, 1.9592, 1.5587, 1.2834, 1.0868, 0.9404,\n", + " 0.8268, 0.7352, 0.6584, 0.5920, 0.5328, 0.4787, 0.4284, 0.3807, 0.3350,\n", + " 0.2908, 0.2477, 0.2053, 0.1636, 0.1223, 0.0813, 0.0406]) return= 58592.08278205747\n", + "probs of actions: tensor([0.9471, 0.9480, 0.9373, 0.9446, 0.9288, 0.9370, 0.9421, 0.9505, 0.9499,\n", + " 0.9375, 0.9450, 0.9518, 0.9503, 0.9493, 0.9544, 0.9582, 0.9693, 0.9684,\n", + " 0.9665, 0.0025, 0.9573, 0.9576, 0.9540, 0.1182, 0.5753],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1735, 0.1711, 0.1693, 0.1680, 0.1670,\n", + " 0.1662, 0.1462, 0.1730, 0.1707, 0.1690, 0.2198, 0.2379])\n", + "finalReturns: tensor([2.1465, 2.2426, 2.2514, 2.2088, 2.1356, 2.0440, 1.9410, 1.8310, 1.7164,\n", + " 1.5990, 1.4795, 1.3588, 1.2371, 1.1148, 0.9920, 0.8689, 0.7651, 0.6339,\n", + " 0.5044, 0.3764, 0.1974])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 27, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 30, 21, 0])\n", + "loss= tensor(12.7550, grad_fn=) , base rewards= tensor([2.1499, 2.1499, 2.1499, 2.1499, 1.6959, 1.3875, 1.1698, 1.0099, 0.8875,\n", + " 0.7898, 0.7090, 0.6397, 0.5785, 0.5230, 0.4716, 0.4232, 0.3769, 0.3323,\n", + " 0.2889, 0.2463, 0.2044, 0.1629, 0.1219, 0.0811, 0.0405]) return= 58411.33868143202\n", + "probs of actions: tensor([0.9562, 0.9571, 0.9480, 0.9560, 0.9438, 0.9475, 0.9537, 0.9604, 0.9576,\n", + " 0.9505, 0.9553, 0.9593, 0.9598, 0.0094, 0.9640, 0.9652, 0.9753, 0.9747,\n", + " 0.9734, 0.9684, 0.9644, 0.9636, 0.0016, 0.1175, 0.6460],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1967, 0.1609, 0.1616, 0.1622, 0.1627,\n", + " 0.1630, 0.1633, 0.1634, 0.1636, 0.1698, 0.2132, 0.2332])\n", + "finalReturns: tensor([2.2956, 2.3917, 2.3958, 2.3469, 2.2676, 2.1704, 2.0629, 1.9491, 1.8317,\n", + " 1.7119, 1.5907, 1.4454, 1.3329, 1.2175, 1.0999, 0.9807, 0.8602, 0.7389,\n", + " 0.6169, 0.4944, 0.3654, 0.1928])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 18, 1])\n", + "loss= tensor(1.8218, grad_fn=) , base rewards= tensor([2.1499, 2.1499, 2.1499, 2.1499, 1.6959, 1.3875, 1.1698, 1.0099, 0.8875,\n", + " 0.7898, 0.7090, 0.6397, 0.5785, 0.5230, 0.4716, 0.4232, 0.3769, 0.3323,\n", + " 0.2889, 0.2463, 0.2044, 0.1629, 0.1219, 0.0811, 0.0405]) return= 58597.02683384424\n", + "probs of actions: tensor([0.9642, 0.9647, 0.9569, 0.9651, 0.9541, 0.9580, 0.9632, 0.9678, 0.9652,\n", + " 0.9612, 0.9652, 0.9674, 0.9665, 0.9650, 0.9709, 0.9721, 0.9811, 0.9802,\n", + " 0.9801, 0.9746, 0.9717, 0.9707, 0.9695, 0.2244, 0.4172],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1735, 0.1711, 0.1693, 0.1680, 0.1670,\n", + " 0.1662, 0.1657, 0.1653, 0.1649, 0.1647, 0.2282, 0.2283])\n", + "finalReturns: tensor([2.3142, 2.4103, 2.4143, 2.3655, 2.2861, 2.1890, 2.0815, 1.9677, 1.8502,\n", + " 1.7305, 1.6093, 1.4871, 1.3644, 1.2414, 1.1180, 0.9945, 0.8708, 0.7470,\n", + " 0.6232, 0.4994, 0.3755, 0.1878])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 21, 29, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 25, 1])\n", + "loss= tensor(30.5883, grad_fn=) , base rewards= tensor([2.4026, 2.4026, 2.4026, 1.8720, 1.5164, 1.2692, 1.0903, 0.9555, 0.8496,\n", + " 0.7631, 0.6899, 0.6260, 0.5685, 0.5157, 0.4663, 0.4193, 0.3741, 0.3303,\n", + " 0.2874, 0.2453, 0.2037, 0.1625, 0.1216, 0.0809, 0.0404]) return= 57688.5045591656\n", + "probs of actions: tensor([9.6275e-01, 9.6327e-01, 9.3141e-04, 9.8535e-03, 9.5129e-01, 9.5643e-01,\n", + " 9.6030e-01, 9.6674e-01, 9.6550e-01, 9.5963e-01, 9.6508e-01, 9.6382e-01,\n", + " 9.6632e-01, 9.6317e-01, 9.7018e-01, 9.7201e-01, 9.8025e-01, 9.7969e-01,\n", + " 9.7948e-01, 9.7395e-01, 9.7149e-01, 9.7063e-01, 9.6964e-01, 2.7223e-02,\n", + " 5.2856e-01], grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4865, 0.3369, 0.2749, 0.2454, 0.2240, 0.2084, 0.1970,\n", + " 0.1885, 0.1823, 0.1777, 0.1742, 0.1716, 0.1697, 0.1683, 0.1672, 0.1664,\n", + " 0.1658, 0.1654, 0.1650, 0.1648, 0.1646, 0.1980, 0.2452])\n", + "finalReturns: tensor([2.4052, 2.4493, 2.4680, 2.4403, 2.3739, 2.2847, 2.1822, 2.0717, 1.9563,\n", + " 1.8380, 1.7178, 1.5963, 1.4741, 1.3514, 1.2283, 1.1049, 0.9814, 0.8577,\n", + " 0.7340, 0.6101, 0.4863, 0.3624, 0.2049])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 30, 31, 29, 1])\n", + "loss= tensor(22.2510, grad_fn=) , base rewards= tensor([2.4026, 2.4026, 2.4026, 1.8720, 1.5164, 1.2692, 1.0903, 0.9555, 0.8496,\n", + " 0.7631, 0.6899, 0.6260, 0.5685, 0.5157, 0.4663, 0.4193, 0.3741, 0.3303,\n", + " 0.2874, 0.2453, 0.2037, 0.1625, 0.1216, 0.0809, 0.0404]) return= 58304.33205910175\n", + "probs of actions: tensor([0.9695, 0.9698, 0.9641, 0.9739, 0.9600, 0.0017, 0.9679, 0.9748, 0.9721,\n", + " 0.9664, 0.9720, 0.9699, 0.9728, 0.9710, 0.9750, 0.9774, 0.9844, 0.9832,\n", + " 0.9838, 0.9794, 0.9758, 0.0013, 0.9758, 0.0260, 0.5039],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2726, 0.2364, 0.2175, 0.2036,\n", + " 0.1935, 0.1859, 0.1804, 0.1762, 0.1731, 0.1708, 0.1691, 0.1678, 0.1669,\n", + " 0.1662, 0.1656, 0.1652, 0.1710, 0.1621, 0.1746, 0.2539])\n", + "finalReturns: tensor([2.4668, 2.5629, 2.5605, 2.5034, 2.4096, 2.3081, 2.1965, 2.0794, 1.9591,\n", + " 1.8371, 1.7142, 1.5907, 1.4670, 1.3431, 1.2192, 1.0952, 0.9712, 0.8472,\n", + " 0.7232, 0.5992, 0.4691, 0.3476, 0.2135])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 25, 0])\n", + "loss= tensor(2.4772, grad_fn=) , base rewards= tensor([2.7473, 2.7473, 2.1053, 1.6816, 1.3919, 1.1861, 1.0339, 0.9164, 0.8222,\n", + " 0.7436, 0.6759, 0.6158, 0.5611, 0.5103, 0.4624, 0.4164, 0.3720, 0.3288,\n", + " 0.2863, 0.2445, 0.2031, 0.1621, 0.1213, 0.0808, 0.0403]) return= 58467.35071144204\n", + "probs of actions: tensor([0.9746, 0.9753, 0.9705, 0.9794, 0.9670, 0.9726, 0.9726, 0.9792, 0.9777,\n", + " 0.9723, 0.9771, 0.9774, 0.9789, 0.9766, 0.9797, 0.9814, 0.9873, 0.9862,\n", + " 0.9870, 0.9834, 0.9797, 0.9808, 0.9814, 0.0192, 0.5321],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1735, 0.1711, 0.1693, 0.1680, 0.1670,\n", + " 0.1662, 0.1657, 0.1653, 0.1649, 0.1647, 0.1981, 0.2454])\n", + "finalReturns: tensor([2.6843, 2.7804, 2.7696, 2.7013, 2.6027, 2.4885, 2.3666, 2.2413, 2.1147,\n", + " 1.9878, 1.8611, 1.7348, 1.6089, 1.4834, 1.3582, 1.2333, 1.1086, 0.9841,\n", + " 0.8596, 0.7353, 0.6111, 0.4869, 0.3628, 0.2051])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 18, 0])\n", + "loss= tensor(1.4614, grad_fn=) , base rewards= tensor([2.7473, 2.7473, 2.1053, 1.6816, 1.3919, 1.1861, 1.0339, 0.9164, 0.8222,\n", + " 0.7436, 0.6759, 0.6158, 0.5611, 0.5103, 0.4624, 0.4164, 0.3720, 0.3288,\n", + " 0.2863, 0.2445, 0.2031, 0.1621, 0.1213, 0.0808, 0.0403]) return= 58598.02683384424\n", + "probs of actions: tensor([0.9732, 0.9728, 0.9689, 0.9787, 0.9656, 0.9717, 0.9730, 0.9787, 0.9769,\n", + " 0.9709, 0.9765, 0.9773, 0.9774, 0.9766, 0.9800, 0.9798, 0.9877, 0.9855,\n", + " 0.9866, 0.9831, 0.9799, 0.9805, 0.9808, 0.3507, 0.5428],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.1946, 0.1868, 0.1810, 0.1767, 0.1735, 0.1711, 0.1693, 0.1680, 0.1670,\n", + " 0.1662, 0.1657, 0.1653, 0.1649, 0.1647, 0.2282, 0.2284])\n", + "finalReturns: tensor([2.6974, 2.7935, 2.7827, 2.7144, 2.6157, 2.5015, 2.3797, 2.2544, 2.1278,\n", + " 2.0009, 1.8742, 1.7479, 1.6220, 1.4965, 1.3713, 1.2464, 1.1217, 0.9971,\n", + " 0.8727, 0.7484, 0.6242, 0.5000, 0.3759, 0.1881])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 24, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 21, 1])\n", + "loss= tensor(14.9548, grad_fn=) , base rewards= tensor([2.9354, 2.4242, 1.9003, 1.5489, 1.3043, 1.1271, 0.9933, 0.8882, 0.8022,\n", + " 0.7293, 0.6656, 0.6083, 0.5557, 0.5063, 0.4594, 0.4143, 0.3705, 0.3276,\n", + " 0.2855, 0.2439, 0.2027, 0.1618, 0.1212, 0.0807, 0.0403]) return= 58222.477341860606\n", + "probs of actions: tensor([0.9600, 0.9640, 0.9630, 0.9733, 0.9555, 0.9656, 0.9670, 0.9723, 0.9723,\n", + " 0.0025, 0.9707, 0.9699, 0.9725, 0.9700, 0.9745, 0.9739, 0.9830, 0.9823,\n", + " 0.9819, 0.9789, 0.9752, 0.9754, 0.9750, 0.0866, 0.4198],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2196, 0.2052,\n", + " 0.2331, 0.1685, 0.1674, 0.1665, 0.1659, 0.1654, 0.1651, 0.1648, 0.1646,\n", + " 0.1644, 0.1643, 0.1643, 0.1642, 0.1641, 0.2161, 0.2352])\n", + "finalReturns: tensor([2.8869, 2.9830, 2.9609, 2.8778, 2.7645, 2.6373, 2.5045, 2.3704, 2.2368,\n", + " 2.1045, 1.9351, 1.8239, 1.7093, 1.5921, 1.4731, 1.3528, 1.2316, 1.1096,\n", + " 0.9872, 0.8643, 0.7412, 0.6178, 0.4943, 0.3707, 0.1949])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 29, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 29, 31, 31, 18, 0])\n", + "loss= tensor(17.0314, grad_fn=) , base rewards= tensor([2.9354, 2.4242, 1.9003, 1.5489, 1.3043, 1.1271, 0.9933, 0.8882, 0.8022,\n", + " 0.7293, 0.6656, 0.6083, 0.5557, 0.5063, 0.4594, 0.4143, 0.3705, 0.3276,\n", + " 0.2855, 0.2439, 0.2027, 0.1618, 0.1212, 0.0807, 0.0403]) return= 58489.545195653496\n", + "probs of actions: tensor([0.9008, 0.9361, 0.9336, 0.9533, 0.9256, 0.9431, 0.9432, 0.0107, 0.9520,\n", + " 0.9367, 0.9528, 0.9490, 0.9535, 0.9479, 0.9574, 0.9554, 0.9709, 0.9709,\n", + " 0.9681, 0.9649, 0.0101, 0.9590, 0.9557, 0.3959, 0.6108],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5459, 0.4345, 0.3579, 0.3044, 0.2665, 0.2393, 0.2316, 0.1997,\n", + " 0.1906, 0.1838, 0.1788, 0.1750, 0.1723, 0.1702, 0.1686, 0.1675, 0.1666,\n", + " 0.1659, 0.1655, 0.1771, 0.1597, 0.1608, 0.2253, 0.2263])\n", + "finalReturns: tensor([2.9136, 3.0097, 2.9876, 2.9045, 2.7912, 2.6640, 2.5312, 2.3971, 2.2515,\n", + " 2.1247, 1.9978, 1.8713, 1.7452, 1.6195, 1.4941, 1.3691, 1.2443, 1.1196,\n", + " 0.9952, 0.8708, 0.7465, 0.6103, 0.4913, 0.3710, 0.1860])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams,prob_break_limit_ln=-0.001)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess.ipynb new file mode 100644 index 0000000..aaa5a51 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-guess.ipynb @@ -0,0 +1,689 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[10]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 2, 2, 0, 0, 1, 1, 0, 0, 4, 1, 0, 1, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 5,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836,\n", + " 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836,\n", + " 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836, 0.4836]) return= 126861.68209030469\n", + "probs of actions: tensor([0.4869, 0.1194, 0.1126, 0.4636, 0.4292, 0.2851, 0.2785, 0.4725, 0.4912,\n", + " 0.0228, 0.2680, 0.5196, 0.2598, 0.4517, 0.2816, 0.4608, 0.2726, 0.1155,\n", + " 0.2674, 0.4915, 0.4968, 0.4548, 0.4653, 0.0149, 0.6235],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5234, 0.5403, 0.5535, 0.5558, 0.5573, 0.5623, 0.5662, 0.5393,\n", + " 0.5179, 0.5191, 0.5083, 0.4965, 0.4914, 0.4840, 0.4821, 0.4770, 0.4765,\n", + " 0.4800, 0.4791, 0.4749, 0.4718, 0.4694, 0.4652, 0.4836])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,\n", + " 0, 2, 0, 0, 0, 13, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179,\n", + " 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179,\n", + " 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179, 0.5179]) return= 133015.8938940882\n", + "probs of actions: tensor([9.0306e-01, 9.0272e-01, 9.0281e-01, 8.8203e-01, 8.7223e-01, 9.0463e-01,\n", + " 8.9608e-01, 8.9309e-01, 9.0924e-01, 8.9915e-01, 9.0652e-01, 9.2605e-01,\n", + " 9.0910e-01, 8.8179e-01, 1.2358e-02, 8.8776e-01, 9.0593e-01, 9.1858e-01,\n", + " 9.2052e-01, 1.1998e-02, 9.0751e-01, 8.8992e-01, 8.8814e-01, 8.5284e-04,\n", + " 9.8649e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5613, 0.5612, 0.5693, 0.5415, 0.5212,\n", + " 0.5062, 0.4946, 0.4938, 0.4858, 0.4799, 0.4586, 0.5179])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([7, 4, 0, 6, 2, 5, 3, 7, 0, 5, 6, 0, 8, 1, 4, 7, 3, 0, 5, 0, 2, 5, 5, 7,\n", + " 0])\n", + "loss= tensor(0.0392, grad_fn=) , base rewards= tensor([1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127,\n", + " 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127,\n", + " 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 1.0127, 0.4999]) return= 130069.93588258505\n", + "probs of actions: tensor([0.0810, 0.0630, 0.2660, 0.1608, 0.0632, 0.1131, 0.0622, 0.0865, 0.2903,\n", + " 0.1077, 0.1654, 0.2721, 0.0390, 0.0764, 0.0618, 0.0912, 0.0578, 0.2467,\n", + " 0.0915, 0.2933, 0.0545, 0.1063, 0.1046, 0.1606, 0.9102],\n", + " grad_fn=)\n", + "rewards: tensor([0.5063, 0.5479, 0.5677, 0.5367, 0.5418, 0.5264, 0.5290, 0.5185, 0.5330,\n", + " 0.5124, 0.5158, 0.5264, 0.5036, 0.5264, 0.5121, 0.5099, 0.5257, 0.5209,\n", + " 0.5034, 0.5126, 0.4994, 0.4949, 0.5036, 0.5079, 0.5250])\n", + "finalReturns: tensor([0.0202, 0.0251])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([10, 0, 8, 0, 9, 7, 1, 7, 1, 10, 10, 8, 1, 10, 0, 10, 4, 10,\n", + " 8, 0, 1, 10, 8, 10, 0])\n", + "loss= tensor(0.0403, grad_fn=) , base rewards= tensor([0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371,\n", + " 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371,\n", + " 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.8371, 0.4084]) return= 114361.22645318601\n", + "probs of actions: tensor([0.1090, 0.3419, 0.2058, 0.1599, 0.0424, 0.1755, 0.0503, 0.1455, 0.0546,\n", + " 0.1087, 0.1161, 0.2017, 0.0511, 0.1241, 0.2734, 0.1164, 0.0172, 0.1273,\n", + " 0.2052, 0.2899, 0.0530, 0.1276, 0.2115, 0.1717, 0.9847],\n", + " grad_fn=)\n", + "rewards: tensor([0.5012, 0.5606, 0.5547, 0.5918, 0.5174, 0.5051, 0.4914, 0.4525, 0.4524,\n", + " 0.4190, 0.4312, 0.4440, 0.4506, 0.4177, 0.4401, 0.4067, 0.4302, 0.4136,\n", + " 0.4306, 0.4406, 0.4170, 0.3930, 0.4149, 0.4187, 0.4410])\n", + "finalReturns: tensor([0.0226, 0.0326])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([10, 0, 10, 10, 10, 0, 10, 10, 14, 7, 2, 7, 10, 10, 10, 7, 8, 9,\n", + " 10, 10, 8, 8, 22, 8, 0])\n", + "loss= tensor(0.6946, grad_fn=) , base rewards= tensor([1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498,\n", + " 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 1.1498,\n", + " 1.1498, 1.1498, 1.1498, 1.1498, 1.1498, 0.7417, 0.3609]) return= 111252.10119493175\n", + "probs of actions: tensor([0.4206, 0.0746, 0.4479, 0.4165, 0.4458, 0.0201, 0.4270, 0.3961, 0.0282,\n", + " 0.0776, 0.0057, 0.0683, 0.4162, 0.4213, 0.4400, 0.0719, 0.1649, 0.0783,\n", + " 0.4198, 0.4127, 0.1883, 0.1744, 0.0120, 0.1392, 0.9839],\n", + " grad_fn=)\n", + "rewards: tensor([0.5012, 0.5606, 0.5511, 0.5895, 0.5431, 0.5195, 0.4504, 0.4414, 0.4251,\n", + " 0.4482, 0.4356, 0.4024, 0.3921, 0.3978, 0.4020, 0.4103, 0.4016, 0.3977,\n", + " 0.3974, 0.4017, 0.4086, 0.4046, 0.3597, 0.4453, 0.4383])\n", + "finalReturns: tensor([0.0935, 0.1419, 0.0773])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([14, 10, 10, 7, 12, 12, 9, 12, 10, 14, 10, 10, 10, 15, 14, 13, 10, 9,\n", + " 9, 14, 13, 8, 11, 14, 0])\n", + "loss= tensor(0.3052, grad_fn=) , base rewards= tensor([1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694,\n", + " 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 1.1694,\n", + " 1.1694, 1.1694, 1.1694, 1.1694, 1.1694, 0.7482, 0.3616]) return= 109383.46638145369\n", + "probs of actions: tensor([0.1905, 0.3348, 0.3677, 0.0482, 0.0455, 0.0464, 0.0315, 0.0601, 0.4014,\n", + " 0.1879, 0.3943, 0.3627, 0.3837, 0.0110, 0.1698, 0.0304, 0.3558, 0.0275,\n", + " 0.0271, 0.1604, 0.0272, 0.1174, 0.0284, 0.5951, 0.9972],\n", + " grad_fn=)\n", + "rewards: tensor([0.4916, 0.5657, 0.5215, 0.4947, 0.4515, 0.4439, 0.4444, 0.4239, 0.4276,\n", + " 0.4109, 0.4284, 0.4211, 0.4157, 0.3991, 0.4153, 0.4248, 0.4335, 0.4268,\n", + " 0.4171, 0.3985, 0.4120, 0.4275, 0.4091, 0.4020, 0.4316])\n", + "finalReturns: tensor([0.0732, 0.0853, 0.0700])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([14, 14, 14, 8, 14, 14, 14, 8, 14, 14, 20, 22, 22, 12, 10, 14, 14, 14,\n", + " 8, 14, 14, 14, 14, 14, 0])\n", + "loss= tensor(0.1518, grad_fn=) , base rewards= tensor([1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964,\n", + " 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964, 1.5964,\n", + " 1.5964, 1.5964, 1.5964, 1.5964, 1.1431, 0.7336, 0.3555]) return= 115439.50773316273\n", + "probs of actions: tensor([0.5415, 0.5352, 0.5524, 0.0234, 0.4963, 0.6158, 0.6606, 0.0232, 0.4553,\n", + " 0.5143, 0.0321, 0.0741, 0.0779, 0.0543, 0.1560, 0.6024, 0.5836, 0.5560,\n", + " 0.0353, 0.5031, 0.6141, 0.6569, 0.7855, 0.8074, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.4916, 0.5561, 0.5266, 0.5182, 0.4679, 0.4616, 0.4568, 0.4665, 0.4303,\n", + " 0.4334, 0.4154, 0.4292, 0.4533, 0.5058, 0.4883, 0.4557, 0.4525, 0.4501,\n", + " 0.4614, 0.4266, 0.4306, 0.4337, 0.4359, 0.4376, 0.4585])\n", + "finalReturns: tensor([0.1694, 0.1890, 0.1625, 0.1031])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 14, 15, 11, 22, 22, 20, 22, 22, 14, 22, 22, 22, 11, 22, 14, 22,\n", + " 22, 22, 14, 22, 14, 22, 0])\n", + "loss= tensor(0.3908, grad_fn=) , base rewards= tensor([1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398,\n", + " 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398, 1.0398,\n", + " 1.0398, 1.0398, 1.0398, 1.0398, 0.7176, 0.4465, 0.2108]) return= 84179.34123104208\n", + "probs of actions: tensor([0.5223, 0.5551, 0.1938, 0.0158, 0.0077, 0.5604, 0.5317, 0.0594, 0.4882,\n", + " 0.4831, 0.1924, 0.5504, 0.5174, 0.5218, 0.0060, 0.5466, 0.2080, 0.5674,\n", + " 0.5663, 0.5024, 0.2240, 0.8038, 0.2883, 0.4222, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5192, 0.4406, 0.4012, 0.3172, 0.3158, 0.3232, 0.3080,\n", + " 0.3089, 0.3384, 0.2865, 0.2927, 0.2974, 0.3372, 0.2717, 0.3103, 0.2660,\n", + " 0.2771, 0.2856, 0.3208, 0.2737, 0.3118, 0.2672, 0.3264])\n", + "finalReturns: tensor([0.1394, 0.1878, 0.1471, 0.1156])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 8, 22, 22, 22, 22, 14, 22, 22, 22, 22, 22, 22, 10, 22, 20, 22,\n", + " 22, 22, 22, 22, 22, 14, 0])\n", + "loss= tensor(0.6580, grad_fn=) , base rewards= tensor([1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061,\n", + " 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061, 1.3061,\n", + " 1.3061, 1.3061, 1.3061, 0.9572, 0.6678, 0.4193, 0.1995]) return= 86110.30338325803\n", + "probs of actions: tensor([9.0493e-01, 9.0524e-01, 8.9198e-04, 8.9000e-01, 8.8218e-01, 9.0776e-01,\n", + " 8.9826e-01, 2.9204e-02, 8.7858e-01, 8.6549e-01, 8.9421e-01, 9.0736e-01,\n", + " 8.8864e-01, 8.8742e-01, 1.4705e-02, 8.9633e-01, 3.2675e-02, 9.1410e-01,\n", + " 9.1044e-01, 8.8395e-01, 9.4659e-01, 9.7137e-01, 9.3503e-01, 8.5482e-02,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5324, 0.3946, 0.3730, 0.3572, 0.3455, 0.3657, 0.3063,\n", + " 0.3076, 0.3086, 0.3094, 0.3099, 0.3103, 0.3491, 0.2758, 0.2930, 0.2854,\n", + " 0.2919, 0.2968, 0.3004, 0.3032, 0.3053, 0.3357, 0.3330])\n", + "finalReturns: tensor([0.2715, 0.3199, 0.3061, 0.2493, 0.1335])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 20, 22, 20, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0347, grad_fn=) , base rewards= tensor([1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387,\n", + " 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387, 1.3387,\n", + " 1.3387, 1.3387, 1.3387, 0.9779, 0.6803, 0.4262, 0.2023]) return= 88840.75989394363\n", + "probs of actions: tensor([0.9639, 0.0113, 0.9672, 0.0130, 0.9536, 0.9648, 0.9586, 0.9663, 0.9508,\n", + " 0.9442, 0.9588, 0.9647, 0.9555, 0.9551, 0.9623, 0.9576, 0.9636, 0.9676,\n", + " 0.9663, 0.9539, 0.9874, 0.9929, 0.9740, 0.9182, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5665, 0.4831, 0.4455, 0.3973, 0.3750, 0.3587, 0.3466, 0.3377,\n", + " 0.3311, 0.3262, 0.3225, 0.3198, 0.3177, 0.3162, 0.3150, 0.3142, 0.3135,\n", + " 0.3130, 0.3127, 0.3124, 0.3122, 0.3121, 0.3119, 0.3603])\n", + "finalReturns: tensor([0.2702, 0.3186, 0.3039, 0.2460, 0.1579])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkxklEQVR4nO3df5SU1Z3n8fe3iwILVLrR1oUGg0kMHhGV0AfJsCfHyEScJGrr0YCrG3bGHU+MO2MmuyQw8QxOIick7I6uMzuZcaIbTRyFEAY5UYcQMWd2sgI2QSSojEQJdMNKJ9COE1ppmu/+Ubeap6qrq7q6urp+fV7n9Kmn7nOfp+7FpL51fzz3mrsjIiIyVA3lLoCIiFQXBQ4RESmIAoeIiBREgUNERAqiwCEiIgUZU+4CjLRzzz3Xp0+fXu5iiIhUlR07dvza3ZuHkrfmAsf06dNpb28vdzFERKqKmf1qqHnVVSUiIgVR4BARkYIocIiISEEUOEREpCAKHCIiUpC8s6rM7FHgM8ARd78049x/A1YDze7+65C2HLgD6AP+2N03hfQ5wHeBBPAscI+7u5mNAx4H5gC/ARa5+/5wzRLg3vBx97v7Y0XVts5t2NnJfRv30N3TC0DT+DifvmwyL7zexaHuHqY0Jli6cAZts1vKXFIRqWSWb3VcM/s48G/A49HAYWbTgO8AFwNz3P3XZnYJ8CQwF5gC/AT4iLv3mdl24B5gK8nA8ZC7P2dmXwAuc/fPm9li4EZ3X2Rmk4B2oBVwYEf4nGO5ytva2uq1Mh13w85OVm/aS2d3DzEz+sq4kvHt8y7g/rZZZft8ESktM9vh7q1DyZu3q8rd/wk4muXUA8CXSX6pp9wAPOXu77v7W8A+YK6ZTQbOdvcXPRmpHgfaItekWhLrgAVmZsBCYLO7Hw3BYjNw7VAqVQs27Oxk6Q920dndA1DWoAHw/a0HmL7sGT64/Bnu3bC7rGURkfIa1hiHmV0PdLr7roxTLcDByPuOkNYSjjPT065x95PAO8A5Oe6VrTx3mlm7mbV3dXUNp0oV58vrdtF7qvL2SjnlySCi4CFSvwp+ctzMxgNfBa7JdjpLmudIH+416YnuDwMPQ7KrKlueanLb373Iib7KrsYTWw/UZNdVqnswNebziYubR2QMKNv40orrZtI2u2XAZ2qcSSrdcJYc+RBwIbAr2aPEVODnZjaXZKtgWiTvVOBQSJ+aJZ3INR1mNgaYSLJrrAO4KuOanw6jvBUp+mUxMRHHDI4d78UYJDpWGCdZh+F+ieb6ohzqF2m2f8Pu471MTMQ5cbKP472ngPQv6Uz3btjNk9sOZu0K7Ozu4ftbD6S9X/qDXfzp+lf67x0V/Zx7N+xOuzbTseO9fHHNy/zp+ld47+QpUo3L1GcAg/7bKtBIueUdHAcws+nAjzJnVYVz+4HWMDg+E/h7Tg+OPw9cFAbHXwL+CNhGcnD8L939WTO7G5gVGRy/yd0/GwbHdwAfDR/1c5KD49nGW/pVw+D4hp2dLF+/m57evnIXpSiJeAOvff33CromW91TwbIl/ML/4Y7OrOdTEwRS+dZsPzjk7jwL5c32hV+poj8iGizZTTjYD4tswVEBRgpRyOD4UKbjPknyl/+5ZtYBrHD3R7Lldfc9ZrYWeBU4Cdzt7qlvgLs4PR33ufAH8AjwPTPbR7KlsTjc66iZfR14KeT7Wr6gUS1Wb9pb9UEDoKf3VMGtjmx1T30RZv7CzzyfahUMli8Xh6oKGpAeIFLxcbAweex4b1pLJbPF09ndw9J1uVsyIkM1pBZHNamGFseFy56piu6ooWhpTPCzZVdnPVdJ04klt7Exw92JxtaxMWPCuDEcO97b/9+vMdIlmGrFAP3/naMtosxWUOY4T7Y8Uj6FtDgUOAoU7ROPmXHrlckhncy0XAPH81dt6Z9mWyuiXzLVMk4jpddgMDER59jx3kHzxGPG6psvV/AoMwWOEQ4c0V/OhZgwNsaNH21hzfYDab/kzj9rLG+/e2JEyyhSzXK1XGV0jOgYR70rZiD7tyf6svbFK2iIpKu1FnitU+DIo1YGskUq3eyv/Tht7ERdV5VLgSMP/RISGR2pcZDO7h6Wr0+uTKDgUZm0rHoOG3Z2lrsIInWpp7eP/7p2l/4/WKHU4shh9aa95S6CSN3qcy/o2ZNCH3iMzpA0YPzYGMdP9PUvNfOjXYcHLBEDDJhi3hI+q/1XRwfMrmz9wKScS9gUuqRNqZbEKZRmVeUwfdkzI3IfERlZ2Z4RyZzEEm8wzjxjzIBxk2TeV+ip0AdCYwbFLFU3/0OTeOIPP1bwdZqOO0KB40PLn9VDayI1osHgjDHVtezMcA1n/5wR3Y+jXm3Y2amgIVJDTnn1LTszXE9uO5g/UxEUOLJINXtFRKpRqX/0KnBkoWc3REQGp8CRxSE9uyEiVa6UU5kVOLKY0pgodxFERIpSyscJFDiySC0VLSJSrUrZc6LAkYWWORCRalfKnhMFjkE0WLlLICIyPEZpe04UOAYxxK2sRUQqjlPanhMFjkGMj+ufRkSq14eXl27JpLzfjmb2qJkdMbNfRNJWm9nrZvaKmf2DmTVGzi03s31mttfMFkbS55jZ7nDuITOzkD7OzNaE9G1mNj1yzRIzeyP8LRmpSuezYWdn3TxhKiK16WQJe02G8rP6u8C1GWmbgUvd/TLgX4DlAGZ2CbAYmBmu+Wszi4Vrvg3cCVwU/lL3vAM45u4fBh4AvhnuNQlYAVwJzAVWmFlT4VUcug07O5m/agtfXPNyKT9GRKSq5Q0c7v5PwNGMtB+7+8nwdiswNRzfADzl7u+7+1vAPmCumU0Gznb3Fz25quLjQFvkmsfC8TpgQWiNLAQ2u/tRdz9GMlhlBrARk1pmRBs3iYjkNhId+X8APBeOW4Do6lodIa0lHGemp10TgtE7wDk57jWAmd1pZu1m1t7V1TWsSmiZERGRoSkqcJjZV4GTwBOppCzZPEf6cK9JT3R/2N1b3b21ubk5d6EHoWVGRESGZtiBIwxWfwa4zU9v6tEBTItkmwocCulTs6SnXWNmY4CJJLvGBrtXSWiZERGRoRlW4DCza4GvANe7+/HIqY3A4jBT6kKSg+Db3f0w8K6ZzQvjF58Dno5ck5oxdTOwJQSiTcA1ZtYUBsWvCWklsXThDOJ66k9EakTMSvd9NpTpuE8CLwIzzKzDzO4A/go4C9hsZi+b2d8AuPseYC3wKvCPwN3unho4uAv4DskB819yelzkEeAcM9sHfAlYFu51FPg68FL4+1pIK4m22S2ceYa2YBeR2lDKPTnyflO6+61Zkh/JkX8lsDJLejtwaZb094BbBrnXo8Cj+co4UrqP947WR4mIlNTYWBlbHPVE4xwiUitO9JWuxaHAEaHl1EVE8lPgiNBy6iIi+SlwRNz2dy+WuwgiIhVPgSO47e9e5Ge/LNmkLRGRmqHAEShoiIgMjQKHiEgNakzES3ZvBQ4RkRoTbzDuu35mye6vR6VJLqkuIlKtGhNxzJIPMU9pTLB04YySzhJV4ACWr3+l3EUQERm2l1dcM6qfp64qoEfbxIpIlSrlYoaDUeAQEalit145LX+mEabAISJSpRqA+9tmleVzRUSkQgy146kB+ItFV5SwJIPT4LiISBnFzOhzpyXPbKgNOztZvWkvh7p7RmXmVC4KHCIiZZCIx/jGTbOG/OXfNrulYhZiVeAQERlhE8bGWHljelCopBZDsRQ4RERGSK7upkpqMRRLgUNEpEiFdjtVu7yzqszsUTM7Yma/iKRNMrPNZvZGeG2KnFtuZvvMbK+ZLYykzzGz3eHcQ2bJp1bMbJyZrQnp28xseuSaJeEz3jCzJSNWaxGRAqUetMt8bWlM1FXQADD33PvSmtnHgX8DHnf3S0Pat4Cj7r7KzJYBTe7+FTO7BHgSmAtMAX4CfMTd+8xsO3APsBV4FnjI3Z8zsy8Al7n7581sMXCjuy8ys0lAO9AKOLADmOPux3KVt7W11dvb2wv6R5i+7JmC8ouIVLLzzxrLtq9+sqBrzGyHu7cOJW/eFoe7/xOQuVnFDcBj4fgxoC2S/pS7v+/ubwH7gLlmNhk4291f9GSkejzjmtS91gELQmtkIbDZ3Y+GYLEZuHYolRIRqWdvv3uCK1duLtn9h/sA4PnufhggvJ4X0luAg5F8HSGtJRxnpqdd4+4ngXeAc3LcawAzu9PM2s2svaura5hVEhGpHW+/e6Jk9x7pJ8ezPfToOdKHe016ovvD7t7q7q3Nzc1DKqiIiAzPcAPH26H7ifB6JKR3ANEVt6YCh0L61CzpadeY2RhgIsmuscHuJSIiZTTcwLERSM1yWgI8HUlfHGZKXQhcBGwP3Vnvmtm8MH7xuYxrUve6GdgSxkE2AdeYWVOYtXVNSBMRkTLK+xyHmT0JXAWca2YdwApgFbDWzO4ADgC3ALj7HjNbC7wKnATudve+cKu7gO8CCeC58AfwCPA9M9tHsqWxONzrqJl9HXgp5Puau2cO0ouISBal3KUjb+Bw91sHObVgkPwrgZVZ0tuBS7Okv0cIPFnOPQo8mq+MIiKS7rZ5F5Ts3lpWXUSkxiTiDSXdp0NLjoiI1JDU8ielpMAhIlKFmsbHWXHdTIBRX3VXgUNEpAI1jY9zyeSz2PrmMfrciZlx65XTsnZBjfY6WQocIiIlEI8ZvX3pzyynWgnVviCiAoeIyAhL7ctRKxs3Zcq7Om610eq4IiKwf9WnC8o/oqvjiohI9SnlD2IFDhERKYgCh4iIFESBQ0RECqLAISIiBVHgEBGRgihwiIhIQRQ4RESkIAocIiJSEAUOEZEa1NKYKNm9FThERGpMIh5j6cIZJbu/FjkUEakyE8bGOH6ir3/xRBjdPTmKChxm9ifAfwYc2A38PjAeWANMB/YDn3X3YyH/cuAOoA/4Y3ffFNLnAN8FEsCzwD3u7mY2DngcmAP8Bljk7vuLKbOISKUzkl+qMTP63PtX200Fgw07O1m9aS+d3T38yZqXSS1V2zQ+Piqr8A57dVwzawH+GbjE3XvMbC3JL/1LgKPuvsrMlgFN7v4VM7sEeBKYC0wBfgJ8xN37zGw7cA+wNdzjIXd/zsy+AFzm7p83s8XAje6+KFe5tDquiNSCVPCImjA2xm9P9GU9F3X7vAsK3nN8NFfHHQMkzGwMyZbGIeAG4LFw/jGgLRzfADzl7u+7+1vAPmCumU0Gznb3Fz0ZxR7PuCZ1r3XAAjOzIsssIlLxsgWG357oG/Rc1BNbD7BhZ+eIlyll2IHD3TuB/w4cAA4D77j7j4Hz3f1wyHMYOC9c0gIcjNyiI6S1hOPM9LRr3P0k8A5wTmZZzOxOM2s3s/aurq7hVklEpCY4yTGPUhl24DCzJpItggtJdj1NMLPbc12SJc1zpOe6Jj3B/WF3b3X31ubm5twFFxGpA53dPSW7dzFdVb8LvOXuXe7eC6wHfgd4O3Q/EV6PhPwdwLTI9VNJdm11hOPM9LRrQnfYROBoEWUWEZEiFRM4DgDzzGx8GHdYALwGbASWhDxLgKfD8UZgsZmNM7MLgYuA7aE7610zmxfu87mMa1L3uhnY4rW2162ISJUZ9nRcd99mZuuAnwMngZ3Aw8CZwFozu4NkcLkl5N8TZl69GvLf7e594XZ3cXo67nPhD+AR4Htmto9kS2PxcMsrIiIjo6jnONx9BbAiI/l9kq2PbPlXAiuzpLcDl2ZJf48QeEREpDJoyRERkRpUyucWFDhERGrQbfMuKNm9tVaViEgNaTD4D1cW/uR4IRQ4RESqQMyMW6+cVtKAMFQKHCIiI2x8vIHeU05v39CfHkjEY3z0golsffMYfe4VFSgyKXCIiAxTIh7jGzfNyroabXQF2+gqt5+4uJkXXu8akD4aq9qOFAUOEZEhGh9vYFw8Rvfx3rz7XrTNbqmaQFAoBQ4RkTyGs0x5LdN0XBERkl+G8YxvRENBIxu1OESk7lXbGEO5KXCISF1raUzws2VXl7sYVUVdVSJSF+INyVlQUYl4jKULZ5SpRNVLLQ4RqXmpabOQ3BnvUHdP3llRMjgFDhGpSWaAMyBAKFAUT4FDRGpSYyLOzj+7ptzFqEka4xCRmtR9vLfcRahZChwiUnUs4zWbKY2J0ShKXVJXlYhUlabxcVZcN7N/rOLeDbt5YusBossJarZUaSlwiEjFSe0p0fqBSXlnQd3fNmtI+WTkFBU4zKwR+A7J/cId+ANgL7AGmA7sBz7r7sdC/uXAHUAf8MfuvimkzwG+CySAZ4F73N3NbBzwODAH+A2wyN33F1NmEalsmQ/k5Vp5Nhoo9BDf6Cl2jON/Av/o7hcDlwOvAcuA5939IuD58B4zuwRYDMwErgX+2sxST+N8G7gTuCj8XRvS7wCOufuHgQeAbxZZXhGpcJ3dPdy7YTfzV23hwmXPMH/VFjbs7Ow/v2FnJ8vX76azuwcP+Zev352WR0pr2IHDzM4GPg48AuDuJ9y9G7gBeCxkewxoC8c3AE+5+/vu/hawD5hrZpOBs939RXd3ki2M6DWpe60DFphZKfdgF5EK8P2tBwYNDKs37aWnty8tf09vH6s37S1DSetTMS2ODwJdwP82s51m9h0zmwCc7+6HAcLreSF/C3Awcn1HSGsJx5npade4+0ngHeCczIKY2Z1m1m5m7V1dXUVUSUQqUTQwHOruyZpnsHQZecUEjjHAR4Fvu/ts4LeEbqlBZGspeI70XNekJ7g/7O6t7t7a3Nycu9QiUpVSgWGwabaafjt6igkcHUCHu28L79eRDCRvh+4nwuuRSP5pkeunAodC+tQs6WnXmNkYYCJwtIgyi8goGek+5VRgWLpwhhYrLLNhBw53/3/AQTNL/ddaALwKbASWhLQlwNPheCOw2MzGmdmFJAfBt4furHfNbF4Yv/hcxjWpe90MbAnjICJSocbHG4jHbGDXQBGigaFtdgvfuGkWLY0JjOQsrMH2/ZbSKPY5jj8CnjCzscCbwO+TDEZrzewO4ABwC4C77zGztSSDy0ngbndPjXDdxenpuM+FP0gOvH/PzPaRbGksLrK8IlIiBry16tPMX7WFzizjDQaMiRm9fflDyu3zLuCF17sGfS6jlvfzrgZFBQ53fxlozXJqwSD5VwIrs6S3k3wWJDP9PULgEZHKlupKyjVIvfrmy/ufvzgj3kBP76kBebRVa+XTk+MiUjSD/q6kKY2JrC2OKY2JAS2Fezfs5sltB+lzJ2bGrVdOU9CoAgocIlI05/QT3ksXzmD5+t1pz1oMNnh9f9ssBYoqpMAhIkVriUyFTQUQrR1VuxQ4RKQo2VoTGryubdqPQ0RySsQbaEzE+9+PjzfQND6uqbB1TC0OkRoVttwuSrzB+MZNlykwSBq1OERqUNP4eM6g0dKY4MFFVwx4AjveYGmtidW3XK6gIQOoxSFSg9yTX/yDPYgXHazWILYUSoFDpAa909PLfdfPHDAt1oDb5l3QHxw0iC3Doa4qkQrRYMmnpkdC6mG7zDWdHlh0hZ6bkKKpxSFSASaMjbHyxuTspGdeOcyx471Dui7eYGCkrf+UuSCgWhQy0tTiEBkBiXhD2kNwQ9U0Ps6Di65gz9eu7f+CX3HdzAGD1pAMLgCxsAlmavB69c2Xa6VYGVVqcYiMgNSU1dR+2Jlbm2ZKjTVk6zYazqC1AoWMJgUOkTxSLYlsM5QAGhPxtMFmSH7pd3b3EDOjz53GRBwz6D7eO+RAoGAglUqBQySPfHtZ33f9zLT3+tKXWqcxDpE8pjQmBt3POtraEKkXanGI5BCPWf8MpWxLhX/m8slc8ec/prsnOQuqaXycFdfNVDCRmqbAIZLDhLFj0oJAdMD6Exc3s2b7QXpPnZ4Ke+x4L0vX7QI0YC21S4FDJIdUSwIGjl3MX7UlLWik9PY5qzftVeCQmlX0GIeZxcxsp5n9KLyfZGabzeyN8NoUybvczPaZ2V4zWxhJn2Nmu8O5h8ySE9XNbJyZrQnp28xserHlFSmEARt2dmY9l2vQPN+Aukg1G4nB8XuA1yLvlwHPu/tFwPPhPWZ2CbAYmAlcC/y1maWecvo2cCdwUfi7NqTfARxz9w8DDwDfHIHyigyZk+yeymawAfN850SqXVGBw8ymAp8GvhNJvgF4LBw/BrRF0p9y9/fd/S1gHzDXzCYDZ7v7i+7uwOMZ16TutQ5YkGqNiIyWwVoPSxfOSC75kSE6oC5Si4ptcTwIfBk4FUk7390PA4TX80J6C3Awkq8jpLWE48z0tGvc/STwDnBOZiHM7E4zazez9q6uriKrJJJusNZD2+wWVt9yedrueE3j46y+WXtYSG0b9uC4mX0GOOLuO8zsqqFckiXNc6TnuiY9wf1h4GGA1tbWYjc9E+mXuZ/2hp2dA5YCeXnFNWUsocjoK2ZW1XzgejP7FHAGcLaZfR9428wmu/vh0A11JOTvAKZFrp8KHArpU7OkR6/pMLMxwETgaBFlFskruuXqGfFko3zDzk7u27gnbZZVZ3cPy9fvBjT1VurLsLuq3H25u0919+kkB723uPvtwEZgSci2BHg6HG8EFoeZUheSHATfHrqz3jWzeWH84nMZ16TudXP4DLUopKSi/wM7dryXpT/YxdJ1u9KCRkpPb9+gg+citaoUz3GsAtaa2R3AAeAWAHffY2ZrgVeBk8Dd7p56DPcu4LtAAngu/AE8AnzPzPaRbGksLkF5RXLK9qxGlKbeSr0ZkcDh7j8FfhqOfwMsGCTfSmBllvR24NIs6e8RAo9IpdLUW6k3WuRQpAiZg+ci9UBLjogMkxY0lHqlwCEyRDEzTrkPaSMmkVqmwCEyBPGY6cE+kUBjHCIRBtw+7wI9DS6Sg1ocIhEO3N82i/vbZpW7KCIVSy0OqRuJeCxvnpjW0BTJS4FD6kIi3sB7kW1fB9OnhQlE8lJXldSFnt5T+TMBLXqYTyQvtThEIj5xcXO5iyBS8RQ4RCJ+uKNz0K1iRSRJgUMkQqvdiuSnwCGSQavdiuSmwXGRDNHVbrPt+Bd9EDDfeZFapMAhEhGPWf9qtxt2drJ8/W56wjTezB3/8p0XqVXqqhKJmDB2TP+X/upNe/uDQkp0DCTfeZFapcAhEtHd09s/q2qwsY5Uer7zIrVKXVUiGVLdTVMaE3RmCQKpMZB850VqlVocIhlS3U1LF84g3pC+dlW84fQYyNKFMwasf6UdAaUeDDtwmNk0M3vBzF4zsz1mdk9In2Rmm83sjfDaFLlmuZntM7O9ZrYwkj7HzHaHcw+ZJVeaM7NxZrYmpG8zs+lF1FVkyPpbEplrHkbet81u4Rs3zaKlMYGRXK7kGzfN0sC41DzzYS7qZmaTgcnu/nMzOwvYAbQB/wk46u6rzGwZ0OTuXzGzS4AngbnAFOAnwEfcvc/MtgP3AFuBZ4GH3P05M/sCcJm7f97MFgM3uvuiXOVqbW319vb2guoyfdkzBeWX2hcz499NPCNrV1RLY4KfLbu6DKUSKR0z2+HurUPJO+wWh7sfdvefh+N3gdeAFuAG4LGQ7TGSwYSQ/pS7v+/ubwH7gLkhAJ3t7i96Moo9nnFN6l7rgAWp1ohIKfW5a/BbZBAjMsYRupBmA9uA8939MCSDC3BeyNYCHIxc1hHSWsJxZnraNe5+EngHOCfL599pZu1m1t7V1TUSVZI619KYGHSQW4PfUu+KDhxmdibwQ+CL7v6vubJmSfMc6bmuSU9wf9jdW929tblZq5tKcVID3Br8FsmuqOm4ZhYnGTSecPf1IfltM5vs7odDN9SRkN4BTItcPhU4FNKnZkmPXtNhZmOAicDRYsoskkvT+DgrrpuZNsCtJUVE0g07cISxhkeA19z9LyKnNgJLgFXh9elI+t+b2V+QHBy/CNgeBsffNbN5JLu6Pgf8Zca9XgRuBrb4cEfzRYbgvYwNn9pmtyhQiGQopqtqPvAfgavN7OXw9ymSAeOTZvYG8MnwHnffA6wFXgX+Ebjb3VPrNdwFfIfkgPkvgedC+iPAOWa2D/gSsKyI8orkpSVDRPIbdovD3f+Z7GMQAAsGuWYlsDJLejtwaZb094BbhltGkeHQrCmR3PTkuNSVpvFxYnlmdGvWlEhuChxSN+IxY8V1M7n1ymmD5jHQrCmRPLTIodSFmBmrb768f7D7ra5/42e/TJ+gZ8Bt8y7QYLhIHmpxSFnFG4x4LHvXUSIe48FFV9AyhK6jlsYE+1d9mgcXXZH12Yv/8dnL0wLCE3/4sf57p9aZemDRFdzfNquo+ojUA7U4qljT+Djdx3uZmIhjBt3He5nSmOATFzfzwutdWddZGilm8DsfnMTWN4/RN9z1zoBFc6fR+oFJrN60l87uHmJm9LnTkvHMRHSnvUzRh/KimzDle/ZCU21FhkeBo8yM9EfhM98P5vZ5F+T9dTx/1ZaswSNmxin3AV+q0f2zJybi/PbESXr7BpYmEY+lrQK7YWcnX1zzctYytIRA9v2tBwacc+CF17u4vy33irKZwSAzUGYGBgUEkdJS4CgTAx5YdAWQ/uv4Exc388MdnWm/ruMNxplnjBn0i3Iwg00rPeXOW6s+PSA98ws3FUhytQRS17X/6ihPbD2QFvRSLYG22S0DzuUrY76yiUj5KHCUQeYgbOYXYqrrpthlLordoa6QL+v722blLLd2yxOpHQoco6TB4JST9Rd7ppH6db104YwBYwOlXKQvV7lHuywiUjoKHCUWMxswo2e0FDJQXE9lEZHiKHCUUOYgcjlU0thAJZVFRIZPgWOETRgb4/iJPv2iFpGapcAxQoYydiEiUgsUOIqQbdMfEZFap8AxTC2NCX627OpyF0NEZNRpraph0jRSEalXChzD0JiIq3tKROqWAkeBDLjv+pnlLoaISNkocBRI+zWISL2risBhZtea2V4z22dmy8pRhgljk3tDaL8GEal3FT+rysxiwP8CPgl0AC+Z2UZ3f3W0ynDReRPY/KWrRuvjREQqWjW0OOYC+9z9TXc/ATwF3DCaBVDQEBE5rRoCRwtwMPK+I6T1M7M7zazdzNq7uroK/oDGRHzQc/M/NKng+4mI1LJqCBzZNqRO2xPI3R9291Z3b21ubi78A7JveQ3A/t+UbvtVEZFqVA2BowOYFnk/FTg0kh/Qfbx30HND3aFORKReVEPgeAm4yMwuNLOxwGJg40h+QK5d6LRDnYhIuooPHO5+EvgvwCbgNWCtu+8Zyc9YunAG8YaB/VXxmGlpERGRDBU/HRfA3Z8Fni3V/VMP9N23cQ/dPcluK618KyKSXVUEjtGg3elERIam4ruqRESksihwiIhIQRQ4RESkIAocIiJSEAUOEREpiLl7/lxVxMy6gF8VcYtzgV+PUHGqRb3Vud7qC6pzvSimzh9w9yGt2VRzgaNYZtbu7q3lLsdoqrc611t9QXWuF6NVZ3VViYhIQRQ4RESkIAocAz1c7gKUQb3Vud7qC6pzvRiVOmuMQ0RECqIWh4iIFESBQ0RECqLAEZjZtWa218z2mdmycpdnKMzsUTM7Yma/iKRNMrPNZvZGeG2KnFse6rfXzBZG0ueY2e5w7iGz5Ga6ZjbOzNaE9G1mNj1yzZLwGW+Y2ZJRqu80M3vBzF4zsz1mdk8d1PkMM9tuZrtCnf+81uscPjdmZjvN7Ef1UN/w2ftDeV82s/aQVpn1dve6/wNiwC+BDwJjgV3AJeUu1xDK/XHgo8AvImnfApaF42XAN8PxJaFe44ALQ31j4dx24GMk93d/Dvi9kP4F4G/C8WJgTTieBLwZXpvCcdMo1Hcy8NFwfBbwL6FetVxnA84Mx3FgGzCvluscPvtLwN8DP6r1/11H6rwfODcjrSLrPSr/IJX+F/6RN0XeLweWl7tcQyz7dNIDx15gcjieDOzNVieSOyp+LOR5PZJ+K/C30TzheAzJJ1Itmiec+1vg1jLU/Wngk/VSZ2A88HPgylquMzAVeB64mtOBo2brG/m8/QwMHBVZb3VVJbUAByPvO0JaNTrf3Q8DhNfzQvpgdWwJx5npadd4cgvfd4Bzctxr1IRm9mySv8Brus6h2+Zl4Aiw2d1rvc4PAl8GTkXSarm+KQ782Mx2mNmdIa0i660dAJMGbjie/I9YSwarY666D+eakjOzM4EfAl90938NXbhZs2ZJq7o6u3sfcIWZNQL/YGaX5she1XU2s88AR9x9h5ldNZRLsqRVTX0zzHf3Q2Z2HrDZzF7Pkbes9VaLI6kDmBZ5PxU4VKayFOttM5sMEF6PhPTB6tgRjjPT064xszHAROBojnuVnJnFSQaNJ9x9fUiu6TqnuHs38FPgWmq3zvOB681sP/AUcLWZfZ/arW8/dz8UXo8A/wDMpVLrPVr9d5X8R7Ll9SbJQabU4PjMcpdriGWfTvoYx2rSB9O+FY5nkj6Y9ianB9NeIjngmhpM+1RIv5v0wbS14XgS8BbJgbSmcDxpFOpqwOPAgxnptVznZqAxHCeA/wN8ppbrHKn7VZwe46jp+gITgLMix/+X5A+Eiqz3qPwPoBr+gE+RnKXzS+Cr5S7PEMv8JHAY6CX5q+EOkn2WzwNvhNdJkfxfDfXbS5hpEdJbgV+Ec3/F6RUFzgB+AOwjOVPjg5Fr/iCk7wN+f5Tq++9JNqFfAV4Of5+q8TpfBuwMdf4F8GchvWbrHPnsqzgdOGq6viRndO4Kf3sI30GVWm8tOSIiIgXRGIeIiBREgUNERAqiwCEiIgVR4BARkYIocIiISEEUOEREpCAKHCIiUpD/D0rZd/4CvQmjAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0329, grad_fn=) , base rewards= tensor([1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268,\n", + " 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268,\n", + " 1.5268, 1.5268, 1.1656, 0.8677, 0.6134, 0.3894, 0.1870]) return= 89197.96159612676\n", + "probs of actions: tensor([0.9835, 0.9829, 0.9841, 0.9773, 0.9781, 0.9830, 0.9788, 0.9833, 0.9772,\n", + " 0.9725, 0.9811, 0.9828, 0.9790, 0.9796, 0.9823, 0.9794, 0.9822, 0.9850,\n", + " 0.9841, 0.9847, 0.9950, 0.9972, 0.9872, 0.9365, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.3952, 0.4436, 0.4289, 0.3710, 0.2828, 0.1733])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0337, grad_fn=) , base rewards= tensor([1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268,\n", + " 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268, 1.5268,\n", + " 1.5268, 1.5268, 1.1656, 0.8677, 0.6134, 0.3894, 0.1870]) return= 89197.96159612676\n", + "probs of actions: tensor([0.9879, 0.9875, 0.9882, 0.9825, 0.9840, 0.9869, 0.9828, 0.9870, 0.9837,\n", + " 0.9790, 0.9861, 0.9868, 0.9845, 0.9857, 0.9873, 0.9847, 0.9863, 0.9888,\n", + " 0.9883, 0.9905, 0.9968, 0.9987, 0.9884, 0.9200, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.3952, 0.4436, 0.4289, 0.3710, 0.2828, 0.1733])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 14, 0])\n", + "loss= tensor(0.7335, grad_fn=) , base rewards= tensor([1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039,\n", + " 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039,\n", + " 1.7039, 1.3422, 1.0441, 0.7896, 0.5655, 0.3630, 0.1759]) return= 89249.86593949163\n", + "probs of actions: tensor([0.9900, 0.9899, 0.9904, 0.9850, 0.9870, 0.9891, 0.9847, 0.9890, 0.9871,\n", + " 0.9821, 0.9887, 0.9887, 0.9874, 0.9887, 0.9901, 0.9873, 0.9886, 0.9907,\n", + " 0.9937, 0.9932, 0.9981, 0.9992, 0.9879, 0.1015, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3408, 0.3367])\n", + "finalReturns: tensor([0.5365, 0.5849, 0.5702, 0.5123, 0.4241, 0.3145, 0.1608])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0298, grad_fn=) , base rewards= tensor([1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039,\n", + " 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039, 1.7039,\n", + " 1.7039, 1.3422, 1.0441, 0.7896, 0.5655, 0.3630, 0.1759]) return= 89197.96159612676\n", + "probs of actions: tensor([0.9952, 0.9949, 0.9951, 0.9925, 0.9933, 0.9944, 0.9916, 0.9942, 0.9933,\n", + " 0.9904, 0.9942, 0.9943, 0.9935, 0.9944, 0.9948, 0.9935, 0.9942, 0.9954,\n", + " 0.9974, 0.9977, 0.9997, 0.9998, 0.9928, 0.9260, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.5313, 0.5797, 0.5651, 0.5071, 0.4189, 0.3093, 0.1844])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0106, grad_fn=) , base rewards= tensor([1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733,\n", + " 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733,\n", + " 1.5111, 1.2126, 0.9578, 0.7336, 0.5309, 0.3437, 0.1678]) return= 89197.96159612676\n", + "probs of actions: tensor([0.9987, 0.9985, 0.9986, 0.9977, 0.9980, 0.9984, 0.9974, 0.9982, 0.9980,\n", + " 0.9970, 0.9983, 0.9983, 0.9980, 0.9983, 0.9984, 0.9981, 0.9983, 0.9994,\n", + " 0.9995, 0.9995, 1.0000, 1.0000, 0.9983, 0.9738, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.6757, 0.7241, 0.7094, 0.6513, 0.5631, 0.4535, 0.3285, 0.1925])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 14, 0])\n", + "loss= tensor(0.9337, grad_fn=) , base rewards= tensor([1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733,\n", + " 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733, 1.8733,\n", + " 1.5111, 1.2126, 0.9578, 0.7336, 0.5309, 0.3437, 0.1678]) return= 89249.86593949163\n", + "probs of actions: tensor([0.9984, 0.9981, 0.9982, 0.9972, 0.9976, 0.9978, 0.9966, 0.9975, 0.9975,\n", + " 0.9959, 0.9978, 0.9977, 0.9974, 0.9981, 0.9981, 0.9976, 0.9979, 1.0000,\n", + " 0.9996, 0.9997, 1.0000, 1.0000, 0.9975, 0.0613, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3408, 0.3367])\n", + "finalReturns: tensor([0.6809, 0.7293, 0.7146, 0.6565, 0.5683, 0.4587, 0.3337, 0.1689])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373,\n", + " 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 1.6744,\n", + " 1.3755, 1.1203, 0.8958, 0.6930, 0.5057, 0.3297, 0.1618]) return= 89197.96159612676\n", + "probs of actions: tensor([0.9999, 0.9999, 0.9999, 0.9998, 0.9998, 0.9998, 0.9997, 0.9998, 0.9998,\n", + " 0.9997, 0.9998, 0.9998, 0.9998, 0.9999, 0.9998, 0.9998, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9814, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.8261, 0.8745, 0.8597, 0.8016, 0.7133, 0.6037, 0.4787, 0.3426, 0.1985])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0012, grad_fn=) , base rewards= tensor([2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373,\n", + " 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 2.0373, 1.6744,\n", + " 1.3755, 1.1203, 0.8958, 0.6930, 0.5057, 0.3297, 0.1618]) return= 89197.96159612676\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9966, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.8261, 0.8745, 0.8597, 0.8016, 0.7133, 0.6037, 0.4787, 0.3426, 0.1985])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978,\n", + " 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 1.8339, 1.5343,\n", + " 1.2787, 1.0539, 0.8508, 0.6634, 0.4872, 0.3193, 0.1574]) return= 89197.96159612676\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.9811, 1.0295, 1.0146, 0.9565, 0.8681, 0.7583, 0.6333, 0.4972, 0.3530,\n", + " 0.2029])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(8.6955e-07, grad_fn=) , base rewards= tensor([2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978,\n", + " 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 2.1978, 1.8339, 1.5343,\n", + " 1.2787, 1.0539, 0.8508, 0.6634, 0.4872, 0.3193, 0.1574]) return= 89197.96159612676\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.4904, 0.4424, 0.4078, 0.3827, 0.3643, 0.3508, 0.3408,\n", + " 0.3334, 0.3279, 0.3238, 0.3207, 0.3184, 0.3167, 0.3154, 0.3145, 0.3138,\n", + " 0.3132, 0.3128, 0.3125, 0.3123, 0.3121, 0.3120, 0.3603])\n", + "finalReturns: tensor([0.9811, 1.0295, 1.0146, 0.9565, 0.8681, 0.7583, 0.6333, 0.4972, 0.3530,\n", + " 0.2029])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 4\u001b[0m ep\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100_000\u001b[39m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(game\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m----> 7\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mep\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m50_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mclc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperParams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\Find the problem\\Actor critic\\learningBase.py:461\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage\u001b[1;34m(self, stage, episodes, print_step, prob_break_limit_ln, clc, options, lr, just_stage)\u001b[0m\n\u001b[0;32m 458\u001b[0m probs_lst_pre \u001b[38;5;241m=\u001b[39m probs_lst\n\u001b[0;32m 460\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolicy\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m--> 461\u001b[0m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 462\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim\u001b[38;5;241m.\u001b[39mstep()\n\u001b[0;32m 464\u001b[0m \u001b[38;5;66;03m# if episode != 0:\u001b[39;00m\n\u001b[0;32m 465\u001b[0m \u001b[38;5;66;03m# self.meanStageValue = (\u001b[39;00m\n\u001b[0;32m 466\u001b[0m \u001b[38;5;66;03m# (self.meanStageValue*episode)+rewards)/(episode+1)\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 469\u001b[0m \u001b[38;5;66;03m# self.returns[iteration][episode] = returns\u001b[39;00m\n\u001b[0;32m 470\u001b[0m \u001b[38;5;66;03m# self.loss[iteration][episode] = loss\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m 477\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m 478\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[0;32m 479\u001b[0m Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[0;32m 480\u001b[0m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 485\u001b[0m inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[0;32m 486\u001b[0m )\n\u001b[1;32m--> 487\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 488\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[0;32m 489\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\autograd\\__init__.py:197\u001b[0m, in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m 192\u001b[0m retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[0;32m 194\u001b[0m \u001b[38;5;66;03m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[0;32m 195\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[0;32m 196\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[1;32m--> 197\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[1e-05, 1, 0]-stage 15-1682152985'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 0.000005-stop when converge.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 0.000005-stop when converge.ipynb new file mode 100644 index 0000000..684f3d9 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 0.000005-stop when converge.ipynb @@ -0,0 +1,1415 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.000005, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 4, 1, 2, 0, 0, 1, 0, 2, 3, 5, 2, 0, 1, 0, 3, 10, 9, 10,\n", + " 6, 3, 39, 3, 23, 2, 4])\n", + "loss= tensor(-0.0047, grad_fn=) , base rewards= tensor([0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391,\n", + " 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391,\n", + " 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391, 0.6391]) return= 146377.52125792814\n", + "probs of actions: tensor([0.0672, 0.1990, 0.1702, 0.1675, 0.2011, 0.2169, 0.1845, 0.1780, 0.1056,\n", + " 0.0536, 0.1797, 0.1758, 0.2060, 0.1973, 0.1021, 0.0102, 0.0167, 0.0108,\n", + " 0.0347, 0.1122, 0.0018, 0.1237, 0.0020, 0.1708, 0.0537],\n", + " grad_fn=)\n", + "rewards: tensor([0.5096, 0.5512, 0.5602, 0.5691, 0.5658, 0.5640, 0.5671, 0.5644, 0.5703,\n", + " 0.5757, 0.5889, 0.5835, 0.5728, 0.5715, 0.5661, 0.5661, 0.5995, 0.6098,\n", + " 0.6262, 0.6182, 0.4499, 0.7395, 0.6076, 0.7033, 0.6375])\n", + "finalReturns: tensor([-0.0016])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 2, 0, 0, 0, 22, 2, 2, 1, 0, 3, 1, 0, 0, 2, 1, 0, 2, 1,\n", + " 0, 4, 2, 0, 2, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683,\n", + " 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683,\n", + " 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683, 0.5683]) return= 142568.99644204692\n", + "probs of actions: tensor([0.1430, 0.3629, 0.3738, 0.3464, 0.0014, 0.1298, 0.1388, 0.3398, 0.3860,\n", + " 0.0376, 0.3325, 0.3618, 0.3532, 0.1279, 0.3315, 0.3839, 0.1288, 0.3255,\n", + " 0.3856, 0.0214, 0.1385, 0.3942, 0.1283, 0.3928, 0.4896],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5439, 0.5532, 0.5578, 0.5118, 0.6464, 0.6113, 0.5944, 0.5822,\n", + " 0.5714, 0.5787, 0.5744, 0.5684, 0.5651, 0.5714, 0.5708, 0.5662, 0.5720,\n", + " 0.5711, 0.5652, 0.5794, 0.5787, 0.5702, 0.5741, 0.5683])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD4CAYAAAD7CAEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAApyElEQVR4nO3df5BV5Z3n8feXpiGNu9qNkl1tJI2JYoUYIXSUDJuUmgk4kx/2JBpxJyW7644bNzOTmAxTsEkt/soEwzimsqlxxhlZNSYEo25LQhzCDCapskRtBhBJZMWo2A0TSZp2XOlA0/3dP+5z2nsv59xffX/351V1i9vP+dHn0HC//Tzf5/kec3dEREQKNaXWFyAiIo1FgUNERIqiwCEiIkVR4BARkaIocIiISFGm1voCyu2MM87wrq6uWl+GiEhD2bFjx6/dfVYh+zZd4Ojq6qKvr6/WlyEi0lDM7JVC99VQlYiIFEWBQ0REiqLAISIiRVHgEBGRoihwiIhIUZpuVlU59e4cYN2WfRwcGuas9jZWLptHz8LOWl+WiEhNKXDE6N05wOpHnmV4ZGy8bWBomNWP7AFQ8BCRSU1DVVl6dw6w8vu7M4JGZHhklHVb9tXgqkRE6ocCR5Z1W/YxMpb8jJKDQ8NVvBoRkfqjoaogymcM5AkMZ7W3VemKRETqkwIHUU5jD8Mjo3n3vfT8gkq5iIg0LQ1VkRqeKiRoAGx46lV6dw5U+IpEROqXAgfF5S1G3Vn9yB4FDxGZtDRURSpvkS+3kW54ZJQvPbibL2zcRYsZo+50ap2HiEwS6nEAK5fNo621pahjRt0z/ozWeagnIiLNToGD1IK+Ty2aeE+hmHUevTsHWLJ2G3NXbWbJ2m0KOCLSMDRUFWx+9lBZzlNIviR7FpdWpYtII1GPIzhydKQs5ylknUfcLC6tSheRRqEeB/CRv/pJ2c7VdXoqcOQqkJjUK9GqdBFpBOpxAC+89mbZzrX9l0fGh6IGhoZxTk6cJ/VKtCpdRBqBAkeZjbrnHYqKm8XV1trCymXzqnadIiKl0lBVBSStCYmGoqIhKz3rQ0QaUd7AYWbrgY8Br7n7e0LbRiD69bgdGHL3BWHbauA6YBT4U3ffEtoXAfcCbcCPgM+7u5vZdOB+YBHwG+Bqd385HLMC+Er4Pre5+30Tu93qMCCuvm76UFTPwk4FChFpSIX0OO4FvkXqwx0Ad786em9mdwCvh/fvBpYD84GzgH80s/PcfRS4C7ge2E4qcFwOPEYqyBxx93eZ2XLgduBqM5sJrAG6SX0O7zCzTe5+ZEJ3XAVxQaO1xTKGovR0QRFpVHkDh7v/zMy64raZmQGfBi4LTVcA33P3Y8BLZrYfuMjMXgZOdfcnw3H3Az2kAscVwE3h+IeAb4XzLgO2uvtgOGYrqWCzoei7rAMjo873+w6Ml25P75VoHYeINJKJJsc/CPzK3V8IX3cCr6Zt7w9tneF9dnvGMe5+glTv5fQc5zqJmV1vZn1m1nf48OEJ3VAlPfHi4Hj+I7tXonUcItIoJho4riGzB2Ax+3iO9lKPyWx0v9vdu929e9asxn1ehtZxiEgjKDlwmNlU4JPAxrTmfuDstK9nAwdD++yY9oxjwjlPAwZznKtpaR2HiDSCifQ4fhd43t3Th6A2AcvNbLqZzQXOBZ5290PAG2a2OOQvrgUeTTtmRXh/JbDN3R3YAiw1sw4z6wCWhrampHUcItIoCpmOuwG4BDjDzPqBNe5+D6nZUxmJanffa2YPAj8HTgCfCzOqAG7grem4j4UXwD3At0MifTCcF3cfNLNbgWfCfrdEifJmESXI9SwPEWkk5h6bNmhY3d3d3tfXV9QxXas2V+hqkilYiEg9MbMd7t5dyL5aOV4DBjyx6rK8+4mI1CPVqqoRPbhJRBqVAkcNOPCl7+9W8BCRhqTAUSOjY84XH9yl4CEiDUeBo4bGHL6wcRddqzaz8JYfK4iISENQ4KgTR46OsPIhDV+JSP1T4KgjI6OuelUiUvc0HbfODAwNs2TtNi49fxaPP3/4pLLrKscuIrWmwFGHBoaGeWD7gYyvVz+yh75XBnl4x8D4Y2lVjl1EakFDVQ1ieGSUDU+9mvNZ5iIi1aDA0UBGE8rDqBy7iFSTAkcDabG4R5SoHLuIVJcCR4Noa23hmovPpq215aR2lWMXkWpS4GgAUww+taiT23ou4GufvIDO9jaMVIXdr33yAiXGRaSqNKuqAYw5PLxjgO53zKRnYedJgUJTdEWkmtTjaBBJs6d6dw6w+pE9DAwN47w1RVcr0EWkUhQ4GsjA0DBzV21mydpt44Fh3ZZ9mqIrIlWloaoGk96rgOSpuJqiKyKVoh5Hg4p6FUlTcTVFV0QqRYGjgR0cGmblsnmaoisiVZU3cJjZejN7zcyey2r/EzPbZ2Z7zezroa3LzIbNbFd4/U3a/ovMbI+Z7Tezb5qlVrOZ2XQz2xjanzKzrrRjVpjZC+G1omx33STOam+jZ2GnpuiKSFUVkuO4F/gWcH/UYGaXAlcA73X3Y2b29rT9X3T3BTHnuQu4HtgO/Ai4HHgMuA444u7vMrPlwO3A1WY2E1gDdJMa2t9hZpvc/Uhxt9i8Lj1/FkDGFN1oau6NG3dpaq6IVETeHoe7/wwYzGq+AVjr7sfCPq/lOoeZnQmc6u5PuruTCkI9YfMVwH3h/UPAh0NvZBmw1d0HQ7DYSirYSPDIjv6MrzU1V0SqodQcx3nAB8PQ0k/N7P1p2+aa2c7Q/sHQ1gmkf8r1h7Zo26sA7n4CeB04Pb095pgMZna9mfWZWd/hw4dLvKXGc3RkLONrTc0VkWoodTruVKADWAy8H3jQzM4BDgFz3P03ZrYI6DWz+UBcdb6o1GvStlzHZDa63w3cDdDd3R1fQnYS0NRcEamGUgNHP/BIGHZ62szGgDPc/TAQDV/tMLMXSfVO+oHZacfPBg6mnetsoN/MpgKnkRoa6wcuyTrmJyVeb9PqWrUZgNYpCVEVTc0VkfIqdaiqF7gMwMzOA6YBvzazWWbWEtrPAc4Ffunuh4A3zGxxyF9cCzwazrUJiGZMXQlsCwFpC7DUzDrMrANYGtokRtaoVYajx08ozyEiZZO3x2FmG0j95n+GmfWTmum0HlgfpugeB1a4u5vZh4BbzOwEMAp81t2jxPoNpGZotZGaTfVYaL8H+LaZ7SfV01gO4O6DZnYr8EzY75a0c0kRjhwd0SNmRaRszBOeKteouru7va+vr6hjouGeZtfZ3sYTqy6r9WWISB0ysx3u3l3Ivlo5PokoSS4i5aDAMYkoSS4i5aDAMUmofpWIlIsCxyRwyrQW1a8SkbJR4JgE3jw+St8rmpAmIuWhwDFJPLD9gNZyiEhZ6AmAk8i6Lftih6uiiroHh4ZVUVdE8lLgmEQGhoZPChKXnj+Lh3cMjBdHTH8srYKHiMTRUNUkc+PGXRll17+z/YAq6opIURQ4JpnsOgFJdQMGtFhQRBIocEisFourai8iosAhCUabrIaZiJSPAofE6lR5EhFJoMAhJzFQeRIRSaTAISdxNBVXRJIpcMhJNEwlIrkocEgGVdEVkXwUOGScGaqiKyJ5qeSIjHOHm3+wl75XBnn8+cM1q12l2lki9U2BQzIcOTrCA9sPjH+dq3ZVJT7ge3cOsPqRPaqdJVLH8g5Vmdl6M3vNzJ7Lav8TM9tnZnvN7Otp7avNbH/YtiytfZGZ7QnbvmmWWppsZtPNbGNof8rMutKOWWFmL4TXirLcsRQtrnZV9AGfXvdq9SN7Jly6fd2WfaqdJVLnCslx3Atcnt5gZpcCVwDvdff5wF+G9ncDy4H54Zi/NrOWcNhdwPXAueEVnfM64Ii7vwu4E7g9nGsmsAa4GLgIWGNmHSXdpUxYVFk3UqkP+IMJNbKS2kWk+vIGDnf/GZD9+LgbgLXufizs81povwL4nrsfc/eXgP3ARWZ2JnCquz/p7g7cD/SkHXNfeP8Q8OHQG1kGbHX3QXc/AmwlK4BJdaX3KJKKIE70A/6shKnASe0iUn2lzqo6D/hgGFr6qZm9P7R3Aq+m7dcf2jrD++z2jGPc/QTwOnB6jnNJjUQ9it6dAySVQJzoB/zKZfNoa23JaNMUYZH6UmpyfCrQASwG3g88aGbnQOzniedop8RjMpjZ9aSGwZgzZ07OC5eJOTg0zLot+2J/EAZcev4slqzdVnLCPNpXs6pE6lepgaMfeCQMOz1tZmPAGaH97LT9ZgMHQ/vsmHbSjuk3s6nAaaSGxvqBS7KO+Uncxbj73cDdAN3d3SrrWkFntbclDkc58J3tB8aDSqkzonoWdipQiNSxUoeqeoHLAMzsPGAa8GtgE7A8zJSaSyoJ/rS7HwLeMLPFIX9xLfBoONcmIJoxdSWwLQSkLcBSM+sISfGloU1qJBoyyjUclR21NSNKpPnk7XGY2QZSv/mfYWb9pGY6rQfWhym6x4EV4cN+r5k9CPwcOAF8zt2jqTc3kJqh1QY8Fl4A9wDfNrP9pHoaywHcfdDMbgWeCfvd4u7ZSXqpore1TuHGjbs4ra2V1hZjZPStMGEkP01QM6JEmkvewOHu1yRs+kzC/l8FvhrT3ge8J6b9t8BVCedaTypISR04cnQEgKHh1J/TWozjIXjkGh/UjCiR5qJaVVKy46P500l6todI81HgkIox4A8Xz1GiW6TJqFYV0GJQwC/PUoQWM+749IUKGiJNSIEDBY1KGPPUX+qCm388nhPpmNHKmo/Pp2dhpyrgijQwBQ6piNPaWln5/d2MjL0VlY8cHWHlQ7vpe2WQh3cMqAKuSINSjkMq4l9/O5IRNCIjo84D2w+oAq5IA1PgAJa8c2atL6HpxMSMvLTeQ6QxKHAA3/mjDyh41IGz2tvo3TnAkrXbmLtqM0vWbpvw8z1EpPzMvbkyw93d3d7X11fSsV2rNpf5aqRQSSvPo/ZOJdBFKsrMdrh7dyH7qseRxpJqhUvFJf36kl0wUT0QkdrTrKo0Tdb5agi5alxlixLouXodmuYrUnkKHIF+k60+s+KDda4EevQcdE3zFaksDVUFmgpafQZMKXJ4MFfBxEo9B11EMqnHEWgqaPWVMmU3V8HEpJ+hfrYi5aXAEZzV3saAPmDqWntba84hp6SfYdRLUf5DpDw0VBWo9Hd9a2tt4aZPzM+5z8pl82hrbTnpuJXL5o3nPwaGhnE0S0tkIhQ4gp6FnXTMaK31ZUiMjhmtfO2TF+TtHfQs7ORrn7yAzvY2jNTaj+g45T9EykdDVWnWfHx+xqwcqQ8zpk0teEipZ2Fn7L7Kf4iUjwJHmp6FnfS9Msh3th8oeG2BVN7A0DBL1m4rODcRl8vIl/8QkcIpcGR5/PnDChp1KPrQz7U2o3fnADdt2jv+/I/0/T+1qDOjlDu8lf8QkeIox5FFQxf1b3hklJs27c1oi5Lf6UEjff/Hnz+cmP8QkeLk7XGY2XrgY8Br7v6e0HYT8EfA4bDb/3D3H5lZF/ALIMo4bnf3z4ZjFgH3Am3Aj4DPu7ub2XTgfmAR8Bvgand/ORyzAvhKONdt7n7fRG62EPmm5XZq2m5dGBoeoWvVZgyYMa2FN4/nzksNDA2zbss+TcEVKYNCehz3ApfHtN/p7gvC60dp7S+mtX82rf0u4Hrg3PCKznkdcMTd3wXcCdwOYGYzgTXAxcBFwBoz6yj81kpz6fmzErd1trfxxKrL6NS4eN1wyBs0IgNDw3xh4y7m/89/0DRckQnIGzjc/WfA4ES+iZmdCZzq7k96qo77/UBP2HwFEPUkHgI+bGYGLAO2uvugux8BthIfwMqmd+cAD++I/0BJHw9fuWwercXWypC68ebxUb744C4W3vJjPfdDpAQTyXH8sZk9a2brs3oCc81sp5n91Mw+GNo6gf60ffpDW7TtVQB3PwG8Dpye3h5zTAYzu97M+sys7/Dhw3G7FCRurj9Ai1nGeHjPwk7WXXVhyd9Ham/MU89A12JAkeKVGjjuAt4JLAAOAXeE9kPAHHdfCHwR+K6ZnUqqnl22aPJS0rZcx2Q2ut/t7t3u3j1rVvJQUz5JifEx95PGxXsWdtLepgWDzUKLAUUKV9J0XHf/VfTezP4O+GFoPwYcC+93mNmLwHmkeguz004xGzgY3vcDZwP9ZjYVOI3U0Fg/cEnWMT8p5XoLVexc/9djZvBI40qa9KAaVyKZSupxhJxF5A+A50L7LDNrCe/PIZUE/6W7HwLeMLPFIX9xLfBoOH4TsCK8vxLYFvIgW4ClZtYRhsKWhraKyVXrKI4WjzUX4+TnshRT40rPS5fJIm/gMLMNwJPAPDPrN7PrgK+b2R4zexa4FLgx7P4h4Fkz200q0f1Zd48S6zcAfw/sB14EHgvt9wCnm9l+UsNbqwDCcbcCz4TXLWnnqohctY7irFw2L3Y8TRqTc/JzWQqtcaUiijKZ5B2qcvdrYprvSdj3YeDhhG19wHti2n8LXJVwzHpgfb5rLKekWkdJtMq8uaTnuXp3DiQOX2Xnw3IFmFoMa2l4TSpJJUdKFP2GKc3lba2pTni+n2/2MGXSxIpaLBbVI3Sl0lRypERJU3elsQ2PjAG5f75xea+kfFdc3qTSVEJeKk09jhKpplXz6t05kPPn+7VPXgCQUbH30vNnxVZVduBLD+4GqvfbvkrIS6Wpx1EizahqXuu27Ev8+UblZlY+tDsjEb7xmVcT812j7lVNlCddu/7NSrkocJQobuquZlg1h4Gh4djcRDREdfMP9jIymhkmRkadXFVoqjlUVOy0cpFiKXCUKG7q7u+8c2atL0sqpMWMTy1Kzbg7cjR+4eeY5/7loVqJ8mKnlYsUy1Jr7ZpHd3e39/X11eR7L1m7TSXXJZEZvPS1j9b6MkRimdkOd+8uZF8lx8tIyUfJJfodTWsspNEpcJRRUq2rttYp49M8ZXL7Su+ejEfYVmONhQKVlJuGqsooe+EVpJKSx06MMtZcf81SZkbqF4yj4ReMjhmtrPn4/Al/wCf9myxXzkNBqXkUM1Sl5HgZJSUlFTQkH4fxoAGpZ4WsfGj3hKfwVnIxoOpzTV4aqiqzuFpXX3pwN6NN1rOTyhsZ9QnXuqrkYsB6q88l1aMeRxVcc/HZtb4EaVAT/YAvdTFgISXitUJ98lKPowpu67mA//PPA7x5XLWtpDintbWelEe49PxZPP784YLyCiuXzYvNceRaDFhokcRiH3wmzUPJ8SqJS1KK5DPFoGWKnbRSPZ2RypF0JgSRYhPYSeuROtvbeGLVZRnnrWTiXapL6zjqUPQfKfoP/DZN0ZUCjDmM5Qga8NYzYZJ6BsU+YyZXifgla7eNB570f9MDQ8O0mGUk3hU8mpd6HDWkleZSCVHPIFdPI9e2fP8uDfjDxXO4reeC8XOp59H4iulxKHDUkIavpFLa21oZGs6sqRUNabW3tfLm8RMZw1/pH/SF/Ls04M6rF9CzsLPgoS2pbwocDRI4IAoez2rYSsomChDFam9r5ZTpUzk4NMxpba2YkVjQEVKFH8fcE7+XAS+tVW2uRqEFgA2kZ2EnM0+ZXuvLkCZS6q+CQ8Mj44v5hoZH+O3IWM5S8aM5gkZ0HUlTeaWx5Q0cZrbezF4zs+fS2m4yswEz2xVev5+2bbWZ7TezfWa2LK19kZntCdu+aWYW2qeb2cbQ/pSZdaUds8LMXgivFWW76zqjPIeUakbrFGa0Vub3v+GRiZfKKddq8kLWlUj1FPIv7l7g8pj2O919QXj9CMDM3g0sB+aHY/7azKInytwFXA+cG17ROa8Djrj7u4A7gdvDuWYCa4CLgYuANWbWUfQd1rnenQN6AJSU7OjIWN0Pc060xIlKm9SfvNNx3f1n6b2APK4Avufux4CXzGw/cJGZvQyc6u5PApjZ/UAP8Fg45qZw/EPAt0JvZBmw1d0HwzFbSQWbDQVeS0NYt2VfyUMLIlD60FQ1HRwazpjJ9bbWKRw7McaYp3Il11x89vgsrWw3/2CvSpvUmYms4/hjM7sW6AO+5O5HgE5ge9o+/aFtJLzPbif8+SqAu58ws9eB09PbY47JYGbXk+rNMGfOnAncUvWpPINMBlOnwI0bd40HufRe0qg7D2w/wEuH/x/f+aMPjLf37hzgpk17T5odFomGeFWht/pKHRy9C3gnsAA4BNwR2uNGXTxHe6nHZDa63+3u3e7ePWvWrByXXX9UnkEmg5Gx/D2jJ14cHB9+ioankoIGpHoqtRrGqkXOpZ7yPCUFDnf/lbuPuvsY8HekchCQ6hWkV/SbDRwM7bNj2jOOMbOpwGnAYI5zNZWVy+bR1tqS0daaayqLSBOLciFxlXezjbpXtGx8nN6dAyy4+cd8YeOuqgaresvzlBQ4zOzMtC//AIhmXG0CloeZUnNJJcGfdvdDwBtmtjjkL64FHk07JpoxdSWwzVOLS7YAS82sIyTFl4a2phL3DI91V13IN65eoAAik040/FTIEG5ne1tVK/Tm6gUlBaty9RKqHSDzyZvjMLMNwCXAGWbWT2qm0yVmtoBU7/Nl4L8BuPteM3sQ+DlwAvicu0d3ewOpGVptpJLij4X2e4Bvh0T6IKlZWbj7oJndCjwT9rslSpQ3m1y1hHKN8Yo0oyVrtzFjWkvOatKtLcbKZfPG62SdxGDuqs3jOQ9gwnmQfL2gg1k5l4Gh4YzFmBN5THC9lbDXyvE6p3pWIpmmT53C7Z9673h5lJXf381IjgUnrVMMjIwSK/kqCseZu2pzzjxNdK585VpazLjj0xcWFTyqUdZF1XGbiGZdiWQ6fiJz3cqJPL/8xgWV7F5A3yuDeZ9xkvT8EXjrGSeF5maK7XmU8lyVSlKPo86pxyFyshazsj6OOa6+1ynTWjh6fDRjuCuuN9Exo5U1H59Pz8LOvL2SdIVUMU6Xvl9US2zo6EjZpiCryGETBY64SqWlFrETkdJ1zGjlo+89M2fPpJhf9KIKw8WWpK9UGXsFjiYKHHDyAqdLz5/FwzsGVI5dpMqiD2iIT7YX86iEzrCGq9jcRVJwiqoVl9oDUY6jSWQHjOj5BwDd75iZPKNERCpieGSUmzbtzXieycDQMCsf2g1w0lMRk0T5iRs37ordniu3mbQtGrqbyOytQilw1Kns31yy/zGkT+Ht3TmQUc5BRConbnr8yKhz8w/2AvmDBsCnFqX+/ybte1pbK0vWbosdEsuVpI9UupaXnsdRp4pZ8KO6PCK1d+ToyPjq7nwef/4wkFw54s3jJzJWiX9h4y66Vm2ma9Vmjrx5jNaW/IuDKzkjU4GjThW74Ec1r0Rqr9C840BateD0Y1rMmDZ1Ssaak2xHR8YYGXU6ZrRi4Zg4lfxMUOCoU0k/9KT2uN9cRKQ+GcT2Tkbdc66YT/fbkVFeWvtR7vj0hSf936/0Gg8FjjoVFwhy/WOIal6JSP1zCu+dJBkeGeMrvXvGey1Rz6OzvW3CU3PzUeCoU3HFD/P9Y+hZ2Dk+xU9Emt8D2w+M91qiWVVHj5+o+PfVrKo6lqv4YZJCauWAFhGKNKsjR0dY+f3M6cHlph5Hk8nuqbS1xv+IFTREmtfImHPTpr0VO796HE0ovaeSa5VpOWv9iEh9qeTjGNTjaHL5VpmKiBRLgaPJJU3f7WxvY1oBi4hERLIpcDS5XNN6v37lhejptCJSLOU4mlx60bWkUtBfenC3hq5EpGAKHJNArmm9UXuhpaBFRBQ4pOBS0CIioMAhQSFTeEWkcSQs4SqLvKc2s/Vm9pqZPRez7c/MzM3sjPB1l5kNm9mu8PqbtH0XmdkeM9tvZt80SxVWMbPpZrYxtD9lZl1px6wwsxfCa0VZ7ljyqmRxNBGpjtaWykWOQs58L3B5dqOZnQ18BDiQtelFd18QXp9Na78LuB44N7yic14HHHH3dwF3AreH888E1gAXAxcBa8yso8D7kgnoWdhJx4zWWl+GiEzA0ZGxip07b+Bw958BgzGb7gT+nAKqV5jZmcCp7v6kpx5yfj/QEzZfAdwX3j8EfDj0RpYBW9190N2PAFuJCWBSGWs+Pv+kabyauSsiUOI6DjP7BDDg7rtjNs81s51m9lMz+2Bo6wT60/bpD23RtlcB3P0E8Dpwenp7zDHZ13O9mfWZWd/hw4dLuSXJEledVxN2RQRKSI6b2Qzgy8DSmM2HgDnu/hszWwT0mtl84n9ZjT6HkrblOiaz0f1u4G6A7u5ufb6VSfY0XiXNRQRK63G8E5gL7Dazl4HZwD+b2b9392Pu/hsAd98BvAicR6q3MDvtHLOBg+F9P3A2gJlNBU4jNTQ23h5zjNTAymXzaNVSc5FJr+jA4e573P3t7t7l7l2kPuDf5+7/YmazzKwFwMzOIZUE/6W7HwLeMLPFIX9xLfBoOOUmIJoxdSWwLeRBtgBLzawjJMWXhjapkZ6Fnay76kLa295KnHfMaOUbVy/gG1cv0EOkRCaJvENVZrYBuAQ4w8z6gTXufk/C7h8CbjGzE8Ao8Fl3jxLrN5CaodUGPBZeAPcA3zaz/aR6GssB3H3QzG4Fngn73ZJ2LqmRfKvQ567arFyISJPLGzjc/Zo827vS3j8MPJywXx/wnpj23wJXJRyzHlif7xqlfpzV3qbnf4g0OVXHlbJKqsZ7x6cv5BtXLzhpm4g0HpUckbIqpBrvTZv2VvTpZCJSWQocUna58iAAx05UbkWriFSehqqkqtZt2Teh8u0zWqcwo5LV20QkL/U4pKx6dw7kHKZKegZ6PqdMa+Grf3DB+Ll6dw7whY27ynHJIlIkBQ4pm96dAxkPhBoYGmb1I3uAt3IfSbOuOtvbOHr8BEeOnpz7aJ0Ce285uUyZZmqJ1Ib6/FI2ccNQwyOjrNuyb/zrXM9AX/Px+bS2ZK5Mb20x1l21IKMtClAKGiK1oR6HlE3SMFR6eyGzrnJti7brMbcitaPAIWWTNAx1VlYpkvRZV1FO5MaNu8YDxROrLsv5fUrNk4hIeWioSsom1zBUnGjIaWBoGOetnEjvzoGc3yc7EBWrxVSoUWQiFDikbOKe4fG1T16QuKajkJxInKQA9ZnFczIKMMbpbG/jjk9fqBXsIhOgoSopq3yL/9IVkhNJ+h4Qnwu5recC4OQZXvBW7yf9+IGh4fHZWW2tUxiu4OM2RZqFAofUTKE5kTj5AlS+JHy+43t3Dqg0ikgCBQ6pmZXL5iX2CsqhmN5PMcfG9WaSvLz2owpC0nQUOKRmCpmaWy35Vrynyx7qShI92CoKQtnf49LzZ/HD3YcUUKThmDfZIqru7m7v6+ur9WVIA0nKh+RK7Jf7ePVIpBJeXvvRgvc1sx3u3l3IvppVJZNeqbO7IsXOJos7fteapeOP39VkYal3GqqSSa/U2V3pJpJPiTvHkrXbcg6D5dLe1srxE6Mc1QwxqRD1OGTSS5rFNdGFhhMRt1alEJ3tbexas5Sf3/p7vLz2o3xm8ZzY/U6Z1jLeO1ryzpnq5UhR1OOQSa/Ss7tKkTRxIGpL6o1k95K63zGT724/QHrfYwpklKhPFyXwk84/feoUPYhL8gcOM1sPfAx4zd3fk7Xtz4B1wCx3/3VoWw1cB4wCf+ruW0L7IuBeoA34EfB5d3czmw7cDywCfgNc7e4vh2NWAF8J3+42d79vQncrEqOeZndlX1fcNfQs7EwcysruJa3bso/sj/mx0J507uw6YtmBKzvItk4xwNHI2ORRSI/jXuBbpD7cx5nZ2cBHgANpbe8GlgPzgbOAfzSz89x9FLgLuB7YTipwXA48RirIHHH3d5nZcuB24GozmwmsAboBB3aY2SZ3P1L67YrEK0eOopoK7SVNJH+T6+8kLsj+4d89yRMvDuY8Z8eMVoaOjnBaWytmcOToCKmwU5jWKShA1YG8gcPdf2ZmXTGb7gT+HHg0re0K4Hvufgx4ycz2AxeZ2cvAqe7+JICZ3Q/0kAocVwA3heMfAr5lZgYsA7a6+2A4ZiupYLOhuFsUaT6F9pImsjo/1/eOCyjbf5n7d7rO9ra8lY8hc7gsKgfTmXZ/SWtu4o6bzCpZzLOkHIeZfQIYcPfdlnlxnaR6FJH+0DYS3me3R8e8CuDuJ8zsdeD09PaYY7Kv53pSvRnmzIlPBoo0m0J6SdXM3+T6oC7mexZSTibfMFskaUivva2Vmz4x/6RAE9f7mdE6hemtLQwdHYkN0O9d8w/867H6ez7MNRefXbFzFx04zGwG8GVgadzmmDbP0V7qMZmN7ncDd0NqAWDcPiKTUb3kb4pZ11JOSYHzpk/Mjw00cav7H3/+cM6/u2dvvjzjuCkl9HbyDddF26OeV98rg2x46tXxYDfFYDScYIrBf7x4znjBz0oopcfxTmAuEPU2ZgP/bGYXkeoVpIe52cDB0D47pp20Y/rNbCpwGjAY2i/JOuYnJVyvyKRWD/mbWn3/YgNn9uSA9KATPS+m75XB2GASHTd31ebE6zGIvYZ8gScKGtFQX3ol6FooOnC4+x7g7dHXIX/R7e6/NrNNwHfN7K9IJcfPBZ5291Eze8PMFgNPAdcC/yucYhOwAngSuBLYFmZbbQH+wsw6wn5LgdWl3KSIVF5nQj6ls4brYaD0wJlUUeA72w+M9w6iYBJ9H0jOK+XK8RQSeOrpyZd5FwCa2QZSH+rzzKzfzK5L2tfd9wIPAj8H/gH4XJhRBXAD8PfAfuBFUolxgHuA00Mi/YvAqnCuQeBW4JnwuiVKlItI/Sn2CZD1LumDOntIKbs8zUT/HupxQWq2QmZVXZNne1fW118FvhqzXx/wnpj23wJXJZx7PbA+3zWKSO3VSz6lXJJ6DnHSg8xE/x7qcUFqNlXHFRGJEVf1OCmJXehU42K+d7UDcDHVcVVyREQkRlzP4dLzZ/HwjoGK9wbqYUJDLgocIiIJ4j7Au98xs2mG40qlwCEiUoR67w1Ug8qqi4hIURQ4RESkKAocIiJSFAUOEREpigKHiIgUpekWAJrZYeCVCZziDODXZbqcRjHZ7nmy3S/onieLidzzO9x9ViE7Nl3gmCgz6yt09WSzmGz3PNnuF3TPk0W17llDVSIiUhQFDhERKYoCx8nurvUF1MBku+fJdr+ge54sqnLPynGIiEhR1OMQEZGiKHCIiEhRFDgCM7vczPaZ2X4zW1Xr6ymGmZ1tZo+b2S/MbK+ZfT60zzSzrWb2QvizI+2Y1eFe95nZsrT2RWa2J2z7pplZaJ9uZhtD+1Nm1lX1G41hZi1mttPMfhi+bup7NrN2M3vIzJ4PP+8PTIJ7vjH8u37OzDaY2dua7Z7NbL2ZvWZmz6W1VeUezWxF+B4vmNmKgi7Y3Sf9C2gh9Rz0c4BpwG7g3bW+riKu/0zgfeH9vwX+L/Bu4OvAqtC+Crg9vH93uMfpwNxw7y1h29PAB0g97Owx4PdC+38H/ia8Xw5srPV9h2v5IvBd4Ifh66a+Z+A+4L+G99OA9ma+Z6ATeAloC18/CPynZrtn4EPA+4Dn0toqfo/ATOCX4c+O8L4j7/XW+j9CPbzCX/SWtK9XA6trfV0TuJ9HgY8A+4AzQ9uZwL64+wO2hL+DM4Hn09qvAf42fZ/wfiqp1alW4/ucDfwTcBlvBY6mvWfgVFIfopbV3sz33Am8Gj7YpgI/BJY24z0DXWQGjorfY/o+YdvfAtfku1YNVaVE/zgj/aGt4YQu6ELgKeDfufshgPDn28NuSffbGd5nt2cc4+4ngNeB0ytyE4X7BvDnwFhaWzPf8znAYeB/h+G5vzezU2jie3b3AeAvgQPAIeB1d/8xTXzPaapxjyV99ilwpFhMW8PNUzazfwM8DHzB3f81164xbZ6jPdcxNWFmHwNec/cdhR4S09ZQ90zqN8X3AXe5+0LgTVJDGEka/p7DuP4VpIZkzgJOMbPP5Dokpq2h7rkA5bzHku5dgSOlHzg77evZwMEaXUtJzKyVVND4jrs/Epp/ZWZnhu1nAq+F9qT77Q/vs9szjjGzqcBpwGD576RgS4BPmNnLwPeAy8zsAZr7nvuBfnd/Knz9EKlA0sz3/LvAS+5+2N1HgEeA36G57zlSjXss6bNPgSPlGeBcM5trZtNIJY821fiaChZmTtwD/MLd/ypt0yYgmiWxglTuI2pfHmZazAXOBZ4O3eE3zGxxOOe1WcdE57oS2OZhULQW3H21u8929y5SP69t7v4Zmvue/wV41czmhaYPAz+nie+Z1BDVYjObEa71w8AvaO57jlTjHrcAS82sI/Tuloa23KqdAKrXF/D7pGYjvQh8udbXU+S1/wdS3ctngV3h9fukxjD/CXgh/Dkz7Zgvh3vdR5h5Edq7gefCtm/xVnWBtwHfB/aTmrlxTq3vO+2aL+Gt5HhT3zOwAOgLP+teUjNhmv2ebwaeD9f7bVKziZrqnoENpHI4I6R6AddV6x6B/xLa9wP/uZDrVckREREpioaqRESkKAocIiJSFAUOEREpigKHiIgURYFDRESKosAhIiJFUeAQEZGi/H+rkbnrGzO+aQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([14, 3, 16, 11, 3, 0, 1, 1, 0, 7, 6, 1, 10, 0, 3, 25, 1, 5,\n", + " 3, 19, 14, 0, 5, 1, 2])\n", + "loss= tensor(0.0175, grad_fn=) , base rewards= tensor([1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905,\n", + " 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905,\n", + " 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 1.1905, 0.5842]) return= 148750.73147959905\n", + "probs of actions: tensor([0.0144, 0.0769, 0.0084, 0.0269, 0.0723, 0.1253, 0.1997, 0.2097, 0.1171,\n", + " 0.0379, 0.0392, 0.1988, 0.0184, 0.1445, 0.0712, 0.0025, 0.1723, 0.0459,\n", + " 0.0791, 0.0074, 0.0123, 0.1493, 0.0456, 0.0360, 0.1514],\n", + " grad_fn=)\n", + "rewards: tensor([0.4916, 0.5882, 0.5615, 0.6249, 0.6416, 0.6135, 0.5876, 0.5787, 0.5744,\n", + " 0.5635, 0.5885, 0.6001, 0.5750, 0.6122, 0.5862, 0.5237, 0.6728, 0.6179,\n", + " 0.6096, 0.5617, 0.6350, 0.6635, 0.6094, 0.6062, 0.5876])\n", + "finalReturns: tensor([0.0033, 0.0034])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([15, 3, 0, 1, 2, 3, 8, 20, 5, 1, 2, 2, 20, 4, 0, 16, 7, 3,\n", + " 1, 4, 0, 1, 10, 18, 2])\n", + "loss= tensor(0.2574, grad_fn=) , base rewards= tensor([1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903,\n", + " 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903,\n", + " 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 1.1903, 0.5841]) return= 147965.21557760105\n", + "probs of actions: tensor([0.0130, 0.0589, 0.1116, 0.1393, 0.1200, 0.0616, 0.0497, 0.0144, 0.0476,\n", + " 0.1558, 0.1346, 0.1217, 0.0172, 0.0458, 0.1088, 0.0108, 0.0390, 0.0611,\n", + " 0.1885, 0.0504, 0.1248, 0.1695, 0.0303, 0.0540, 0.1250],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5920, 0.5891, 0.5756, 0.5725, 0.5743, 0.5738, 0.5620, 0.6584,\n", + " 0.6303, 0.5994, 0.5883, 0.5431, 0.6493, 0.6216, 0.5661, 0.6345, 0.6268,\n", + " 0.6062, 0.5864, 0.5905, 0.5763, 0.5632, 0.5737, 0.6545])\n", + "finalReturns: tensor([0.0380, 0.0704])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([14, 21, 8, 9, 6, 12, 8, 10, 0, 16, 13, 14, 8, 11, 9, 10, 24, 11,\n", + " 6, 12, 4, 6, 21, 24, 1])\n", + "loss= tensor(1.2737, grad_fn=) , base rewards= tensor([1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578,\n", + " 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.7578,\n", + " 1.7578, 1.7578, 1.7578, 1.7578, 1.7578, 1.1436, 0.5555]) return= 155604.86406451356\n", + "probs of actions: tensor([0.0600, 0.0362, 0.0519, 0.0546, 0.0361, 0.0490, 0.0557, 0.0364, 0.0278,\n", + " 0.0230, 0.0319, 0.0608, 0.0539, 0.0619, 0.0510, 0.0411, 0.0055, 0.0660,\n", + " 0.0392, 0.0492, 0.0329, 0.0401, 0.0539, 0.0233, 0.3283],\n", + " grad_fn=)\n", + "rewards: tensor([0.4916, 0.5450, 0.6517, 0.6329, 0.6329, 0.6080, 0.6327, 0.6216, 0.6358,\n", + " 0.5730, 0.6260, 0.6339, 0.6565, 0.6313, 0.6376, 0.6288, 0.5818, 0.6848,\n", + " 0.6687, 0.6255, 0.6464, 0.6165, 0.5702, 0.6138, 0.7134])\n", + "finalReturns: tensor([0.1395, 0.1836, 0.1579])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 6, 15, 14, 20, 36, 0, 15, 8, 8, 14, 12, 18, 18, 13, 3, 14, 22, 14,\n", + " 21, 11, 20, 8, 21, 18, 0])\n", + "loss= tensor(0.9700, grad_fn=) , base rewards= tensor([1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388,\n", + " 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.8388,\n", + " 1.8388, 1.8388, 1.8388, 1.8388, 1.8388, 1.1775, 0.5665]) return= 159349.80394345985\n", + "probs of actions: tensor([0.0330, 0.0339, 0.0631, 0.0733, 0.0017, 0.0306, 0.0286, 0.0401, 0.0466,\n", + " 0.0726, 0.0440, 0.0487, 0.0563, 0.0307, 0.0221, 0.0734, 0.0735, 0.0665,\n", + " 0.0498, 0.0591, 0.0820, 0.0466, 0.0689, 0.0787, 0.4260],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5363, 0.5986, 0.6050, 0.5536, 0.7714, 0.6403, 0.6653, 0.6413,\n", + " 0.6162, 0.6396, 0.6226, 0.6477, 0.6759, 0.6775, 0.6114, 0.6031, 0.6753,\n", + " 0.6395, 0.6950, 0.6372, 0.6933, 0.6173, 0.6634, 0.7007])\n", + "finalReturns: tensor([0.1425, 0.1866, 0.1341])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 20, 13, 14, 22, 14, 19, 17, 22, 21, 20, 3, 20, 11, 19, 22, 22, 18,\n", + " 10, 7, 6, 3, 14, 20, 0])\n", + "loss= tensor(1.5644, grad_fn=) , base rewards= tensor([2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511,\n", + " 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511, 2.3511,\n", + " 2.3511, 2.3511, 2.3511, 2.3511, 1.7238, 1.1293, 0.5538]) return= 161196.03057528232\n", + "probs of actions: tensor([0.0256, 0.1232, 0.0320, 0.0744, 0.1199, 0.0737, 0.0420, 0.0094, 0.1163,\n", + " 0.0829, 0.1265, 0.0155, 0.1098, 0.0445, 0.0464, 0.1240, 0.1144, 0.0748,\n", + " 0.0275, 0.0205, 0.0154, 0.0063, 0.0466, 0.1303, 0.4053],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5568, 0.6412, 0.6416, 0.6184, 0.6831, 0.6514, 0.6718, 0.6506,\n", + " 0.6750, 0.6851, 0.7229, 0.6127, 0.6750, 0.6313, 0.6421, 0.6665, 0.6948,\n", + " 0.7063, 0.6727, 0.6430, 0.6264, 0.5865, 0.5988, 0.6800])\n", + "finalReturns: tensor([0.1407, 0.1416, 0.1495, 0.1262])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 14, 20, 22, 9, 14, 4, 14, 16, 10, 20, 27, 16, 18, 21, 22, 22, 36,\n", + " 35, 14, 19, 22, 18, 22, 3])\n", + "loss= tensor(2.6137, grad_fn=) , base rewards= tensor([2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956,\n", + " 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956, 2.4956,\n", + " 2.4956, 2.4956, 2.4956, 2.4956, 1.7649, 1.1211, 0.5397]) return= 164736.5382403899\n", + "probs of actions: tensor([0.0133, 0.0640, 0.1319, 0.1598, 0.0210, 0.0640, 0.0092, 0.0613, 0.0241,\n", + " 0.0190, 0.1395, 0.0154, 0.0235, 0.0725, 0.0903, 0.1666, 0.1526, 0.0027,\n", + " 0.0031, 0.0615, 0.0470, 0.2001, 0.0628, 0.1609, 0.0251],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.6325, 0.6222, 0.6436, 0.7075, 0.6536, 0.6712, 0.6126, 0.6266,\n", + " 0.6604, 0.6151, 0.6155, 0.7094, 0.6794, 0.6646, 0.6714, 0.6813, 0.6050,\n", + " 0.6759, 0.8072, 0.7115, 0.6823, 0.7028, 0.6719, 0.7290])\n", + "finalReturns: tensor([0.2903, 0.3387, 0.2798, 0.1893])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 18, 18, 21, 20, 20, 19, 29, 20, 12, 18, 30, 20, 20, 19, 20, 19, 21,\n", + " 14, 22, 33, 22, 30, 19, 1])\n", + "loss= tensor(7.3655, grad_fn=) , base rewards= tensor([2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315,\n", + " 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315, 2.9315,\n", + " 2.9315, 2.9315, 2.9315, 2.2128, 1.5745, 1.0063, 0.4840]) return= 166890.7839838453\n", + "probs of actions: tensor([0.0632, 0.0722, 0.0731, 0.1009, 0.1375, 0.1517, 0.0480, 0.0092, 0.1566,\n", + " 0.0204, 0.0714, 0.0143, 0.1307, 0.1588, 0.0509, 0.1426, 0.0479, 0.0973,\n", + " 0.0514, 0.2092, 0.0065, 0.2335, 0.0459, 0.0530, 0.3991],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5721, 0.6217, 0.6355, 0.6651, 0.6738, 0.6820, 0.6320, 0.7180,\n", + " 0.7257, 0.6651, 0.6115, 0.7148, 0.6986, 0.6944, 0.6822, 0.6863, 0.6741,\n", + " 0.7050, 0.6499, 0.6099, 0.7285, 0.6681, 0.7477, 0.7484])\n", + "finalReturns: tensor([0.5711, 0.6800, 0.5898, 0.4899, 0.2645])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 34, 21, 22, 18, 20, 20, 12, 24, 27, 27, 22, 19, 22, 13, 22, 22, 27,\n", + " 19, 7, 28, 27, 20, 20, 1])\n", + "loss= tensor(5.8577, grad_fn=) , base rewards= tensor([2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630,\n", + " 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630, 2.8630,\n", + " 2.8630, 2.8630, 2.8630, 2.1888, 1.5716, 1.0087, 0.4901]) return= 167594.10275330738\n", + "probs of actions: tensor([0.0381, 0.0033, 0.1169, 0.2371, 0.0617, 0.1343, 0.1313, 0.0187, 0.0158,\n", + " 0.0354, 0.0313, 0.2488, 0.0485, 0.2537, 0.0144, 0.2383, 0.2167, 0.0351,\n", + " 0.0473, 0.0053, 0.0577, 0.0559, 0.0876, 0.1112, 0.4341],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5284, 0.6977, 0.6880, 0.7056, 0.6817, 0.6821, 0.7079, 0.6312,\n", + " 0.6496, 0.6796, 0.7194, 0.7175, 0.6853, 0.7197, 0.6516, 0.6712, 0.6567,\n", + " 0.7201, 0.7300, 0.5959, 0.6591, 0.7174, 0.6998, 0.7310])\n", + "finalReturns: tensor([0.5402, 0.6186, 0.5767, 0.4222, 0.2409])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([20, 19, 20, 14, 16, 15, 14, 20, 29, 22, 30, 7, 23, 22, 16, 28, 21, 21,\n", + " 15, 22, 27, 24, 28, 18, 20])\n", + "loss= tensor(9.9226, grad_fn=) , base rewards= tensor([3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069,\n", + " 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069, 3.4069,\n", + " 3.4069, 3.4069, 2.6990, 2.0658, 1.4896, 0.9606, 0.4659]) return= 165948.08509427204\n", + "probs of actions: tensor([0.1222, 0.0517, 0.1246, 0.0333, 0.0148, 0.0208, 0.0315, 0.1187, 0.0167,\n", + " 0.2670, 0.0305, 0.0043, 0.0257, 0.2612, 0.0148, 0.0541, 0.1120, 0.1124,\n", + " 0.0204, 0.2571, 0.0602, 0.0236, 0.0898, 0.0548, 0.0089],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5762, 0.6222, 0.6724, 0.6566, 0.6630, 0.6635, 0.6377, 0.6158,\n", + " 0.7012, 0.6546, 0.7721, 0.6414, 0.6726, 0.7047, 0.6310, 0.7061, 0.6965,\n", + " 0.7133, 0.6595, 0.6508, 0.6956, 0.6766, 0.7411, 0.6991])\n", + "finalReturns: tensor([0.7158, 0.7642, 0.7465, 0.6272, 0.4796, 0.2332])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([10, 18, 22, 8, 13, 21, 30, 22, 22, 18, 20, 22, 22, 20, 16, 22, 22, 31,\n", + " 27, 22, 22, 28, 33, 25, 0])\n", + "loss= tensor(8.9832, grad_fn=) , base rewards= tensor([3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430,\n", + " 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430, 3.5430,\n", + " 3.5430, 3.5430, 2.7640, 2.0976, 1.5056, 0.9645, 0.4642]) return= 166974.19797318938\n", + "probs of actions: tensor([0.0065, 0.0534, 0.2572, 0.0041, 0.0070, 0.1266, 0.0462, 0.2606, 0.2463,\n", + " 0.0471, 0.1058, 0.2736, 0.2632, 0.1185, 0.0113, 0.2592, 0.2285, 0.0110,\n", + " 0.0443, 0.2700, 0.2503, 0.1291, 0.0162, 0.0182, 0.4393],\n", + " grad_fn=)\n", + "rewards: tensor([0.5012, 0.5414, 0.5896, 0.6815, 0.6387, 0.6158, 0.6050, 0.7030, 0.6971,\n", + " 0.7101, 0.6840, 0.6748, 0.6830, 0.6955, 0.7034, 0.6604, 0.6757, 0.6357,\n", + " 0.7019, 0.7306, 0.7108, 0.6710, 0.6617, 0.7411, 0.7845])\n", + "finalReturns: tensor([0.7566, 0.8050, 0.7605, 0.6816, 0.5611, 0.3202])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 25, 20, 22, 19, 27, 14, 20, 20, 28, 22, 26, 22, 25, 22, 16, 20, 28,\n", + " 35, 22, 28, 24, 35, 21, 1])\n", + "loss= tensor(17.5911, grad_fn=) , base rewards= tensor([3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892,\n", + " 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892, 3.8892,\n", + " 3.8892, 3.1333, 2.4777, 1.9031, 1.3792, 0.8937, 0.4336]) return= 169157.71969025527\n", + "probs of actions: tensor([0.1966, 0.0134, 0.0961, 0.2240, 0.0379, 0.0611, 0.0165, 0.0902, 0.0964,\n", + " 0.1224, 0.2404, 0.0058, 0.2346, 0.0130, 0.2149, 0.0092, 0.0876, 0.1168,\n", + " 0.0107, 0.2272, 0.1714, 0.0245, 0.0173, 0.0977, 0.4515],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5577, 0.6510, 0.6583, 0.6869, 0.6456, 0.7309, 0.6709, 0.6767,\n", + " 0.6412, 0.7070, 0.6799, 0.7125, 0.6877, 0.7095, 0.7231, 0.6785, 0.6421,\n", + " 0.6334, 0.7566, 0.6935, 0.7244, 0.6469, 0.7678, 0.7709])\n", + "finalReturns: tensor([1.1043, 1.2268, 1.1258, 1.0068, 0.8064, 0.6450, 0.3373])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 18, 28, 8, 30, 28, 22, 26, 21, 30, 16, 28, 30, 21, 29, 20, 15, 14,\n", + " 35, 24, 30, 25, 15, 28, 1])\n", + "loss= tensor(20.5320, grad_fn=) , base rewards= tensor([3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731,\n", + " 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731, 3.7731,\n", + " 3.7731, 3.0794, 2.4531, 1.8923, 1.3768, 0.8983, 0.4447]) return= 168858.2221272981\n", + "probs of actions: tensor([0.1752, 0.0359, 0.1420, 0.0023, 0.1136, 0.1529, 0.1983, 0.0071, 0.1085,\n", + " 0.0974, 0.0071, 0.1572, 0.0805, 0.1022, 0.0308, 0.0753, 0.0101, 0.0115,\n", + " 0.0147, 0.0269, 0.1365, 0.0181, 0.0044, 0.1603, 0.4318],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5878, 0.5838, 0.7193, 0.5839, 0.6620, 0.7176, 0.6852, 0.7194,\n", + " 0.6572, 0.7527, 0.6545, 0.6722, 0.7418, 0.6741, 0.7395, 0.7282, 0.6956,\n", + " 0.5712, 0.7149, 0.6747, 0.7247, 0.7539, 0.6493, 0.7595])\n", + "finalReturns: tensor([1.0750, 1.1975, 1.1090, 0.9950, 0.7859, 0.5105, 0.3148])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([35, 30, 27, 30, 26, 30, 24, 28, 30, 28, 28, 20, 22, 18, 28, 21, 30, 21,\n", + " 28, 20, 35, 27, 23, 24, 0])\n", + "loss= tensor(22.2467, grad_fn=) , base rewards= tensor([4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083,\n", + " 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083, 4.4083,\n", + " 3.6312, 2.9657, 2.3731, 1.8365, 1.3349, 0.8691, 0.4276]) return= 171860.1014475075\n", + "probs of actions: tensor([0.0155, 0.1387, 0.0842, 0.1351, 0.0062, 0.1424, 0.0205, 0.1975, 0.1485,\n", + " 0.2269, 0.2205, 0.0589, 0.1767, 0.0277, 0.2067, 0.0804, 0.1470, 0.0747,\n", + " 0.2376, 0.0435, 0.0166, 0.0998, 0.0360, 0.0276, 0.5303],\n", + " grad_fn=)\n", + "rewards: tensor([0.3887, 0.5824, 0.6667, 0.6713, 0.7178, 0.6899, 0.7373, 0.6974, 0.6939,\n", + " 0.7185, 0.7161, 0.7533, 0.7091, 0.7161, 0.6485, 0.7150, 0.6550, 0.7331,\n", + " 0.6755, 0.7329, 0.6250, 0.7277, 0.7390, 0.7123, 0.7634])\n", + "finalReturns: tensor([1.3006, 1.3447, 1.3347, 1.1943, 1.1059, 0.8798, 0.6066, 0.3358])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 27, 22, 29, 21, 30, 30, 19, 28, 28, 28, 28, 20, 21, 28, 22, 28, 16,\n", + " 30, 22, 30, 30, 28, 22, 0])\n", + "loss= tensor(18.0560, grad_fn=) , base rewards= tensor([4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142,\n", + " 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142, 4.4142,\n", + " 3.6415, 2.9781, 2.3817, 1.8416, 1.3390, 0.8688, 0.4250]) return= 171085.1459720632\n", + "probs of actions: tensor([0.1140, 0.0849, 0.1386, 0.0385, 0.0610, 0.1932, 0.1898, 0.0215, 0.2710,\n", + " 0.2721, 0.2628, 0.2541, 0.0457, 0.0631, 0.2471, 0.1317, 0.2572, 0.0035,\n", + " 0.2388, 0.1023, 0.2539, 0.2563, 0.2776, 0.1031, 0.5480],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5473, 0.6509, 0.6352, 0.7155, 0.6553, 0.6873, 0.7575, 0.6749,\n", + " 0.6942, 0.7039, 0.7088, 0.7496, 0.7116, 0.6649, 0.7191, 0.6751, 0.7471,\n", + " 0.6402, 0.7212, 0.6645, 0.6920, 0.7175, 0.7456, 0.7666])\n", + "finalReturns: tensor([1.2805, 1.3061, 1.3294, 1.2046, 1.0801, 0.8908, 0.6434, 0.3416])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 34, 28, 28, 21, 28, 27, 33, 22, 30, 30, 30, 18, 28, 18, 28, 22, 28,\n", + " 26, 21, 28, 19, 28, 28, 0])\n", + "loss= tensor(28.0922, grad_fn=) , base rewards= tensor([4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255,\n", + " 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.8255, 4.0601,\n", + " 3.4001, 2.8111, 2.2769, 1.7822, 1.3120, 0.8635, 0.4256]) return= 171718.15438855253\n", + "probs of actions: tensor([0.2378, 0.0037, 0.2717, 0.2788, 0.0438, 0.2894, 0.0874, 0.0125, 0.0765,\n", + " 0.2683, 0.2530, 0.2230, 0.0178, 0.3035, 0.0147, 0.2880, 0.0791, 0.2907,\n", + " 0.0042, 0.0341, 0.3246, 0.0078, 0.3015, 0.2731, 0.5919],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5365, 0.6677, 0.6905, 0.7364, 0.6771, 0.7008, 0.6696, 0.7592,\n", + " 0.6832, 0.7015, 0.7107, 0.7730, 0.6763, 0.7409, 0.6606, 0.7169, 0.6740,\n", + " 0.7045, 0.7292, 0.6736, 0.7358, 0.6643, 0.6888, 0.7796])\n", + "finalReturns: tensor([1.5413, 1.5897, 1.5757, 1.4602, 1.2652, 1.0863, 0.8207, 0.6049, 0.3540])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([21, 28, 22, 22, 27, 22, 22, 30, 28, 27, 22, 21, 20, 28, 30, 30, 23, 28,\n", + " 30, 30, 28, 27, 28, 28, 2])\n", + "loss= tensor(20.1178, grad_fn=) , base rewards= tensor([4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159,\n", + " 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.8159, 4.0178,\n", + " 3.3426, 2.7475, 2.2110, 1.7192, 1.2610, 0.8262, 0.4072]) return= 171458.06683668698\n", + "probs of actions: tensor([0.0470, 0.2593, 0.0759, 0.0688, 0.0710, 0.0658, 0.0667, 0.3319, 0.3037,\n", + " 0.0801, 0.0649, 0.0467, 0.0246, 0.3009, 0.3288, 0.3135, 0.0220, 0.2825,\n", + " 0.3948, 0.3628, 0.3131, 0.0678, 0.2872, 0.2681, 0.0473],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5378, 0.6530, 0.6720, 0.6571, 0.7080, 0.6996, 0.6538, 0.6981,\n", + " 0.7114, 0.7354, 0.7174, 0.7062, 0.6559, 0.6729, 0.6963, 0.7452, 0.6946,\n", + " 0.6925, 0.7062, 0.7247, 0.7247, 0.7120, 0.7128, 0.7913])\n", + "finalReturns: tensor([1.6880, 1.7409, 1.7215, 1.6242, 1.4545, 1.2216, 0.9551, 0.6779, 0.3841])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 25, 22, 20, 28, 20, 30, 28, 28, 28, 35, 28, 30, 20, 22, 30,\n", + " 28, 28, 28, 30, 27, 30, 0])\n", + "loss= tensor(25.6680, grad_fn=) , base rewards= tensor([5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876,\n", + " 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 5.2876, 4.4790, 3.7990,\n", + " 3.1986, 2.6521, 2.1501, 1.6813, 1.2371, 0.8114, 0.4008]) return= 172405.49027244744\n", + "probs of actions: tensor([0.3832, 0.4014, 0.3750, 0.0089, 0.0426, 0.0203, 0.2878, 0.0189, 0.4120,\n", + " 0.3024, 0.2965, 0.3046, 0.0178, 0.2992, 0.4045, 0.0189, 0.0395, 0.4283,\n", + " 0.2964, 0.3319, 0.2991, 0.4888, 0.0720, 0.4572, 0.6501],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.7064, 0.7189, 0.7134, 0.6595, 0.7247, 0.6535,\n", + " 0.6980, 0.7058, 0.7098, 0.6676, 0.7441, 0.7173, 0.7686, 0.7166, 0.6622,\n", + " 0.7024, 0.7081, 0.7109, 0.7007, 0.7274, 0.7017, 0.8008])\n", + "finalReturns: tensor([1.9119, 1.9519, 1.9153, 1.8534, 1.6975, 1.4915, 1.2494, 0.9929, 0.6912,\n", + " 0.4000])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 28, 30, 28, 28, 27, 30, 28, 28, 30, 28, 30, 30, 19, 30, 30, 21, 25,\n", + " 28, 30, 20, 30, 30, 30, 0])\n", + "loss= tensor(32.1078, grad_fn=) , base rewards= tensor([5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258,\n", + " 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 5.2258, 4.4412, 3.7722,\n", + " 3.1867, 2.6532, 2.1573, 1.6914, 1.2503, 0.8206, 0.4043]) return= 172645.15051400254\n", + "probs of actions: tensor([0.0372, 0.2417, 0.4542, 0.2564, 0.2608, 0.0588, 0.4877, 0.2576, 0.2707,\n", + " 0.5234, 0.2679, 0.4483, 0.4529, 0.0076, 0.4857, 0.4772, 0.0205, 0.0070,\n", + " 0.2501, 0.5249, 0.0046, 0.5703, 0.5679, 0.5416, 0.6514],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5418, 0.6135, 0.6774, 0.6955, 0.7100, 0.6931, 0.7181, 0.7159,\n", + " 0.7032, 0.7232, 0.7068, 0.7134, 0.7706, 0.6697, 0.6946, 0.7532, 0.7013,\n", + " 0.6863, 0.6883, 0.7541, 0.6679, 0.6937, 0.7068, 0.8034])\n", + "finalReturns: tensor([1.9238, 2.0138, 1.9296, 1.8138, 1.6610, 1.4686, 1.1804, 0.9536, 0.6895,\n", + " 0.3991])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 27, 30, 30, 27, 30, 30, 30, 28, 28, 30, 28, 30, 29, 30, 30, 30, 28,\n", + " 28, 30, 23, 28, 30, 28, 1])\n", + "loss= tensor(23.5519, grad_fn=) , base rewards= tensor([5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 5.5706,\n", + " 5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 5.5706, 4.7682, 4.0911, 3.5017,\n", + " 2.9746, 2.4921, 2.0401, 1.6096, 1.1960, 0.7901, 0.3912]) return= 173937.79779327314\n", + "probs of actions: tensor([0.5095, 0.0492, 0.5090, 0.5198, 0.0417, 0.5439, 0.5376, 0.5386, 0.2644,\n", + " 0.2588, 0.5492, 0.2807, 0.5039, 0.0184, 0.5435, 0.5311, 0.5756, 0.2470,\n", + " 0.2346, 0.5822, 0.0068, 0.2665, 0.6153, 0.2230, 0.2690],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5792, 0.6261, 0.6723, 0.7131, 0.6946, 0.7073, 0.7136, 0.7284,\n", + " 0.7210, 0.7058, 0.7245, 0.7075, 0.7196, 0.7124, 0.7162, 0.7181, 0.7306,\n", + " 0.7222, 0.7063, 0.7502, 0.6970, 0.6937, 0.7184, 0.7944])\n", + "finalReturns: tensor([2.3890, 2.4790, 2.4399, 2.3112, 2.1077, 1.8681, 1.6137, 1.2940, 1.0105,\n", + " 0.7227, 0.4031])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 27, 28, 30, 19, 30, 30, 27, 30, 30, 30, 30, 28, 28, 30, 30, 30,\n", + " 32, 22, 30, 30, 30, 30, 0])\n", + "loss= tensor(32.7948, grad_fn=) , base rewards= tensor([5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 5.5584,\n", + " 5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 5.5584, 4.7580, 4.0818, 3.4910,\n", + " 2.9618, 2.4773, 2.0253, 1.5988, 1.1837, 0.7800, 0.3860]) return= 173655.8781758673\n", + "probs of actions: tensor([0.5760, 0.6007, 0.0420, 0.2223, 0.6365, 0.0036, 0.6069, 0.6039, 0.0373,\n", + " 0.6480, 0.6170, 0.5649, 0.5725, 0.2313, 0.2187, 0.5898, 0.6441, 0.6361,\n", + " 0.0007, 0.0148, 0.6816, 0.6923, 0.6811, 0.6625, 0.6277],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6560, 0.6774, 0.6839, 0.7557, 0.6624, 0.6909, 0.7225,\n", + " 0.6993, 0.7096, 0.7148, 0.7174, 0.7303, 0.7220, 0.7062, 0.7131, 0.7165,\n", + " 0.7059, 0.7698, 0.6884, 0.7041, 0.7120, 0.7160, 0.8080])\n", + "finalReturns: tensor([2.4036, 2.4820, 2.4520, 2.3297, 2.1424, 1.9210, 1.6032, 1.3414, 1.0523,\n", + " 0.7440, 0.4220])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAApcklEQVR4nO3df5TddX3n8ecrkwtO7MIMELcwIRtEiGtAEjNCdlk8iG1CZZVIwYTKku3hNJVat1abNqxsg6AlNKVwqCsulRxEKQYQx7iKkT2AeDABJp2EEEuW8MMwE1oiyVCWjDCZvPeP+73hzuT+mjv3zv31epxzD3c+3+/nm8+XTL7v7+e3IgIzM7N8ptS6AGZmVt8cKMzMrCAHCjMzK8iBwszMCnKgMDOzgqbWugCVdtxxx8WsWbNqXQwzs4ayefPmX0XE9FzHmi5QzJo1i97e3loXw8ysoUj6Zb5jbnoyM7OCHCjMzKwgBwozMyvIgcLMzApyoDAzs4KabtSTmVmz6OkbYM2GHeweHOKEjnZWLJrN4nldk16OojUKSWslvSLp6ay0dZK2JJ8XJW1J0mdJGso69vWsPPMlbZO0U9ItkpSkH5lcb6ekxyXNysqzTNKzyWdZJW/czKye9fQNcNX92xgYHCKAgcEhPrduC/Ou/Qk9fQOTWhYVW2Zc0oeA/wfcGRGn5Th+I/BaRFybPOT/d57zngD+BNgE/Ai4JSIekPRHwPsj4tOSlgKfiIglko4BeoFuIIDNwPyI2FeovN3d3eF5FGatq9Jv4Vf3bOPux19iJOtZ2dXRzoffO53vbu5naPjgqPM7p6VY9bE5AFyzfjuDQ8Nl/9nlumzBTL68+PRx5ZG0OSK6cx4rZT+KfAEgqRXsAs6LiGcLnHc88HBEvDf5+VLg3Ij4Q0kbgGsiYqOkqcA/A9OBpZlzkjz/C3gkIu4uVFYHCrPWlXkLHxoeGZXeOS3FBe8/noef2cPuwSGObk8hweD+YU7oaGfWse1sen7fqGDQ6MYbLAoFion2UZwD/EtEPJuVdpKkPuBfgasj4mdAF9CfdU5/kkby35cAIuKApNeAY7PTc+QZRdJyYDnAzJkzJ3hLZlavxtYWPvze6Tz8zB4GBocK5tu3f5hvb9p16Ofst/yBwaGi+RvRtzftGnetIp+JBopLgew3/JeBmRHxqqT5QI+kOYBy5M2E7nzHCuUZnRhxG3AbpGsUJZbdzOpcrmafjIHBoVEPf6uesgNF0kx0ETA/kxYRbwJvJt83S3oOOJV0bWBGVvYZwO7kez9wItCfXPNoYG+Sfu6YPI+UW14zq71CNYI2qamafprJRGoUvwU8ExGHmpQkTQf2RsSIpHcDpwDPR8ReSa9LWgA8DlwO/F2SbT2wDNgIXAw8FBGR9F38laTO5LyFwFUTKK+ZTaJMUMgXBMbWCBwk6lfRQCHpbtJv9sdJ6gdWRcTtpDubx3Ysfwi4VtIBYAT4dETsTY5dCdwBtAMPJB+A24FvSdpJuiaxFCAJLtcBTybnXZt1LTOrM9m1haPbU7w2NHyordhBoLGVNOqpkXjUk9nk6ukbqNkwUCvsxdUXlHxuNUc9mVmDKzTvIFfzUUcytHTffgeGVuFAYdbCxs47GBgc4qr7tx06nn0s03zkmkPrcaAwa2FrNuw4bHLa0PAIn1u3pTYFsrrkQJGol8W3zKol1+/47iacaGaV50BB+h/QF+7dysjBdNV6YHCIL9y7FcDBwppCriYm1xqsVN6PAvji97YdChIZIweDL35vW54cZo3li987fP0js1K5RgG88Vbuf0D50s3qTaGm06t7tvl32SbEgcKsweVrVvrcui10tKc8SskmzIHCrIHkWisp36J54KGsVhkOFGZ1amxQmHVsOz9/bu+hZTG8eqpNFgcKsxrK17eQqzmpGfdMsMbgQFHE1T3bKrb5h1m2XMHgT9dtofeXe3n4mT0epWR1w4GiiLsquEuUtbaxtYf9bx04LBgEuDnJKqKro71i13KgKCJI/wP3xDsr19U927hr065R2zO6GcmqbcWi2RW7lgNFCdZs2OFAYXkVmsPwqb/fyGPPeRsVm3yVfGY5UJTA6+FYPoXmMJjVSiWbncCBoiQd01K1LoLVWL5aQ67VV81qqT3VVtFmJ3CgKEmTbQJo45Sr1rDi3q186QfbvXmP1ZV3HtHGVz5xesWbykvZM3st8J+BVyLitCRtHZAJWR3AYETMTY5dBVxBes/s/xYRG5L0+by9Z/aPgD+JiJB0JHAnMB94FVgSES8meZYBVyd/zpcj4psTu93yvObZrU1r7D7PEgzuHx5Va/jSD7YfVmsYPhgOElY3pgh+76yZVRuhWUqN4g7gq6Qf5gBExJLMd0k3Aq8l398HLAXmACcA/0fSqRExAtwKLAc2kQ4U5wMPkA4q+yLiPZKWAjcASyQdA6wCukkPPtosaX1E7JvQHZfhhAq391l9GDsaKXu5i8xOb72/3OuAYJNmiuDgOFowBHxqQfUCREbRZcYj4lEg57ANSQI+CdydJF0IfCci3oyIF4CdwJmSjgeOioiNERGkg87irDyZmsJ9wEeS6y4CHoyIvUlweJB0cJl0lW7vs9rr6Rs4bMjqWEPDI57TYBXVJgHQ0Z6ic1oKke54vnnJXF5cfUHBZu4XV1/AzUvm0tXRfijfTUvmTso8r4n2UZwD/EtEPJv83EW6xpDRn6QNJ9/HpmfyvAQQEQckvQYcm52eI8+kurd3l4fHNpk1G3YUDBJmlSbgues/WvCcEzrac86xyYxiWjyvqybPooluXHQpb9cmIP3/YqwokF5unlEkLZfUK6l3z549BYpbHo+Dbz4e8myTrZQm7BWLZtOeahuVVo1RTONVdo1C0lTgItKd0Bn9wIlZP88AdifpM3KkZ+fpT655NOmmrn7g3DF5HslVloi4DbgNoLu72y+KLWQ8e5339A1wzfrtXnrbJl2pD/vM726pv9OTZSJNT78FPBMR2U1K64F/kPS3pDuzTwGeiIgRSa9LWgA8DlwO/F1WnmXARuBi4KFkNNQG4K8kdSbnLQSumkB5rcnkW1Tv3t5dvPjq0KiRTO6QtloQjPthX6vmpUJKGR57N+k3++Mk9QOrIuJ20qObspudiIjtku4BfgEcAD6TjHgCuJK3h8c+kHwAbge+JWkn6ZrE0uRaeyVdBzyZnHdtRLgNyA7JNdktGN1U6NqDVUN7qo0PzDyaTc/vy7tpVFdHO4+tPG+SS1YdRQNFRFyaJ/2/5kn/CvCVHOm9wGk50n8NXJLnWmuBtcXKWG3TUhPtyrFqcD+DVUNHe4otqxZy9uqHcnYst0lcf9Hbk9rG1myhPvoVKslPwBIMDR+sdREsB89vsUpLTRHXfHwOkL9j+cZPnjGqaWjxvC6uv+j0UcNWswNJM/ASHiXwWk+Tq1gHdea4l+q2iehK9hx/+Jk9OX/XxtOxXI/9CpXkQFECd4ROnlwd1Ffdvw0g5xahZuUotf+g2QNAqdz0ZHUlVwf10PAIazbsAMi57pJZLmeffAw3L5lbl/MSGo1rFFYzuZqY8nVQDwwOMWvlDye5hNaIunI0EdXbvIRG40BhNZFv6W6zcqWmiDWXnHFYEHDz0cQ5UFhN5GpiGh7PsplmiXImtdn4OFCUqKdvwL+EFeQRS1aq9lQb70hNyTmopJkmtdUzB4oSfSFpFnGwqIw2Ke+MVrOMTH8D0PST2uqZA0WJRg4GazbscKCoEAcJy6dQLcGd0rXhQDEOXjJi4jIjnczyyffvzJ3SteNAMQ5eMmJiPFnOSuF/Z/XHgWIc3B5avp6+Ab5wz1Y3OVlB7neoTw4U4+Bqb3kyNQkHCSukc1qKVR+b439ndciBYhw8RHZ8O8plzndNwoq5bMFMvrz49FoXw/LwWk/j0OqdsJmawcDgEMHbC/b19A3kPP/qnm386botDhJ2SOe0FJctmDlqSe6bl8x1kKhzrlGMQ6uPeiq0YN/YWkVP3wB3bdqFQ4RBevb0TUvmtnyNvFG5RjEOrT4aI1+gzJW+ZsMOB4kWkpqSnkSZz9S2/Mes/jlQjEOrj8bIFygz6T19A5y9+iFOWvlDL9HRQtqmiDWXzOVggSbG4ZFo+abbRlY0UEhaK+kVSU+PSf+spB2Stkv66yRtlqQhSVuSz9ezzp8vaZuknZJukdKvH5KOlLQuSX9c0qysPMskPZt8llXsrsvU6tXmfFtDrlg0+7D+C2sN7zyijRuTFVuL1bhbvem2kZXSR3EH8FXgzkyCpA8DFwLvj4g3Jb0r6/znImJujuvcCiwHNgE/As4HHgCuAPZFxHskLQVuAJZIOgZYBXQDAWyWtD4i9o3vFq1SCm0NefbqhzyRroXk2vNhxaLZBSdUtnrTbSMrGigi4tHst/zElcDqiHgzOeeVQteQdDxwVERsTH6+E1hMOlBcCFyTnHof8NWktrEIeDAi9iZ5HiQdXO4u5caqwcNj8y+j4LfF5tcmcelZJ+YdoZT5vbhm/XYGh0av9OqJdI2t3D6KU4Fzkqain0r6YNaxkyT1JennJGldQH/WOf1JWubYSwARcQB4DTg2Oz1HnlEkLZfUK6l3z549Zd5ScW5jzc9vi82tq6Od567/aNFhrIvndbFl1UJuXjJ31BDY6y86veVfshpZucNjpwKdwALgg8A9kt4NvAzMjIhXJc0HeiTNIT06bqxMU3a+Y4XyjE6MuA24DaC7u7tqTeR+a85vxaLZrLh3qzcfakLl1Aa8gF9zKTdQ9AP3R0QAT0g6CBwXEXuATHPUZknPka599AMzsvLPAHZnXetEoF/SVOBoYG+Sfu6YPI+UWd6KmHZEW/GTWkhP38CoZgYPgGxsbRIHIzi6PYUEg/uHvZy3AeUHih7gPOARSacCRwC/kjQd2BsRI0kN4xTg+YjYK+l1SQuAx4HLgb9LrrUeWAZsBC4GHoqIkLQB+CtJncl5C4GryixvRbzxVnN21uZbliNXOqSb4HINf3VdonG1p9rcPGR5FQ0Uku4m/WZ/nKR+0iOR1gJrkyGzbwHLkof7h4BrJR0ARoBPZzqjSXeA3wG0k+7EfiBJvx34lqSdpGsSSwGS4HId8GRy3rVZ17IKGbv0d2ZZjnt7d/Hz5/YeevgPDA7xuXVbalZOqx4vxmfFlDLq6dI8hy7Lce53ge/muU4vcFqO9F8Dl+TJs5Z0ULIqybcsx2PPOSY3q66Odu8SZ+PitZ5anDvoW0uhbUbN8vESHi3Ow1pbh/AyNFYeB4oWl2tZDmtOgZehsfK46anFjV2WY4rk/SOaVJdrj1Ym1yiMxfO6eGzledy0ZC7hINGUUm1ys5OVzYHCgLeHyR6sdUGsIrInP3ZOS7Hm4jPc7GRlc9PTODXrwoC5hslaY/F8CKsWB4px+uL3tjXlP0RvNNSYOtpTbFm1sNbFsCbnpqdxasZlPHr6BmpdBCtDe6qNaz4+p9bFsBbgGoXxF999qtZFsHHKtXGQWbU4ULS43/7bR3jzgLuw69W01BT2D6f/ftwHYbXiQNHCevoGePaVN2pdDMtBwKcWzCy6UZDZZHAfRQv74ve21boIloeDhNUTB4oW1dM30JQd883i4Weqt6Wv2Xg5ULSoL/1ge62LYAV4VV+rJw4ULWrf/uFaF8EK8Kq+Vk8cKMpw0sofcvbqhxp2/kGjlrsZTUtNIdU2erdxkZ4A2ci/Y9ZcPOqpDMHbW4ZCYy3dfHXPNr69aVeti9GyOtpTvPHWAYZH0osv7h8+SGqK6JyWYt/+YQSjtp9txN8xaz5FaxSS1kp6JdkfOzv9s5J2SNou6a+z0q+StDM5tigrfb6kbcmxWyQpST9S0rok/XFJs7LyLJP0bPJZVpE7rqCh4RHWbNhR62KUrKdvgLscJGqmq6Oddx459VCQyBg+GEw7YipdHe2MXbu30X7HrDmV0vR0B3B+doKkDwMXAu+PiDnA3yTp7wOWAnOSPF+TlNkV51ZgOXBK8slc8wpgX0S8B7gJuCG51jHAKuAs4ExglaTOsu6yihqp03HNhh2HPYhs8uweHMr7+1LsmFktFQ0UEfEosHdM8pXA6oh4MznnlST9QuA7EfFmRLwA7ATOlHQ8cFREbIz0hgd3Aouz8nwz+X4f8JGktrEIeDAi9kbEPuBBxgSsetBInY5+4FTHlKSLQYVP44SO9ry/L8WOmdVSuZ3ZpwLnJE1FP5X0wSS9C3gp67z+JK0r+T42fVSeiDgAvAYcW+BadaM91dZQm8H4gVMdR70jdajZqC3donpY0Mj8ruTaeraUY2a1VG5n9lSgE1gAfBC4R9K7yf1SFQXSKTPPKJKWk27WYubMmQULXikSXH/R6Q3Vybhi0Ww+t25LrYvRdAaHhhkcSg83HomgPdXG787v4uFn9rB7cIgTcizgl9l6drzHzGqh3EDRD9yfNCM9IekgcFySfmLWeTOA3Un6jBzpZOXplzQVOJp0U1c/cO6YPI/kKkxE3AbcBtDd3T0pzfARjTcSpfeXY1sQrRqGhkd4+Jk9PLbyvJzHF8/ryvu7U+iYWa2U2/TUA5wHIOlU4AjgV8B6YGkykukk0p3WT0TEy8DrkhYk/Q+XA99PrrUeyIxouhh4KAlAG4CFkjqTTuyFSVpdULEG6Tp09+MvFT/JKsL9QdZMShkeezewEZgtqV/SFcBa4N3JkNnvAMsibTtwD/AL4MfAZyIis6DQlcA3SHdwPwc8kKTfDhwraSfweWAlQETsBa4Dnkw+1yZpdSEacPjQSCMWuo50dbRz85K5dHW0o+TnzmmpnOe6P8iaSdGmp4i4NM+hy/Kc/xXgKznSe4HTcqT/Grgkz7XWkg5KZjWVatOh/oLspqGevgGuun/bqP3G3QFtzcYzs82KKLRhUCbNHdDWzBwoWoTXDBq/9lRbSSPb3AFtzc6Boon19A0cetOd0oi975OsPTWFY955pGsGZmM4UExAT99AzR8k2cEg++E2tu3cHdnFXX/R+2v+92lWjxwoJmDNhh01fbCMDQbZq42u2bBjVAerFTYtNcVBwiwPB4oJGKjxWPlcwWBoeMSzr8swNHyw1kUwq1veuGgCat3q70ldleN5D2b5OVBMQFDb0UR+uFWG5z2YFeZAMUFX3f9Uzf7sXKuNWm5tEjcvmcuLqy84bHZ1oy3uaDbZ3EcxQUPDB2s2+il7slet+0vqWapNrLn4jEP/vzzvwWx8XKOogFptVdnTN8A167c7SBQgMSpImNn4uUZRAZPdqXx1zzbu2rSrpG1NRZ5NPFpAqTOrzawwB4oKOLo99wqi1XB1zza+vWlXyee3apDo8sxqs4pxoKiAN946MGn9FN5TorDOaSn6/nJhrYth1lTcR1EBwyMxaf0UXoqjsFUfm1PrIpg1HQcK4LIFE99ne7L6KabUepZfnXNTk1nlOVAAP3zq5QlfYzImv/X0DXDQFYq8ujwB0awqHCiAffuHJ5R/Mmb29vQNsOLerVX9MxqZwLOrzarEndkV8LvzqzeBK7OMuOdKvK091TZqMUQBn1ow081OZlVStEYhaa2kVyQ9nZV2jaQBSVuSz0eT9FmShrLSv56VZ76kbZJ2SrpFSu+kI+lISeuS9MclzcrKs0zSs8lnWUXvPPseJ5i/Ek1XuWSWEXeQeFtmyY3sJThuWjKXLy8+vdZFM2tapdQo7gC+Ctw5Jv2miPibHOc/FxFzc6TfCiwHNgE/As4HHgCuAPZFxHskLQVuAJZIOgZYBXSTng6wWdL6iNhXQpnHZaLN/hNtusrHe0qMlmni8xIcZpOraI0iIh4F9k7kD5F0PHBURGyMiCAddBYnhy8Evpl8vw/4SFLbWAQ8GBF7k+DwIOngUnGd0yY+Ye7qnm0VKMloXkb8bV68z6x2JtKZ/ceSnkqapjqz0k+S1Cfpp5LOSdK6gP6sc/qTtMyxlwAi4gDwGnBsdnqOPKNIWi6pV1Lvnj17xn0jlZiacNc4ZkuXysuIv+2xlec5SJjVSLmB4lbgZGAu8DJwY5L+MjAzIuYBnwf+QdJR5O4GyDye8x0rlGd0YsRtEdEdEd3Tp08v+SYyXhuaeNNRNUatTjvCg9IgvUS4mdVOWU+iiPiXiBiJiIPA3wNnJulvRsSryffNwHPAqaRrAzOyLjED2J187wdOBJA0FTiadFPXofQceSqqUm/ulWx+6ukb4NlX3qjY9RqZZ6Ob1VZZgSLpc8j4BPB0kj5dUlvy/d3AKcDzEfEy8LqkBUn/w+XA95P864HMiKaLgYeSfowNwEJJnUnT1sIkreIqNf7+rk27Krbj3TXrt1fkOs3AE+nMaquU4bF3AxuB2ZL6JV0B/HUy1PUp4MPAnyanfwh4StJW0h3Tn46ITEf4lcA3gJ2kaxoPJOm3A8dK2km6uWolQJLvOuDJ5HNt1rUqqlJt3wF8bt0Wzl790IQDxmAFmsOagSfSmdWeosmq9d3d3dHb2zvufLNW/rCi5ShnL4TM5Lrdg0Mtuzx4tsxEOs+RMKs+SZsjojvXMfeWVsnQ8Mi4VpTNnlzXykEis+ihJ9KZ1Q8v4VFF45kH0cqT6wS8sPqCWhfDzPJwjaKKxjOaqpUn1wVUpF/HzKrDgSIxLVXZ/xXjXVG21SfXDQwOcdX92xwszOqQA0Xiovkzip9UonKWm1ixaDapFt+VaLz9OmY2ORwoEg8/M/6lP/IpZ7mJxfO6+I13uMuolZvgzOqVA0WiHh5Qg1VahbYe5as8tXoTnFk9cqBIVPIBNe/an5TV1t5e4X6SevZ7Z82kPdU2Km0ydgo0s/FrnSdTEZV8QO3bP8zn1m0ZV8Do6Rtg//DBipWhnl2WTKIbuwGRlxE3q0+emZ2l0rOzofQZ2mevfqgldrI7++RjuOsP/kOti2FmY3hmdg2VOpKnHvpIJoODhFnjcaCYBKXUFDoqsMuemVk1OFBMglI23mmyFsCcWqiv3qyp+J9ulrYqzXcrZeOdVlhWfMmZM2tdBDMrgwNFloNVeqsvNuy1VZatqOSkRjObPA4UWao12Wto+GDeYNDTN8CK+7ZW5c+tN63SYW/WbBwoslRzsle+kU9f+sF2hkdaoIMCz7o2a1QOFFmqOdkr39v0vhZZtsNbmpo1rlL2zF4r6RVJT2elXSNpQNKW5PPRrGNXSdopaYekRVnp85N9tndKukVKDwWSdKSkdUn645JmZeVZJunZ5LOsYnddA9LhfRGt0jcB6S1NPevarDGVUqO4Azg/R/pNETE3+fwIQNL7gKXAnCTP1yRlFvS5FVgOnJJ8Mte8AtgXEe8BbgJuSK51DLAKOAs4E1glqXPcd1gnDgaH7bfQCktqd05LcbO3NDVraEXXtY6IR7Pf8ou4EPhORLwJvCBpJ3CmpBeBoyJiI4CkO4HFwANJnmuS/PcBX01qG4uAByNib5LnQdLB5e4Sy1J3MrO0M2/Wzdy5+6K3NjVrGhPpo/hjSU8lTVOZN/0u4KWsc/qTtK7k+9j0UXki4gDwGnBsgWsdRtJySb2Sevfsqe8hmNmztJu1c/edR7Rx0sofentTsyZRbqC4FTgZmAu8DNyYpOeashYF0svNMzox4raI6I6I7unTpxcodn2Y+6Wf8L7/8UDTLgL4xlsjBN7e1KxZlBUoIuJfImIkIg4Cf0+6DwHSb/0nZp06A9idpM/IkT4qj6SpwNHA3gLXaniDQ8Mts6S4tzc1a3xlBQpJx2f9+AkgMyJqPbA0Gcl0EulO6yci4mXgdUkLkv6Hy4HvZ+XJjGi6GHgo0mufbwAWSupMmrYWJmlVNc0LElVcM/fFmLWCop3Zku4GzgWOk9RPeiTSuZLmkm4KehH4Q4CI2C7pHuAXwAHgMxExklzqStIjqNpJd2I/kKTfDnwr6fjeS3rUFBGxV9J1wJPJeddmOrar6aL5M/j2pl3V/mOaTpvEO1JTeOOtkcOONWtfjFmr8MZFY7TKBkKVMHZTpp6+Aa66fxtDwyN5zzGz+lRo46KiNYpW42aS0nROS7HqY3NGBYDM9zUbdrB7cIgTOtpZsWi2g4RZg3OgGOOEjnbXKApok7jxk2fkffgvntflwGDWZNxzO4bXI8qvPdVWMEiYWXNyoBjDD8H83Ndg1pocKMbw5LDcujraHSTMWpQDxRieHHa49lSbm+TMWpgDxRge9ZTWOS2FSNck3ORk1to86mkMj3pKB4fHVp5X62KYWZ1wjWKMVm9icTOTmY3lQDHG4nlddE5L1boYNeFmJjPLxYEih1Ufm1PrItTEYyvPc5Aws8M4UOTgh6WZ2dscKMzMrCAHCjvEkw3NLBcHCjvEkw3NLBcHCjvEkw3NLBcHijy6WnBXNu9EZ2a5OFDk0WqTzjzRzszycaDIo5WGyHqinZkVUjRQSFor6RVJT+c49meSQtJxyc+zJA1J2pJ8vp517nxJ2yTtlHSLJCXpR0pal6Q/LmlWVp5lkp5NPssqcsc2ys1L5nqinZkVVEqN4g7g/LGJkk4EfhvYNebQcxExN/l8Oiv9VmA5cEryyVzzCmBfRLwHuAm4Ibn+McAq4CzgTGCVpM4S78tK5JFOZlZM0UAREY8Ce3Mcugn4cyCKXUPS8cBREbExIgK4E1icHL4Q+Gby/T7gI0ltYxHwYETsjYh9wIPkCFjV9M4j2ibzj6sJj3Qys2LK6qOQ9HFgICK25jh8kqQ+ST+VdE6S1gX0Z53Tn6Rljr0EEBEHgNeAY7PTc+QZW57lknol9e7Zs6ecW8op1db8XTge6WRmxYx7PwpJ04AvAgtzHH4ZmBkRr0qaD/RImgMox7mZmki+Y4XyjE6MuA24DaC7u7toDadUrw0NV+pSdcsjncysmHJemU8GTgK2SnoRmAH8o6TfjIg3I+JVgIjYDDwHnEq6NjAj6xozgN3J937gRABJU4GjSTd1HUrPkWdSNPvbdntqijuxzayocQeKiNgWEe+KiFkRMYv0A/0DEfHPkqZLagOQ9G7SndbPR8TLwOuSFiT9D5cD308uuR7IjGi6GHgo6cfYACyU1Jl0Yi9M0iZNs79tHzgYXt/JzIoqZXjs3cBGYLakfklXFDj9Q8BTkraS7pj+dERkOsKvBL4B7CRd03ggSb8dOFbSTuDzwEqAJN91wJPJ59qsa02KZn/bHh4Jj3oys6KK9lFExKVFjs/K+v5d4Lt5zusFTsuR/mvgkjx51gJri5WxmrqafA9tj3oys2Kaf1jPBDV781Oz98OY2cQ5UBSxeF5X086n8PpOZlYKB4oSNON8is5pKa/vZGYlab4nYBUMNuF8il8PH6x1EcysQThQFNHTN5Bz5l+jGxoe8YgnMyuJA0URazbsKL6YVYPyiCczK4UDRRHN/DD1iCczK4UDRRHN8DBNTRGpttENaB7xZGalcqAoYsWi2aSmNFYvRWqK6JyWQqQnDK655AzWXHwGXR3th9I84snMSjXu1WNbzeJ5XXzpB9vZt79+Rz5NS03hyFQbg/uHOaGjnRWLZucMAg4MZlYOB4oSDNZpkGiTuPGTZzgAmFlVuempBPXYTyFwkDCzSeFAUYIVi2bTnqqvZTw+tWCmg4SZTQo3PZUg80Bes2EHA4NDiBI2Cq+ijvYUX158eg1LYGatxDWKEi2e18VjK8+jq6O9pkGiPdXGNR+fU8MSmFmrcY1inGoxAW+K4GCkh7XmG9FkZlYtDhTjdEINNjJ6/voLJvXPMzPL5qancZrsju2uOhxxZWatpZQ9s9dKekXS0zmO/ZmkkHRcVtpVknZK2iFpUVb6fEnbkmO3SFKSfqSkdUn645JmZeVZJunZ5LNswndbAYvndXH9RacfmuVcbV5mw8xqrZQaxR3A+WMTJZ0I/DawKyvtfcBSYE6S52uSMq/ftwLLgVOST+aaVwD7IuI9wE3ADcm1jgFWAWcBZwKrJHWO7/aqI9Ox/cLqC6r6xn+Zh8CaWR0oGigi4lFgb45DNwF/zuiRohcC34mINyPiBWAncKak44GjImJjRARwJ7A4K883k+/3AR9JahuLgAcjYm9E7AMeJEfAqrVqvfFftmCmh8CaWV0oq49C0seBgYjYOuZQF/BS1s/9SVpX8n1s+qg8EXEAeA04tsC1cpVnuaReSb179uwp55bKtnheF53TUhW9poOEmdWTcQcKSdOALwJ/metwjrQokF5untGJEbdFRHdEdE+fPj3XKVW16mNzKtLBfeTUKdy8ZK6DhJnVlXJqFCcDJwFbJb0IzAD+UdJvkn7rPzHr3BnA7iR9Ro50svNImgocTbqpK9+16k52B3e5Um3iht99v/skzKzujDtQRMS2iHhXRMyKiFmkH+gfiIh/BtYDS5ORTCeR7rR+IiJeBl6XtCDpf7gc+H5yyfVAZkTTxcBDST/GBmChpM6kE3thklaXsmdul2N4JLyHtZnVpVKGx94NbARmS+qXdEW+cyNiO3AP8Avgx8BnImIkOXwl8A3SHdzPAQ8k6bcDx0raCXweWJlcay9wHfBk8rk2SatrE5ln0czbrppZ41L65b15dHd3R29vb03L0NM3wJoNO9g9ODSumdxdHe08tvK8KpfOzOxwkjZHRHeuY17CowoWz+sa1dcw79qfFN0hz3tYm1m98hIek2DVx+aQahs9iGuKGLWvtfewNrN65RrFJMjezyLTHOVVYM2sUThQTJKxzVFmZo3CTU9mZlaQA4WZmRXkQGFmZgU5UJiZWUEOFGZmVlDTzcyWtAf45QQucRzwqwoVp9743hpXM9+f760+/LuIyLn8dtMFiomS1JtvGnuj8701rma+P99b/XPTk5mZFeRAYWZmBTlQHO62WheginxvjauZ78/3VufcR2FmZgW5RmFmZgU5UJiZWUEtGSgknS9ph6SdklbmOC5JtyTHn5L0gVqUs1wl3N+nkvt6StLPJZ1Ri3KWo9i9ZZ33QUkjki6ezPJNRCn3JulcSVskbZf008ku40SU8Ht5tKQfSNqa3N/v16Kc4yVpraRXJD2d53hDP08AiIiW+gBtpPfsfjdwBLAVeN+Ycz5Kek9vAQuAx2td7grf338EOpPvv9Mo91fKvWWd9xDwI+DiWpe7gn9vHaT3o5+Z/PyuWpe7wvf334Ebku/Tgb3AEbUuewn39iHgA8DTeY437PMk82nFGsWZwM6IeD4i3gK+A1w45pwLgTsjbRPQIen4yS5omYreX0T8PCL2JT9uAmZMchnLVcrfHcBnge8Cr0xm4SaolHv7PeD+iNgFEBHNdn8B/BtJAn6DdKA4MLnFHL+IeJR0WfNp5OcJ0JpNT13AS1k/9ydp4z2nXo237FeQfttpBEXvTVIX8Ang65NYrkoo5e/tVKBT0iOSNku6fNJKN3Gl3N9XgX8P7Aa2AX8SEQcnp3hV1cjPE6A1d7hTjrSxY4RLOadelVx2SR8mHSj+U1VLVDml3NvNwF9ExEj6xbRhlHJvU4H5wEeAdmCjpE0R8X+rXbgKKOX+FgFbgPOAk4EHJf0sIv61ymWrtkZ+ngCtGSj6gROzfp5B+g1mvOfUq5LKLun9wDeA34mIVyepbBNVyr11A99JgsRxwEclHYiInkkpYflK/b38VUS8Abwh6VHgDKARAkUp9/f7wOpIN+zvlPQC8F7gickpYtU08vMEaM2mpyeBUySdJOkIYCmwfsw564HLk9EKC4DXIuLlyS5omYren6SZwP3Af2mQt9GMovcWESdFxKyImAXcB/xRAwQJKO338vvAOZKmSpoGnAX80ySXs1yl3N8u0rUlJP1bYDbw/KSWsjoa+XkCtGCNIiIOSPpjYAPpkRhrI2K7pE8nx79OerTMR4GdwH7SbzoNocT7+0vgWOBryZv3gWiAFS5LvLeGVMq9RcQ/Sfox8BRwEPhGROQckllvSvy7uw64Q9I20s01fxERdb9Et6S7gXOB4yT1A6uAFDT+8yTDS3iYmVlBrdj0ZGZm4+BAYWZmBTlQmJlZQQ4UZmZWkAOFmVmDK7YwYY7zPynpF8nii/9Q9HyPejIza2ySPgT8P9JrSp1W5NxTgHuA8yJin6R3FVs3zDUKM7MGl2thQkknS/pxsi7YzyS9Nzn0B8D/zCwMWsrikg4UZmbN6TbgsxExH/gz4GtJ+qnAqZIek7RJ0vnFLtRyM7PNzJqdpN8gve/MvVmLYx6Z/HcqcArp2eQzgJ9JOi0iBvNdz4HCzKz5TAEGI2JujmP9wKaIGAZekLSDdOB4stDFzMysiSRLs78g6RI4tB1rZsvjHuDDSfpxpJuiCi6+6EBhZtbgkoUJNwKzJfVLugL4FHCFpK3Adt7eUXAD8KqkXwAPAyuKbTXg4bFmZlaQaxRmZlaQA4WZmRXkQGFmZgU5UJiZWUEOFGZmVpADhZmZFeRAYWZmBf1/oxzenFhef8QAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 22, 30, 27, 30, 30, 30, 30, 28, 27, 30, 31, 28, 30, 30, 19, 28,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(30.0299, grad_fn=) , base rewards= tensor([5.9985, 5.9985, 5.9985, 5.9985, 5.9985, 5.9985, 5.9985, 5.9985, 5.9985,\n", + " 5.9985, 5.9985, 5.9985, 5.9985, 5.9985, 5.1887, 4.5081, 3.9152, 3.3851,\n", + " 2.9001, 2.4386, 1.9973, 1.5741, 1.1656, 0.7688, 0.3810]) return= 173619.98811464538\n", + "probs of actions: tensor([0.6114, 0.6354, 0.0283, 0.6261, 0.0316, 0.6471, 0.6391, 0.6426, 0.6508,\n", + " 0.1993, 0.0354, 0.6022, 0.0056, 0.2172, 0.6499, 0.6220, 0.0022, 0.1846,\n", + " 0.7279, 0.6904, 0.7233, 0.7299, 0.7137, 0.6972, 0.2871],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6805, 0.6442, 0.6988, 0.6874, 0.7036, 0.7118, 0.7159,\n", + " 0.7295, 0.7271, 0.7016, 0.7047, 0.7315, 0.7110, 0.7155, 0.7716, 0.6818,\n", + " 0.6860, 0.7029, 0.7114, 0.7157, 0.7179, 0.7189, 0.8094])\n", + "finalReturns: tensor([2.6751, 2.7535, 2.7231, 2.6005, 2.3590, 2.1622, 1.9376, 1.6760, 1.3878,\n", + " 1.0805, 0.7595, 0.4284])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 28, 28, 30, 20, 30, 24, 28, 30, 28, 30, 30,\n", + " 30, 30, 30, 30, 28, 21, 0])\n", + "loss= tensor(19.9486, grad_fn=) , base rewards= tensor([5.8726, 5.8726, 5.8726, 5.8726, 5.8726, 5.8726, 5.8726, 5.8726, 5.8726,\n", + " 5.8726, 5.8726, 5.8726, 5.8726, 5.8726, 5.1013, 4.4385, 3.8539, 3.3277,\n", + " 2.8429, 2.3895, 1.9597, 1.5476, 1.1487, 0.7596, 0.3778]) return= 173885.61811949068\n", + "probs of actions: tensor([0.6582, 0.6814, 0.6625, 0.6710, 0.7155, 0.6934, 0.6872, 0.1775, 0.1842,\n", + " 0.7284, 0.0035, 0.6533, 0.0037, 0.1936, 0.6918, 0.1918, 0.7303, 0.7204,\n", + " 0.7692, 0.7447, 0.7717, 0.7717, 0.1512, 0.0070, 0.7013],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7290, 0.7213,\n", + " 0.7059, 0.7629, 0.6722, 0.7283, 0.6929, 0.6917, 0.7174, 0.7039, 0.7119,\n", + " 0.7160, 0.7180, 0.7190, 0.7195, 0.7313, 0.7568, 0.7656])\n", + "finalReturns: tensor([2.7714, 2.8498, 2.8209, 2.6881, 2.5104, 2.2833, 2.0207, 1.7325, 1.4256,\n", + " 1.1050, 0.7628, 0.3877])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 30, 30, 30, 30, 30, 28, 22, 30, 21, 30, 22, 30, 30, 27, 30, 28, 32,\n", + " 30, 28, 30, 28, 30, 30, 0])\n", + "loss= tensor(47.7502, grad_fn=) , base rewards= tensor([6.2299, 6.2299, 6.2299, 6.2299, 6.2299, 6.2299, 6.2299, 6.2299, 6.2299,\n", + " 6.2299, 6.2299, 6.2299, 6.2299, 5.4679, 4.8094, 4.2288, 3.7058, 3.2226,\n", + " 2.7701, 2.3392, 1.9270, 1.5283, 1.1380, 0.7547, 0.3754]) return= 173444.481526588\n", + "probs of actions: tensor([1.5417e-01, 7.3112e-01, 7.1352e-01, 7.2127e-01, 7.6316e-01, 7.4294e-01,\n", + " 1.4994e-01, 1.5544e-02, 7.4822e-01, 6.7025e-03, 7.5187e-01, 1.9892e-02,\n", + " 7.2069e-01, 7.2700e-01, 3.1470e-02, 7.2279e-01, 1.2746e-01, 5.6664e-04,\n", + " 8.1453e-01, 1.3124e-01, 8.1841e-01, 1.2749e-01, 7.9660e-01, 7.8469e-01,\n", + " 6.5443e-01], grad_fn=)\n", + "rewards: tensor([0.4328, 0.5540, 0.6346, 0.6767, 0.6982, 0.7091, 0.7261, 0.7499, 0.6787,\n", + " 0.7451, 0.6698, 0.7363, 0.6720, 0.6958, 0.7250, 0.7005, 0.7218, 0.6938,\n", + " 0.7221, 0.7326, 0.7115, 0.7274, 0.7089, 0.7144, 0.8072])\n", + "finalReturns: tensor([3.1032, 3.1932, 3.1558, 3.0115, 2.8339, 2.5953, 2.3540, 2.0629, 1.7425,\n", + " 1.4296, 1.0925, 0.7670, 0.4318])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 29, 30, 30, 30, 28, 30, 28, 20, 30, 30, 30, 30, 30, 33,\n", + " 30, 30, 28, 30, 30, 30, 0])\n", + "loss= tensor(22.1335, grad_fn=) , base rewards= tensor([6.1892, 6.1892, 6.1892, 6.1892, 6.1892, 6.1892, 6.1892, 6.1892, 6.1892,\n", + " 6.1892, 6.1892, 6.1892, 6.1892, 5.4291, 4.7715, 4.1914, 3.6686, 3.1881,\n", + " 2.7388, 2.3124, 1.9055, 1.5116, 1.1269, 0.7472, 0.3718]) return= 174176.32268193088\n", + "probs of actions: tensor([0.7532, 0.7736, 0.7590, 0.7660, 0.0079, 0.7853, 0.7796, 0.7825, 0.1267,\n", + " 0.8185, 0.1237, 0.0026, 0.7690, 0.7773, 0.7830, 0.7635, 0.8259, 0.0089,\n", + " 0.8517, 0.8362, 0.0964, 0.8537, 0.8324, 0.8226, 0.6290],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.7052, 0.7052, 0.7126, 0.7163, 0.7297,\n", + " 0.7101, 0.7266, 0.7586, 0.6701, 0.6948, 0.7074, 0.7137, 0.7168, 0.6995,\n", + " 0.7328, 0.7264, 0.7348, 0.7126, 0.7163, 0.7181, 0.8091])\n", + "finalReturns: tensor([3.1631, 3.2531, 3.2159, 3.0887, 2.8978, 2.6614, 2.4112, 2.1048, 1.7854,\n", + " 1.4445, 1.1166, 0.7800, 0.4373])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 28, 30, 30, 30, 30, 28, 28, 30, 30, 30, 30, 30, 28, 30, 30, 30, 30,\n", + " 30, 27, 30, 30, 30, 30, 0])\n", + "loss= tensor(22.2392, grad_fn=) , base rewards= tensor([6.6786, 6.6786, 6.6786, 6.6786, 6.6786, 6.6786, 6.6786, 6.6786, 6.6786,\n", + " 6.6786, 6.6786, 6.6786, 5.8705, 5.1907, 4.6001, 4.0724, 3.5879, 3.1353,\n", + " 2.7065, 2.2952, 1.8969, 1.5084, 1.1248, 0.7459, 0.3713]) return= 174358.79722511506\n", + "probs of actions: tensor([0.7562, 0.1252, 0.7619, 0.7682, 0.8044, 0.7865, 0.1327, 0.1273, 0.7909,\n", + " 0.8182, 0.7949, 0.7539, 0.7718, 0.1322, 0.7762, 0.7657, 0.8278, 0.8171,\n", + " 0.8564, 0.0138, 0.8538, 0.8517, 0.8330, 0.8278, 0.7300],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5737, 0.6304, 0.6745, 0.6971, 0.7085, 0.7258, 0.7198, 0.7051,\n", + " 0.7125, 0.7163, 0.7181, 0.7191, 0.7311, 0.7108, 0.7154, 0.7177, 0.7188,\n", + " 0.7194, 0.7368, 0.7064, 0.7132, 0.7166, 0.7183, 0.8091])\n", + "finalReturns: tensor([3.4723, 3.5623, 3.5230, 3.3825, 3.1994, 2.9686, 2.7034, 2.4134, 2.1053,\n", + " 1.7667, 1.4488, 1.1193, 0.7815, 0.4379])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 18, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 28, 30, 30,\n", + " 30, 30, 30, 30, 28, 30, 0])\n", + "loss= tensor(14.6218, grad_fn=) , base rewards= tensor([6.6716, 6.6716, 6.6716, 6.6716, 6.6716, 6.6716, 6.6716, 6.6716, 6.6716,\n", + " 6.6716, 6.6716, 6.6716, 5.8619, 5.1815, 4.5906, 4.0627, 3.5798, 3.1293,\n", + " 2.7008, 2.2891, 1.8903, 1.5012, 1.1193, 0.7430, 0.3707]) return= 174098.21181278626\n", + "probs of actions: tensor([8.2251e-01, 4.7674e-04, 8.3021e-01, 9.6048e-02, 8.6199e-01, 8.4819e-01,\n", + " 8.4462e-01, 8.4719e-01, 8.5265e-01, 8.7677e-01, 8.5720e-01, 8.2959e-01,\n", + " 8.4695e-01, 8.5319e-01, 8.4007e-01, 9.9248e-02, 8.7930e-01, 8.7517e-01,\n", + " 9.0522e-01, 8.9492e-01, 9.0184e-01, 9.0348e-01, 7.0153e-02, 8.8183e-01,\n", + " 7.3780e-01], grad_fn=)\n", + "rewards: tensor([0.4212, 0.6197, 0.5886, 0.6644, 0.6773, 0.6985, 0.7092, 0.7146, 0.7173,\n", + " 0.7186, 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7316, 0.7110, 0.7155,\n", + " 0.7177, 0.7189, 0.7194, 0.7197, 0.7315, 0.7110, 0.8055])\n", + "finalReturns: tensor([3.4895, 3.5795, 3.5402, 3.4112, 3.2191, 2.9704, 2.7099, 2.4229, 2.1168,\n", + " 1.7968, 1.4664, 1.1286, 0.7735, 0.4348])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(23.6086, grad_fn=) , base rewards= tensor([7.0213, 7.0213, 7.0213, 7.0213, 7.0213, 7.0213, 7.0213, 7.0213, 7.0213,\n", + " 7.0213, 7.0213, 6.2116, 5.5311, 4.9402, 4.4124, 3.9295, 3.4790, 3.0521,\n", + " 2.6424, 2.2455, 1.8587, 1.4791, 1.1047, 0.7339, 0.3660]) return= 174723.71368801882\n", + "probs of actions: tensor([8.7383e-01, 8.8741e-01, 8.7980e-01, 8.8511e-01, 9.0658e-01, 8.9661e-01,\n", + " 8.9365e-01, 8.9439e-01, 8.9941e-01, 9.1905e-01, 9.0974e-01, 8.8482e-01,\n", + " 8.9987e-01, 9.0173e-01, 8.9741e-01, 8.8340e-01, 9.1838e-01, 9.1274e-04,\n", + " 9.3720e-01, 9.3060e-01, 9.3637e-01, 9.3907e-01, 9.2169e-01, 9.1801e-01,\n", + " 2.6735e-01], grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7139,\n", + " 0.7245, 0.7223, 0.7211, 0.7206, 0.7203, 0.7201, 0.8100])\n", + "finalReturns: tensor([3.8708, 3.9608, 3.9214, 3.7924, 3.6003, 3.3632, 3.0937, 2.8007, 2.4964,\n", + " 2.1689, 1.8334, 1.4918, 1.1457, 0.7962, 0.4440])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(3.1150, grad_fn=) , base rewards= tensor([7.0258, 7.0258, 7.0258, 7.0258, 7.0258, 7.0258, 7.0258, 7.0258, 7.0258,\n", + " 7.0258, 7.0258, 6.2162, 5.5357, 4.9448, 4.4169, 3.9340, 3.4835, 3.0566,\n", + " 2.6469, 2.2500, 1.8625, 1.4819, 1.1065, 0.7350, 0.3664]) return= 174695.3335318168\n", + "probs of actions: tensor([0.9078, 0.9183, 0.9131, 0.9170, 0.9331, 0.9256, 0.9238, 0.9241, 0.9280,\n", + " 0.9434, 0.9388, 0.9182, 0.9303, 0.9293, 0.9268, 0.9198, 0.9448, 0.9383,\n", + " 0.9573, 0.9533, 0.9565, 0.9576, 0.9456, 0.9438, 0.2588],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8099])\n", + "finalReturns: tensor([3.8634, 3.9534, 3.9141, 3.7850, 3.5929, 3.3559, 3.0864, 2.7933, 2.4830,\n", + " 2.1599, 1.8274, 1.4880, 1.1434, 0.7949, 0.4435])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(2.4732, grad_fn=) , base rewards= tensor([7.3900, 7.3900, 7.3900, 7.3900, 7.3900, 7.3900, 7.3900, 7.3900, 7.3900,\n", + " 7.3900, 6.5807, 5.9004, 5.3095, 4.7817, 4.2988, 3.8483, 3.4214, 3.0118,\n", + " 2.6148, 2.2273, 1.8467, 1.4714, 1.0999, 0.7313, 0.3648]) return= 174645.0002092123\n", + "probs of actions: tensor([0.0417, 0.9328, 0.9281, 0.9315, 0.9452, 0.9390, 0.9374, 0.9377, 0.9409,\n", + " 0.9544, 0.9496, 0.9354, 0.9467, 0.9436, 0.9422, 0.9339, 0.9559, 0.9507,\n", + " 0.9662, 0.9625, 0.9652, 0.9647, 0.9544, 0.9538, 0.6521],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5540, 0.6346, 0.6767, 0.6982, 0.7091, 0.7145, 0.7173, 0.7186,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([4.2186, 4.3086, 4.2693, 4.1403, 3.9482, 3.7111, 3.4416, 3.1486, 2.8382,\n", + " 2.5152, 2.1827, 1.8433, 1.4986, 1.1501, 0.7987, 0.4452])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 29, 30, 30, 30, 30, 28, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(40.8628, grad_fn=) , base rewards= tensor([7.4077, 7.4077, 7.4077, 7.4077, 7.4077, 7.4077, 7.4077, 7.4077, 7.4077,\n", + " 7.4077, 6.5983, 5.9180, 5.3262, 4.7973, 4.3133, 3.8620, 3.4344, 3.0226,\n", + " 2.6233, 2.2336, 1.8513, 1.4745, 1.1019, 0.7324, 0.3653]) return= 174600.9519396913\n", + "probs of actions: tensor([0.9171, 0.9265, 0.9217, 0.9254, 0.9396, 0.9327, 0.9312, 0.9317, 0.9345,\n", + " 0.0018, 0.9430, 0.9318, 0.9380, 0.9392, 0.0408, 0.9294, 0.9512, 0.9464,\n", + " 0.9615, 0.9566, 0.9614, 0.9597, 0.9493, 0.9495, 0.3406],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7252, 0.7152, 0.7176, 0.7188, 0.7194, 0.7313, 0.7109, 0.7154, 0.7177,\n", + " 0.7189, 0.7194, 0.7197, 0.7199, 0.7199, 0.7200, 0.8099])\n", + "finalReturns: tensor([4.1915, 4.2756, 4.2407, 4.1149, 3.9251, 3.6896, 3.4096, 3.1264, 2.8227,\n", + " 2.5043, 2.1751, 1.8381, 1.4951, 1.1479, 0.7974, 0.4446])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(2.7005, grad_fn=) , base rewards= tensor([7.7525, 7.7525, 7.7525, 7.7525, 7.7525, 7.7525, 7.7525, 7.7525, 7.7525,\n", + " 6.9438, 6.2637, 5.6730, 5.1453, 4.6624, 4.2119, 3.7850, 3.3754, 2.9784,\n", + " 2.5909, 2.2103, 1.8350, 1.4635, 1.0949, 0.7284, 0.3636]) return= 174695.3335318168\n", + "probs of actions: tensor([0.9365, 0.9441, 0.9405, 0.9434, 0.9547, 0.9491, 0.9482, 0.9484, 0.9508,\n", + " 0.9651, 0.9591, 0.9506, 0.9534, 0.9552, 0.9493, 0.9475, 0.9657, 0.9627,\n", + " 0.9719, 0.9699, 0.9722, 0.9702, 0.9619, 0.9641, 0.2772],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8099])\n", + "finalReturns: tensor([4.5748, 4.6648, 4.6255, 4.4966, 4.3045, 4.0674, 3.7979, 3.5048, 3.1945,\n", + " 2.8715, 2.5390, 2.1995, 1.8549, 1.5064, 1.1550, 0.8015, 0.4463])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 28, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(15.3826, grad_fn=) , base rewards= tensor([7.7629, 7.7629, 7.7629, 7.7629, 7.7629, 7.7629, 7.7629, 7.7629, 7.7629,\n", + " 6.9542, 6.2742, 5.6835, 5.1557, 4.6728, 4.2224, 3.7955, 3.3858, 2.9889,\n", + " 2.5998, 2.2173, 1.8401, 1.4671, 1.0972, 0.7298, 0.3642]) return= 174633.0188027606\n", + "probs of actions: tensor([0.9580, 0.9633, 0.9611, 0.9630, 0.9710, 0.9672, 0.9667, 0.9667, 0.9694,\n", + " 0.9792, 0.9754, 0.9684, 0.9722, 0.9720, 0.9672, 0.0179, 0.9786, 0.9763,\n", + " 0.9840, 0.9822, 0.9834, 0.9815, 0.9763, 0.9775, 0.6772],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7316, 0.7110, 0.7155,\n", + " 0.7178, 0.7189, 0.7194, 0.7197, 0.7199, 0.7199, 0.8100])\n", + "finalReturns: tensor([4.5582, 4.6482, 4.6089, 4.4799, 4.2878, 4.0507, 3.7813, 3.4882, 3.1662,\n", + " 2.8522, 2.5258, 2.1905, 1.8488, 1.5024, 1.1525, 0.8001, 0.4458])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(1.5091, grad_fn=) , base rewards= tensor([8.1127, 8.1127, 8.1127, 8.1127, 8.1127, 8.1127, 8.1127, 8.1127, 7.3053,\n", + " 6.6259, 6.0355, 5.5079, 5.0251, 4.5746, 4.1477, 3.7381, 3.3411, 2.9536,\n", + " 2.5731, 2.1977, 1.8262, 1.4576, 1.0912, 0.7263, 0.3627]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9611, 0.9659, 0.9640, 0.9657, 0.9732, 0.9696, 0.9692, 0.9686, 0.9734,\n", + " 0.9816, 0.9768, 0.9716, 0.9740, 0.9741, 0.9719, 0.9710, 0.9806, 0.9783,\n", + " 0.9851, 0.9841, 0.9851, 0.9837, 0.9778, 0.9795, 0.7330],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([4.9321, 5.0221, 4.9828, 4.8539, 4.6618, 4.4248, 4.1553, 3.8622, 3.5519,\n", + " 3.2288, 2.8964, 2.5569, 2.2123, 1.8638, 1.5124, 1.1588, 0.8037, 0.4473])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 28, 30, 30, 30, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(23.6912, grad_fn=) , base rewards= tensor([8.1248, 8.1248, 8.1248, 8.1248, 8.1248, 8.1248, 8.1248, 8.1248, 7.3176,\n", + " 6.6383, 6.0480, 5.5204, 5.0359, 4.5833, 4.1545, 3.7432, 3.3450, 2.9565,\n", + " 2.5751, 2.1992, 1.8272, 1.4583, 1.0916, 0.7266, 0.3628]) return= 174574.19907247985\n", + "probs of actions: tensor([0.9596, 0.0204, 0.9626, 0.9641, 0.9718, 0.9681, 0.9678, 0.9678, 0.9721,\n", + " 0.0125, 0.9761, 0.9707, 0.9727, 0.9733, 0.9708, 0.9702, 0.9798, 0.9769,\n", + " 0.9846, 0.9834, 0.9843, 0.9823, 0.9762, 0.9779, 0.2585],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5737, 0.6304, 0.6745, 0.6971, 0.7085, 0.7142, 0.7171, 0.7186,\n", + " 0.7309, 0.7107, 0.7153, 0.7177, 0.7188, 0.7194, 0.7197, 0.7199, 0.7199,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8099])\n", + "finalReturns: tensor([4.9130, 5.0030, 4.9638, 4.8232, 4.6402, 4.4094, 4.1442, 3.8542, 3.5461,\n", + " 3.2246, 2.8933, 2.5547, 2.2107, 1.8627, 1.5116, 1.1583, 0.8033, 0.4471])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 35, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(27.3346, grad_fn=) , base rewards= tensor([8.4405, 8.4405, 8.4405, 8.4405, 8.4405, 8.4405, 8.4405, 7.6357, 6.9574,\n", + " 6.3676, 5.8402, 5.3575, 4.9072, 4.4803, 4.0747, 3.6826, 3.2997, 2.9231,\n", + " 2.5509, 2.1818, 1.8151, 1.4501, 1.0864, 0.7236, 0.3616]) return= 174822.34687814018\n", + "probs of actions: tensor([0.9669, 0.9709, 0.9694, 0.9709, 0.9771, 0.9740, 0.9767, 0.9734, 0.9773,\n", + " 0.9849, 0.9816, 0.0050, 0.9781, 0.9794, 0.9763, 0.9788, 0.9841, 0.9824,\n", + " 0.9879, 0.9864, 0.9873, 0.9861, 0.9811, 0.9829, 0.2758],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.6873, 0.7426, 0.7312, 0.7256, 0.7228, 0.7214, 0.7207,\n", + " 0.7204, 0.7202, 0.7201, 0.7200, 0.7200, 0.7200, 0.8099])\n", + "finalReturns: tensor([5.3317, 5.4217, 5.3826, 5.2537, 5.0617, 4.8247, 4.5878, 4.2721, 3.9464,\n", + " 3.6129, 3.2730, 2.9282, 2.5797, 2.2284, 1.8749, 1.5198, 1.1635, 0.8063,\n", + " 0.4483])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(1.1644, grad_fn=) , base rewards= tensor([8.4699, 8.4699, 8.4699, 8.4699, 8.4699, 8.4699, 8.4699, 7.6651, 6.9869,\n", + " 6.3970, 5.8696, 5.3870, 4.9366, 4.5097, 4.1001, 3.7032, 3.3156, 2.9351,\n", + " 2.5597, 2.1882, 1.8196, 1.4532, 1.0884, 0.7247, 0.3620]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9728, 0.9761, 0.9749, 0.9762, 0.9814, 0.9789, 0.9818, 0.9781, 0.9821,\n", + " 0.9882, 0.9857, 0.9804, 0.9827, 0.9839, 0.9808, 0.9834, 0.9879, 0.9867,\n", + " 0.9906, 0.9895, 0.9903, 0.9892, 0.9847, 0.9869, 0.7137],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([5.2897, 5.3797, 5.3405, 5.2117, 5.0197, 4.7827, 4.5132, 4.2202, 3.9099,\n", + " 3.5868, 3.2543, 2.9149, 2.5703, 2.2218, 1.8704, 1.5168, 1.1616, 0.8053,\n", + " 0.4480])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(1.2641, grad_fn=) , base rewards= tensor([8.8218, 8.8218, 8.8218, 8.8218, 8.8218, 8.8218, 8.0221, 7.3463, 6.7575,\n", + " 6.2307, 5.7483, 5.2980, 4.8712, 4.4616, 4.0647, 3.6772, 3.2966, 2.9212,\n", + " 2.5498, 2.1812, 1.8147, 1.4499, 1.0863, 0.7236, 0.3615]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9732, 0.9765, 0.9752, 0.9764, 0.9816, 0.9797, 0.9824, 0.9785, 0.9840,\n", + " 0.9883, 0.9854, 0.9816, 0.9837, 0.9844, 0.9807, 0.9833, 0.9880, 0.9868,\n", + " 0.9908, 0.9898, 0.9904, 0.9893, 0.9848, 0.9869, 0.7391],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([5.6475, 5.7375, 5.6985, 5.5699, 5.3780, 5.1411, 4.8717, 4.5786, 4.2683,\n", + " 3.9453, 3.6128, 3.2734, 2.9287, 2.5802, 2.2288, 1.8753, 1.5201, 1.1637,\n", + " 0.8064, 0.4485])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(1.0142, grad_fn=) , base rewards= tensor([8.8218, 8.8218, 8.8218, 8.8218, 8.8218, 8.8218, 8.0221, 7.3463, 6.7575,\n", + " 6.2307, 5.7483, 5.2980, 4.8712, 4.4616, 4.0647, 3.6772, 3.2966, 2.9212,\n", + " 2.5498, 2.1812, 1.8147, 1.4499, 1.0863, 0.7236, 0.3615]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9772, 0.9800, 0.9790, 0.9801, 0.9846, 0.9829, 0.9858, 0.9824, 0.9871,\n", + " 0.9907, 0.9880, 0.9845, 0.9864, 0.9876, 0.9845, 0.9861, 0.9899, 0.9898,\n", + " 0.9928, 0.9919, 0.9928, 0.9917, 0.9874, 0.9892, 0.8099],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([5.6475, 5.7375, 5.6985, 5.5699, 5.3780, 5.1411, 4.8717, 4.5786, 4.2683,\n", + " 3.9453, 3.6128, 3.2734, 2.9287, 2.5802, 2.2288, 1.8753, 1.5201, 1.1637,\n", + " 0.8064, 0.4485])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(1.0303, grad_fn=) , base rewards= tensor([9.1636, 9.1636, 9.1636, 9.1636, 9.1636, 8.3743, 7.7032, 7.1166, 6.5908,\n", + " 6.1089, 5.6589, 5.2322, 4.8227, 4.4258, 4.0383, 3.6577, 3.2824, 2.9109,\n", + " 2.5423, 2.1759, 1.8110, 1.4474, 1.0847, 0.7227, 0.3611]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9789, 0.9816, 0.9806, 0.9817, 0.9865, 0.9843, 0.9865, 0.9849, 0.9885,\n", + " 0.9919, 0.9892, 0.9862, 0.9876, 0.9893, 0.9854, 0.9873, 0.9907, 0.9910,\n", + " 0.9935, 0.9929, 0.9939, 0.9925, 0.9882, 0.9904, 0.7998],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([6.0049, 6.0949, 6.0564, 5.9282, 5.7366, 5.4998, 5.2304, 4.9374, 4.6272,\n", + " 4.3041, 3.9717, 3.6322, 3.2876, 2.9391, 2.5877, 2.2341, 1.8790, 1.5226,\n", + " 1.1653, 0.8073, 0.4489])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(31.6695, grad_fn=) , base rewards= tensor([9.1771, 9.1771, 9.1771, 9.1771, 9.1771, 8.3878, 7.7166, 7.1282, 6.6001,\n", + " 6.1161, 5.6644, 5.2364, 4.8258, 4.4281, 4.0400, 3.6590, 3.2833, 2.9116,\n", + " 2.5428, 2.1762, 1.8113, 1.4476, 1.0848, 0.7227, 0.3612]) return= 174633.43787014481\n", + "probs of actions: tensor([0.9829, 0.9852, 0.9843, 0.9852, 0.0057, 0.9885, 0.9897, 0.9885, 0.9911,\n", + " 0.9940, 0.9913, 0.9895, 0.9904, 0.9916, 0.9882, 0.9901, 0.9933, 0.9931,\n", + " 0.9949, 0.9945, 0.9953, 0.9944, 0.9910, 0.9926, 0.8231],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.7109, 0.7007, 0.7103, 0.7152, 0.7176,\n", + " 0.7188, 0.7194, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([5.9852, 6.0636, 6.0340, 5.9121, 5.7250, 5.4914, 5.2244, 4.9330, 4.6239,\n", + " 4.3017, 3.9699, 3.6309, 3.2867, 2.9384, 2.5872, 2.2338, 1.8787, 1.5224,\n", + " 1.1652, 0.8073, 0.4488])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 1])\n", + "loss= tensor(1.5193, grad_fn=) , base rewards= tensor([9.4862, 9.4862, 9.4862, 9.4862, 8.7172, 8.0556, 7.4734, 6.9497, 6.4688,\n", + " 6.0193, 5.5929, 5.1834, 4.7866, 4.3991, 4.0186, 3.6432, 3.2718, 2.9032,\n", + " 2.5367, 2.1719, 1.8083, 1.4456, 1.0835, 0.7220, 0.3609]) return= 174695.3335318168\n", + "probs of actions: tensor([0.9842, 0.9863, 0.9855, 0.9870, 0.9911, 0.9894, 0.9908, 0.9897, 0.9920,\n", + " 0.9944, 0.9926, 0.9907, 0.9915, 0.9924, 0.9889, 0.9911, 0.9941, 0.9938,\n", + " 0.9956, 0.9951, 0.9954, 0.9949, 0.9918, 0.9935, 0.1746],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8099])\n", + "finalReturns: tensor([6.3612, 6.4512, 6.4136, 6.2861, 6.0950, 5.8585, 5.5893, 5.2964, 4.9861,\n", + " 4.6631, 4.3307, 3.9913, 3.6466, 3.2981, 2.9467, 2.5932, 2.2380, 1.8816,\n", + " 1.5243, 1.1664, 0.8079, 0.4490])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 28, 30, 30, 30, 0])\n", + "loss= tensor(11.9491, grad_fn=) , base rewards= tensor([9.4913, 9.4913, 9.4913, 9.4913, 8.7224, 8.0607, 7.4786, 6.9549, 6.4740,\n", + " 6.0245, 5.5980, 5.1886, 4.7918, 4.4043, 4.0238, 3.6484, 3.2769, 2.9083,\n", + " 2.5419, 2.1771, 1.8134, 1.4507, 1.0887, 0.7257, 0.3626]) return= 174643.91557478285\n", + "probs of actions: tensor([0.9841, 0.9861, 0.9853, 0.9877, 0.9911, 0.9891, 0.9909, 0.9900, 0.9915,\n", + " 0.9945, 0.9926, 0.9906, 0.9921, 0.9924, 0.9890, 0.9914, 0.9943, 0.9936,\n", + " 0.9958, 0.9952, 0.0026, 0.9950, 0.9914, 0.9937, 0.8678],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7316, 0.7110, 0.7155, 0.7178, 0.8089])\n", + "finalReturns: tensor([6.3509, 6.4409, 6.4033, 6.2757, 6.0846, 5.8481, 5.5790, 5.2861, 4.9758,\n", + " 4.6528, 4.3204, 3.9810, 3.6363, 3.2878, 2.9364, 2.5829, 2.2277, 1.8713,\n", + " 1.5024, 1.1534, 0.8010, 0.4462])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(38.6371, grad_fn=) , base rewards= tensor([9.7840, 9.7840, 9.7840, 9.0551, 8.4121, 7.8388, 7.3193, 6.8386, 6.3880,\n", + " 5.9601, 5.5492, 5.1512, 4.7628, 4.3815, 4.0056, 3.6337, 3.2647, 2.8980,\n", + " 2.5330, 2.1693, 1.8064, 1.4443, 1.0827, 0.7216, 0.3607]) return= 174633.43787014481\n", + "probs of actions: tensor([0.9877, 0.9893, 0.9890, 0.9911, 0.0036, 0.9925, 0.9937, 0.9930, 0.9941,\n", + " 0.9962, 0.9946, 0.9931, 0.9942, 0.9946, 0.9917, 0.9939, 0.9958, 0.9954,\n", + " 0.9971, 0.9963, 0.9970, 0.9963, 0.9938, 0.9955, 0.8143],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.7109, 0.7007, 0.7103, 0.7152, 0.7176,\n", + " 0.7188, 0.7194, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([6.6960, 6.7860, 6.7501, 6.6125, 6.4314, 6.2017, 5.9372, 5.6475, 5.3395,\n", + " 5.0182, 4.6869, 4.3483, 4.0043, 3.6563, 3.3053, 2.9520, 2.5970, 2.2407,\n", + " 1.8836, 1.5257, 1.1673, 0.8084, 0.4493])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.5376, grad_fn=) , base rewards= tensor([9.7712, 9.7712, 9.7712, 9.0423, 8.3993, 7.8260, 7.3065, 6.8276, 6.3790,\n", + " 5.9530, 5.5438, 5.1471, 4.7597, 4.3792, 4.0039, 3.6324, 3.2638, 2.8973,\n", + " 2.5325, 2.1689, 1.8062, 1.4442, 1.0826, 0.7215, 0.3606]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9901, 0.9915, 0.9914, 0.9932, 0.9951, 0.9942, 0.9952, 0.9947, 0.9955,\n", + " 0.9973, 0.9959, 0.9948, 0.9954, 0.9959, 0.9937, 0.9955, 0.9970, 0.9966,\n", + " 0.9979, 0.9973, 0.9977, 0.9972, 0.9953, 0.9966, 0.8406],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([6.7151, 6.8051, 6.7692, 6.6432, 6.4531, 6.2172, 5.9484, 5.6557, 5.3455,\n", + " 5.0225, 4.6901, 4.3507, 4.0061, 3.6576, 3.3062, 2.9526, 2.5975, 2.2411,\n", + " 1.8838, 1.5258, 1.1674, 0.8085, 0.4494])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.6762, grad_fn=) , base rewards= tensor([9.9849, 9.9849, 9.3328, 8.7264, 8.1704, 7.6592, 7.1843, 6.7376, 6.3126,\n", + " 5.9039, 5.5074, 5.1201, 4.7396, 4.3643, 3.9929, 3.6243, 3.2578, 2.8930,\n", + " 2.5294, 2.1667, 1.8046, 1.4431, 1.0820, 0.7211, 0.3605]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9888, 0.9911, 0.9908, 0.9918, 0.9944, 0.9932, 0.9947, 0.9941, 0.9948,\n", + " 0.9972, 0.9958, 0.9940, 0.9951, 0.9953, 0.9931, 0.9950, 0.9966, 0.9961,\n", + " 0.9978, 0.9973, 0.9976, 0.9970, 0.9947, 0.9963, 0.8248],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([7.0635, 7.1535, 7.1211, 6.9981, 6.8100, 6.5753, 6.3072, 6.0148, 5.7048,\n", + " 5.3820, 5.0496, 4.7102, 4.3656, 4.0171, 3.6657, 3.3122, 2.9570, 2.6006,\n", + " 2.2433, 1.8854, 1.5269, 1.1680, 0.8089, 0.4495])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.4788, grad_fn=) , base rewards= tensor([9.9849, 9.9849, 9.3328, 8.7264, 8.1704, 7.6592, 7.1843, 6.7376, 6.3126,\n", + " 5.9039, 5.5074, 5.1201, 4.7396, 4.3643, 3.9929, 3.6243, 3.2578, 2.8930,\n", + " 2.5294, 2.1667, 1.8046, 1.4431, 1.0820, 0.7211, 0.3605]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9916, 0.9938, 0.9937, 0.9939, 0.9960, 0.9955, 0.9963, 0.9959, 0.9967,\n", + " 0.9982, 0.9970, 0.9957, 0.9968, 0.9966, 0.9952, 0.9968, 0.9977, 0.9974,\n", + " 0.9986, 0.9982, 0.9985, 0.9980, 0.9961, 0.9976, 0.8535],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([7.0635, 7.1535, 7.1211, 6.9981, 6.8100, 6.5753, 6.3072, 6.0148, 5.7048,\n", + " 5.3820, 5.0496, 4.7102, 4.3656, 4.0171, 3.6657, 3.3122, 2.9570, 2.6006,\n", + " 2.2433, 1.8854, 1.5269, 1.1680, 0.8089, 0.4495])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.6760, grad_fn=) , base rewards= tensor([10.0687, 9.5574, 9.0209, 8.4989, 8.0041, 7.5371, 7.0943, 6.6711,\n", + " 6.2633, 5.8673, 5.4802, 5.0999, 4.7246, 4.3532, 3.9846, 3.6182,\n", + " 3.2534, 2.8897, 2.5270, 2.1650, 1.8035, 1.4423, 1.0815, 0.7208,\n", + " 0.3604]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9895, 0.9915, 0.9919, 0.9919, 0.9943, 0.9942, 0.9950, 0.9945, 0.9956,\n", + " 0.9975, 0.9961, 0.9946, 0.9957, 0.9955, 0.9940, 0.9957, 0.9970, 0.9966,\n", + " 0.9983, 0.9975, 0.9980, 0.9971, 0.9947, 0.9967, 0.9019],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([7.4010, 7.4910, 7.4655, 7.3486, 7.1645, 6.9322, 6.6653, 6.3737, 6.0641,\n", + " 5.7414, 5.4091, 5.0698, 4.7252, 4.3767, 4.0253, 3.6718, 3.3166, 2.9602,\n", + " 2.6030, 2.2450, 1.8865, 1.5277, 1.1685, 0.8092, 0.4496])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.5389, grad_fn=) , base rewards= tensor([10.0687, 9.5574, 9.0209, 8.4989, 8.0041, 7.5371, 7.0943, 6.6711,\n", + " 6.2633, 5.8673, 5.4802, 5.0999, 4.7246, 4.3532, 3.9846, 3.6182,\n", + " 3.2534, 2.8897, 2.5270, 2.1650, 1.8035, 1.4423, 1.0815, 0.7208,\n", + " 0.3604]) return= 174696.3335318168\n", + "probs of actions: tensor([0.9917, 0.9925, 0.9932, 0.9940, 0.9956, 0.9955, 0.9957, 0.9957, 0.9967,\n", + " 0.9981, 0.9968, 0.9957, 0.9966, 0.9963, 0.9956, 0.9966, 0.9977, 0.9972,\n", + " 0.9988, 0.9981, 0.9985, 0.9978, 0.9958, 0.9975, 0.9187],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6789, 0.6993, 0.7096, 0.7148, 0.7174, 0.7187,\n", + " 0.7193, 0.7197, 0.7198, 0.7199, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200,\n", + " 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.7200, 0.8100])\n", + "finalReturns: tensor([7.4010, 7.4910, 7.4655, 7.3486, 7.1645, 6.9322, 6.6653, 6.3737, 6.0641,\n", + " 5.7414, 5.4091, 5.0698, 4.7252, 4.3767, 4.0253, 3.6718, 3.3166, 2.9602,\n", + " 2.6030, 2.2450, 1.8865, 1.5277, 1.1685, 0.8092, 0.4496])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkVklEQVR4nO3df7DU9X3v8eeLw4EcbPSAYKsHKUaRTNAGwqmSZpIx2oCTNpFaDXjjlXvHCdVJe5ubho7eOMVq0sTShIztjbmkMmpqiUbtCe2NZZgxqRkHUcjRIEm4YjR6DjQQAWPiUX74vn/sZ3VZ9+zu2d9n9/WY2XH5fL+f736+rHzf+/mtiMDMzGw0E5pdADMza20OFGZmVpQDhZmZFeVAYWZmRTlQmJlZURObXYBamz59esyePbvZxTAzG1e2b9/+i4iYUehY2wWK2bNns23btmYXw8xsXJH0s9GOuenJzMyKcqAwM7OiHCjMzKwoBwozMyvKgcLMzIpqu1FPZu1mYHCYNZt2sefQCKf19rBqyVyWLuhrdrGsg6jdVo/t7+8PD4+1SlTyQC6V54aBHfzTo88fl+eESV38+vAxBBT71zdxgjj/jKk88syBiu7nfWdO4/L+WW+U76SebiQ4+MqRt3z21CndrP7IvOPKPjA4zI0bd3Jo5Mio51j7kLQ9IvoLHisVKCStB/4Q2BcR56S0e4C56ZRe4FBEzJc0G/gxsCsdezQirkl5FgJ3AD3Ad4A/j4iQNBm4C1gIvAgsi4jnUp4VwA3pWp+LiDtL3awDhZUr/0GYT8DvnTmNx549wJHXG1s2s2pcuWgWn1t67pjyFAsU5TQ93QH8A5mHOQARsSzn4l8CXso5/5mImF/gOrcBK4FHyQSKi4EHgauBgxFxlqTlwC3AMknTgNVAP5kfP9slbYyIg2WU2dpYOb/8P/71LRX/Es8KqPoaZs2QrcWONViMpqymp1RT+LdsjSInXcDzwIUR8XSR804FvhsR70x/vgK4ICL+RNIm4MaI2CJpIvCfwAxgefaclOf/AN+LiA3FyuoaRXsbGBxm1bee5Mjr7dVkalYPz33xD8o+t9oaRTHvB34eEU/npJ0haRD4JXBDRHwf6AOGcs4ZSmmk/74AEBFHJb0EnJybXiDPcSStJFNbYdasWVXekrWaUk1EZlZf1QaKK4DcX/h7gVkR8WLqkxiQNI9Mc2++7E/C0Y4Vy3N8YsQ6YB1kahRllt1aXC2aj8ysehUHitRMdCmZTmgAIuI14LX0frukZ4CzydQGZuZknwnsSe+HgNOBoXTNk4ADKf2CvDzfq7S81tpuGNjB3Y8+X3QUkJk1RzU1it8HfhIRbzQpSZoBHIiIY5LeAcwBfhoRByS9LGkRsBW4Cvj7lG0jsALYAlwGPJRGQ20C/kbS1HTeYuD6KsprLcZNSmbjQ8lAIWkDmV/20yUNAasj4nYync35HcsfAG6SdBQ4BlwTEdm2g2t5c3jsg+kFcDvwDUm7ydQklgOk4HIz8Hg676aca9k4V2h+gZm1Jk+4s4ZzkDCrv7GMeIL6jnoyKyh3rsNJPd0cPnqMVzxrzayuJgj+y/ljn2xXigOF1dzA4DDXP7CDkSPHANwHYVZHAp4dY+1hrLx6rNXcmk273ggSZlZfp/X21P0zXKNIvEJn9bJ/h8OHRppdFLOO0DVBrFoyt/SJVXKgIPOA+4tvPcmxtCzE8KER/uJbTwI4WJQpv7nJzOrrhEldfP6Pzm3IM8qBAvjsv+x4I0hkHXs9+Oy/7HCgKCK3FjZB4libjaCz0gSc8vZJ/Pzlw6OeM0HwekCfa+rjlgMF8OvDhX8Fj5Zub61BOEi0n77eHj74zhncv334uJpidi+L3Ae/m27bmwOFVcQd1u2rp7uLL1z6ZpNG/29PKxkEli7oc2BoYw4UNmYDg8PusB4nsr/+u1LTYPa/vWm3u0OvHHlj57tDrxwpGAgcBMyBwsqWaW76ISOeONfy+np7eOS6C5tdDGsTDhQ2qvzZ1b989QjeL6j19XR3NWTIpHUOBworyLOrm+c33z6JiV1db/QJHHrlcMGBFUrtSqWajsyq5UBhbzEwOMxf3PukRzI12NQp3az+yLy3POQLzVHJ73A2qycHihIGBoc76h+jd5VrrHIe+NljHn5qzeJAUcKaTbva/h+kl95ojrFMQPPII2smB4oS9rT5w9NLb9RP9wSx5vJ3A64N2PjmQFFCI1ZmbAbXIuorv7bgwGDjmQNFCe04zNC1iMr85tsnse/lw5Tq4h/rzmJmra6cPbPXA38I7IuIc1LaPUD2CdoLHIqI+enY9cDVZPbM/h8RsSmlL+TNPbO/A/x5RISkycBdwELgRWBZRDyX8qwAbkif87mIuLO62x27dvgleMPADjZsfcGjmKrQPQG2fvZDJWtifW1aA7XOVs7GRXcAF+cmRMSyiJifgsP9wAMAkt4FLAfmpTxfldSVst0GrATmpFf2mlcDByPiLGAtcEu61jRgNXA+cB6wWtLUiu6yg2X3p3aQqFymr2E+kPnh8Mh1F/KVZfPp6e467jxPdLN2VTJQRMTDQMHxkpIEfAzYkJIuAb4ZEa9FxLPAbuA8SacCJ0bElogIMjWIpTl5sjWF+4CL0nWXAJsj4kBEHAQ2kxewrLQNW19odhHGtb7eHtZc/u6Ci+B94dJz6evtQek8z2uwdlVtH8X7gZ9HxNPpz33AoznHh1LakfQ+Pz2b5wWAiDgq6SXg5Nz0AnmOI2klmdoKs2bNquJ23urjX9/C3Z94b02v2UiuSRQnYO2y+RVNaPOQVesU1QaKK3izNgGZf3f5okh6pXmOT4xYB6wD6O/vr+mTcbxMPhttP4DspjFW2Gm9PZ7QZlZCxYFC0kTgUjKd0FlDwOk5f54J7EnpMwuk5+YZStc8iUxT1xBwQV6e71Va3naWP4pp+NAIq771JKu+9YSDRBG5fQquHZiNrpzO7NH8PvCTiMhtUtoILJc0WdIZZDqtH4uIvcDLkhal/oergG/n5FmR3l8GPJT6MTYBiyVNTZ3Yi1Oa5Sm0idCR1wOvBj66Lsl9CmZlKmd47AYyv+ynSxoCVkfE7WRGN+U2OxEROyXdC/wIOAp8MiKyT7BreXN47IPpBXA78A1Ju8nUJJanax2QdDPweDrvpohoeDvQnFNOaPRHjlm7zx6vNS+oZzY2JQNFRFwxSvp/GyX988DnC6RvA84pkP4qcPko11oPrC9Vxnp65XDr/yw/rbfHM6xLyC7J7f4Hs7HzzOwSxsOv9VVL5vKpe55odjFalmsQZtVxoCihu6vQ4Kvmyh/hNPtkzwbO9ZVl8z2CyayGHChKOHystYYNFRrh5GanN/Wl4a4ODGa1U82oJ2uCQiOcLMNLaJjVhwPFODIwOOzaQ44J4CU0zBrATU/jRLbJyTImCL78sfkODGYN4BrFOOEmpzfJQcKsoRwoxgk3OWX0dHex1kHCrKHc9DROdEkduxJsmiv3lu1FzawxHCjGgYHB4Y4NEgDPemtRs6Zy01OL6/RO7C613oRHs07jQNHiOr0Tu5NrUmatwoGixXV6J3Zfr5cnMWs291G0CO9QV5hnWps1nwNFGQYGh+s60qbQ+k3XP7CDbT870NFB4spFszzCyawFuOmpDGs27ar79fP7IUaOHOPurc/X9XNb1dQp3Xxl2Xw+t/TcZhfFzHCNoiz13pNitOt3Yj9uT/cEBv9qcbOLYWY5XKMow2l17lCt9/XHk7d1dzW7CGaWx4GiDPXuUF21ZC49fkACcOiVI80ugpnlKRkoJK2XtE/SU3npfyZpl6Sdkv42pc2WNCLpifT6Ws75CyXtkLRb0q1SZiaVpMmS7knpWyXNzsmzQtLT6bWiZnc9RvXuUF26oI8vXHquh4Li2pVZKyqnRnEHcHFugqQPApcAvxMR84C/yzn8TETMT69rctJvA1YCc9Ire82rgYMRcRawFrglfcY0YDVwPnAesFrS1LHd3vixdEEfj1x3IZ0yD/k33z7pLffqjYfMWlPJQBERDwMH8pKvBb4YEa+lc/YVu4akU4ETI2JLRARwF7A0Hb4EuDO9vw+4KNU2lgCbI+JARBwENpMXsBplYHC4YZ/VCb+or1w0i62f/RBrl833xkNm40Clo57OBt4v6fPAq8BnIuLxdOwMSYPAL4EbIuL7QB8wlJN/KKWR/vsCQEQclfQScHJueoE8x5G0kkxthVmzZlV4S6Nbs2lXwx5gq5bMPW5ORbvp6+15Y9ir97Y2Gx8q7cyeCEwFFgGrgHtTLWAvMCsiFgCfBv5Z0olQsEUlO/hztGPF8hyfGLEuIvojon/GjBlju5My1Ht4bK6lC/r444Xt+fDs7pKblszGoUprFEPAA6kZ6TFJrwPTI2I/kG2O2i7pGTK1jyFgZk7+mcCenGudDgxJmgicRKapawi4IC/P9yosb1V6p3TX7dr5S3dMmTSBp/f9um6f1yxTp3Sz+iPzXIMwG4cqDRQDwIXA9ySdDUwCfiFpBnAgIo5JegeZTuufRsQBSS9LWgRsBa4C/j5dayOwAtgCXAY8FBEhaRPwNzkd2IuB6yssb1V+9Wrth2wODA5z48adHBp589rtugBgb0+3J9GZjWMlA4WkDWR+2U+XNERmJNJ6YH0aMnsYWJEe7h8AbpJ0FDgGXBMR2Y7wa8mMoOoBHkwvgNuBb0jaTaYmsRwgBZebgWzfx00512qoI6/X9nr5azu1s+4J4saPzmt2McysCiUDRURcMcqhKwucez9w/yjX2QacUyD9VeDyUfKsJxOU2kqn7DHRJbHm8ne7uclsnPPM7DLUem5DIzvHm6W7S3zpYw4SZu3AgaIMPd21/WvqhLkSJ0ya6CBh1iYcKMrwSo07KTphiOhLI16zyaxdOFA0wdIFfUye2N5/9Z1QazLrFO39tGpRA4PDvHa0xkOpWogn1pm1F29c1AT13jGvmTyxzqz9OFA0QTuOerpy0SxvXWrWptz01ARTJrXXJkW9Pd0OEmZtzIGiCV453D6T7bq7PPParN05UDRBwSVwx6ETJnWx5jJPqjNrd+6jaLBGboJULwLWLpvvAGHWIVyjaLC//tedzS5C1T6+aJaDhFkHcaBosIOvjP8Zy9/9yf5mF8HMGsiBwsasHYf3mtnoHChszLw8h1lncaCwMRHwwXfWfl9yM2tdDhRlqsVopRsGdtSgJM0VwP3bh9ti9JaZlceBokzXP7CjqofjwOAw//To8zUsUfOMHDnW1utVmdnxSgYKSesl7Uv7Y+em/5mkXZJ2SvrbnPTrJe1Ox5bkpC+UtCMdu1WSUvpkSfek9K2SZufkWSHp6fRaUZM7rlC1D8d2e7C6Q9usc5RTo7gDuDg3QdIHgUuA34mIecDfpfR3AcuBeSnPVyVlFza6DVgJzEmv7DWvBg5GxFnAWuCWdK1pwGrgfOA8YLWkqRXdZY1U83BstwerO7TNOkfJQBERDwMH8pKvBb4YEa+lc/al9EuAb0bEaxHxLLAbOE/SqcCJEbElIgK4C1iak+fO9P4+4KJU21gCbI6IAxFxENhMXsBqtGoeju30YO3p7vJ+E2YdpNI+irOB96emov+Q9LspvQ94Iee8oZTWl97npx+XJyKOAi8BJxe51ltIWilpm6Rt+/fXbzJYNQ/H8fZgndQlpk7pRmRWh82+7+vt4QuXnuuZ2WYdpNK1niYCU4FFwO8C90p6B5nRk/miSDoV5jk+MWIdsA6gv7+/bmvuVfNw3Paz/EpZa5vx9rfxyHUXNrsYZtYCKq1RDAEPRMZjwOvA9JR+es55M4E9KX1mgXRy80iaCJxEpqlrtGs1RU93dQPENmx9ofRJLaTd+lTMrHKVPv0GgAsBJJ0NTAJ+AWwElqeRTGeQ6bR+LCL2Ai9LWpT6H64Cvp2utRHIjmi6DHgo9WNsAhZLmpo6sRentKaodo/rYzG+Fhdvpz4VM6tOyaYnSRuAC4DpkobIjERaD6xPQ2YPAyvSw32npHuBHwFHgU9GRHaXnmvJjKDqAR5ML4DbgW9I2k2mJrEcICIOSLoZeDydd1NENK395vUqn/OidfehyC+bO6vNLFfJQBERV4xy6MpRzv888PkC6duAcwqkvwpcPsq11pMJSuNe1wRxtNpoUwc93V388cI+vvuT/ew5NMJpvT2sWjLXndVm9gZvXNQgrRgkuiSPYDKzkryERwO04rpIPd1dfOlj3sbUzEpzoKizgcFhrn+gtRYDFLgmYWZlc9NTnQwMDrNm0y6GW3CYae+UbgcJMyubA0UdZGsRI0eOlT65CQ61wXasZtY4bnqqgzWbdrVskADPkTCzsXGgqINWntXc3SXPkTCzMXGgGIOPf31LWee16i/2qVO6WXOZRzqZ2di4j2IMHnmmvInhq5bM5VP3PFHfwozRc1/8g2YXwczGKdco6mDpgj4mT/RfrZm1Bz/N6uDjX99S9SKCtdTXok1hZjY+OFDU2MDgcNlNVI3gBf7MrFoOFDX21/+6s9lFOI5nYJtZtRwoxqjUuk0HW2gyW19vj4OEmVXNgWKM1mza1ewilM1NTmZWCw4UY9TKk+nyuTZhZrXgQDFGxSbTtdJy4lOq3OPbzCzLT5MxKtac89l/aY3lxCcI/ubS32l2McysTZQMFJLWS9qX9sfOpt0oaVjSE+n14ZQ+W9JITvrXcvIslLRD0m5Jt0pSSp8s6Z6UvlXS7Jw8KyQ9nV4ranrnFRqtOWdgcJhfH27+QoB9vT18+WPz3exkZjVTzhIedwD/ANyVl742Iv6uwPnPRMT8Aum3ASuBR4HvABcDDwJXAwcj4ixJy4FbgGWSpgGrgX4ggO2SNkbEwTLK3HCt0Mnd19vDI9dd2OximFmbKVmjiIiHgapmkEk6FTgxIrZERJAJOkvT4UuAO9P7+4CLUm1jCbA5Ig6k4LCZTHBpSc3eoKhrgleFNbP6qKaP4k8l/TA1TU3NST9D0qCk/5D0/pTWBwzlnDOU0rLHXgCIiKPAS8DJuekF8hxH0kpJ2yRt279/fxW3VFordVjnmtwlNzeZWV1UGihuA84E5gN7gS+l9L3ArIhYAHwa+GdJJ5LZpjlfpP+OdqxYnuMTI9ZFRH9E9M+YMaPsm6hEKzQxFfLKkdZZW8rM2ktFgSIifh4RxyLideDrwHkp/bWIeDG93w48A5xNpjYwM+cSM4E96f0QcDqApInASWSaut5IL5CnaQo1Md0w0BqjnczM6qGiQJH6HLL+CHgqpc+Q1JXevwOYA/w0IvYCL0talPofrgK+nfJvBLIjmi4DHkr9GJuAxZKmpqatxSmt5dy99flmF6Fg9cvMrBZKjnqStAG4AJguaYjMSKQLJM0n0xT0HPAn6fQPADdJOgocA66JiGxH+LVkRlD1kBnt9GBKvx34hqTdZGoSywEi4oCkm4HH03k35VyrqQYGh4/rD4iCDWKN1QJFMLM2VTJQRMQVBZJvH+Xc+4H7Rzm2DTinQPqrwOWj5FkPrC9Vxka7/oFMU9PSBX0t07ntPSfMrF68FWoFRo4ce6NTOxs0msl7TphZPTlQVGjPoRHWbNrFyJHmzcYWmbWnVi2Z66GxZlY3DhQVOq23p+kryT77xT9o6uebWWfwooAVWrVkbtGVZBuhVfpHzKy9OVBQ2ZLcSxf0sWrJ3Kb+BV7/wA4HCzOrOwcKYHJ315jOn5AmLSxd0NfUCQy5nepmZvXiQAEcGuM+169H4ffN0Ox+EjNrfw4UFN+1rpQJTZ4S3ex+EjNrfw4UFN+1bjQDg8MMDA43tUbh+RNm1ggOFIy+a10xN27c2bT+AZGZif2FS8/1/AkzqzvPo6jQoZEjHBoZW99GrXj+hJk1kmsUVeiS12w1s/bnQFGFY62wbKyZWZ05UIwzvT3dzS6CmXUYB4pxxq1dZtZoDhTjzFgnB5qZVcuBYpzxBDszazQHinHGE+zMrNEcKMaR9505zRPszKzhSgYKSesl7ZP0VE7ajZKGJT2RXh/OOXa9pN2SdklakpO+UNKOdOxWKdMtK2mypHtS+lZJs3PyrJD0dHqtqNldj0NzTjmBuz/x3mYXw8w6UDk1ijuAiwukr42I+en1HQBJ7wKWA/NSnq9Kyq7hfRuwEpiTXtlrXg0cjIizgLXALela04DVwPnAecBqSVPHfIdtYvOnL2h2EcysQ5UMFBHxMHCgzOtdAnwzIl6LiGeB3cB5kk4FToyILRERwF3A0pw8d6b39wEXpdrGEmBzRByIiIPAZgoHrI7gDYrMrFmq6aP4U0k/TE1T2V/6fcALOecMpbS+9D4//bg8EXEUeAk4uci13kLSSknbJG3bv39/FbfUurybnZk1S6WB4jbgTGA+sBf4UkovNB0siqRXmuf4xIh1EdEfEf0zZswoUuzxy7vZmVmzVBQoIuLnEXEsIl4Hvk6mDwEyv/pPzzl1JrAnpc8skH5cHkkTgZPINHWNdq2O5d3szKwZKgoUqc8h64+A7IiojcDyNJLpDDKd1o9FxF7gZUmLUv/DVcC3c/JkRzRdBjyU+jE2AYslTU1NW4tTWsfyZDsza4aS+1FI2gBcAEyXNERmJNIFkuaTaQp6DvgTgIjYKele4EfAUeCTEXEsXepaMiOoeoAH0wvgduAbknaTqUksT9c6IOlm4PF03k0RUW6netvxbnZm1iyKNlsqu7+/P7Zt2zbmfLOv+791KE3l3nfmNJ57cYQ9h0Y4rbeHVUvmerKdmdWNpO0R0V/omHe4a0G9Pd2eXGdmLcNLeCRTp7TOPg83fnRes4tgZvYGB4pk9Uda5+HsJiYzayUOFC3G+3CbWatxoEhaZTLbFeefXvokM7MGcqBIWmEy25WLZvG5pec2uxhmZsdxoEhaYTKbg4SZtSIHiqTZk9n6WiBQmZkV4kCRNHukUbMDlZnZaBwoWkSzA5WZ2WgcKMzMrCgHCjMzK8qBwszMinKgaAHd/hbMrIX5EdUCfuNtrbMgoZlZPgeKFnDolSPNLoKZ2agcKFpAK8wKNzMbjQNFC/BkOzNrZSUDhaT1kvZJeqrAsc9ICknT059nSxqR9ER6fS3n3IWSdkjaLelWKbOetqTJku5J6Vslzc7Js0LS0+m1oiZ33GK6J3iynZm1tnJqFHcAF+cnSjod+BDwfN6hZyJifnpdk5N+G7ASmJNe2WteDRyMiLOAtcAt6frTgNXA+cB5wGpJU8u8r4o0Y5e7I683/CPNzMakZKCIiIeBAwUOrQX+EohS15B0KnBiRGyJiADuApamw5cAd6b39wEXpdrGEmBzRByIiIPAZgoErFpqxi533qjIzFpdRX0Ukj4KDEfEkwUOnyFpUNJ/SHp/SusDhnLOGUpp2WMvAETEUeAl4OTc9AJ58suzUtI2Sdv2799fyS0BzWkCOhYl46yZWVNNHGsGSVOAzwKLCxzeC8yKiBclLQQGJM0DCv1szj4hRztWLM/xiRHrgHUA/f394+rJ6+XFzazVVVKjOBM4A3hS0nPATOAHkn4rIl6LiBcBImI78AxwNpnawMyca8wE9qT3Q8DpAJImAieRaep6I71AnrbhEU9m1urGHCgiYkdEnBIRsyNiNpkH+nsi4j8lzZDUBSDpHWQ6rX8aEXuBlyUtSv0PVwHfTpfcCGRHNF0GPJT6MTYBiyVNTZ3Yi1OamZk1UDnDYzcAW4C5koYkXV3k9A8AP5T0JJmO6WsiItsRfi3wj8BuMjWNB1P67cDJknYDnwauA0j5bgYeT6+bcq7VNtZs2tXsIpiZFVWyjyIirihxfHbO+/uB+0c5bxtwToH0V4HLR8mzHlhfqozj2Z5DI80ugplZUZ6ZneeESV0N/Twv32Fmrc6BIs+vDx9r6Oe5M9vMWp0DRZ5GToCbc8oJXr7DzFqeA0WeRk6AGzr4KgODww37PDOzSjhQ5Gnkek8jR4551JOZtTwHijyNXlHDo57MrNU5UOR5aaSxu8151JOZtToHijyNfHD3dHd51JOZtTwHijwffOeMul17SvcEpk7pRmQWA/zCped61JOZtbwxrx7b7r77k8qXKS/mK8vmOyiY2bjkGkWeenQu9/X2OEiY2bjlQJGnHn0U7ocws/HMgSLPqiVz6emu3XpPVy6a5dqEmY1r7qPIk32o/897n6h6TsWkLvG5pefWoFRmZs3jGkUBSxf0cdLbqp+h/beXvbsGpTEzay4HilFUO/HOo5zMrF04UIyi2k5tBwkzaxcOFKNYtWSu/3LMzChvz+z1kvZJeqrAsc9ICknTc9Kul7Rb0i5JS3LSF0rakY7dKmU2fpA0WdI9KX2rpNk5eVZIejq9VlR9t2OwdEEfX142v5EfaWbWksr50XwHcHF+oqTTgQ8Bz+ekvQtYDsxLeb4qKTvW9DZgJTAnvbLXvBo4GBFnAWuBW9K1pgGrgfOB84DVkqaO7faqs3RBX0UbGb3vzGl1KI2ZWXOUDBQR8TBwoMChtcBfArmDSC8BvhkRr0XEs8Bu4DxJpwInRsSWiAjgLmBpTp470/v7gItSbWMJsDkiDkTEQWAzBQJWvVWykdHdn3hvHUpiZtYcFTXDS/ooMBwRT+Yd6gNeyPnzUErrS+/z04/LExFHgZeAk4tcq1B5VkraJmnb/v21Xaupb4yd2lcumlXTzzcza7YxBwpJU4DPAn9V6HCBtCiSXmme4xMj1kVEf0T0z5hR29Vfx7L8xts8wc7M2lAlNYozgTOAJyU9B8wEfiDpt8j86j8959yZwJ6UPrNAOrl5JE0ETiLT1DXatRpqLMNcv+gJdmbWhsYcKCJiR0ScEhGzI2I2mQf6eyLiP4GNwPI0kukMMp3Wj0XEXuBlSYtS/8NVwLfTJTcC2RFNlwEPpX6MTcBiSVNTJ/bilNZw5TY/ef9rM2tH5QyP3QBsAeZKGpJ09WjnRsRO4F7gR8C/A5+MiGPp8LXAP5Lp4H4GeDCl3w6cLGk38GngunStA8DNwOPpdVNKa7hyFwr0/tdm1o4U1a5812L6+/tj27ZtNb/uwOAwn7rniaLn9PX28Mh1F9b8s83M6k3S9ojoL3TMk4/LtHRBH1OnjL5QoPe/NrN25UAxBqs/Mo/urrcOxpo6pdv7X5tZ2/J+FGOQDQRrNu1iz6ERTuvtYdWSuQ4QZtbWHCjGaOmCPgcGM+sobnoyM7OiHCjMzKwoBwozMyvKgcLMzIpyoDAzs6Labma2pP3Az6q4xHTgFzUqznjRaffcafcLvudOUc09/3ZEFFx+u+0CRbUkbRttGnu76rR77rT7Bd9zp6jXPbvpyczMinKgMDOzohwo3mpdswvQBJ12z512v+B77hR1uWf3UZiZWVGuUZiZWVEOFGZmVlRHBgpJF0vaJWm3pOsKHJekW9PxH0p6TzPKWUtl3PMFkl6S9ER6/VUzyllLktZL2ifpqVGOt9X3XMb9tuN3fLqk70r6saSdkv68wDnt9j2Xc8+1/a4joqNeQBeZPbvfAUwCngTelXfOh8ns6S1gEbC12eVuwD1fAPxbs8ta4/v+APAe4KlRjrfb91zqftvxOz4VeE96/3bg/3XAv+dy7rmm33Un1ijOA3ZHxE8j4jDwTeCSvHMuAe6KjEeBXkmnNrqgNVTOPbediHgYOFDklLb6nsu437YTEXsj4gfp/cvAj4H8DWPa7Xsu555rqhMDRR/wQs6fh3jrX3I554wn5d7PeyU9KelBSfMaU7SmarfvuRxt+x1Lmg0sALbmHWrb77nIPUMNv+tO3OHurZteQ/4Y4XLOGU/KuZ8fkFnr5VeSPgwMAHPqXbAma7fvuZS2/Y4l/QZwP/CpiPhl/uECWcb991zinmv6XXdijWIIOD3nzzOBPRWcM56UvJ+I+GVE/Cq9/w7QLWl644rYFO32PRfVrt+xpG4yD8y7I+KBAqe03fdc6p5r/V13YqB4HJgj6QxJk4DlwMa8czYCV6XREouAlyJib6MLWkMl71nSb0lSen8emf83Xmx4SRur3b7notrxO073czvw44j48iintdX3XM491/q77rimp4g4KulPgU1kRgOtj4idkq5Jx78GfIfMSIndwCvAf29WeWuhzHu+DLhW0lFgBFgeafjEeCVpA5nRH9MlDQGrgW5oz++5jPttu+8YeB/wX4Edkp5Iaf8LmAXt+T1T3j3X9Lv2Eh5mZlZUJzY9mZnZGDhQmJlZUQ4UZmZWlAOFmZkV5UBhZjbOlVoQssD5H5P0o7So4D+XPN+jnszMxjdJHwB+RWZNq3NKnDsHuBe4MCIOSjolIvYVy+MahZnZOFdoQUhJZ0r6d0nbJX1f0jvToU8A/zsiDqa8RYMEOFCYmbWrdcCfRcRC4DPAV1P62cDZkh6R9Kiki0tdqONmZpuZtbu0YODvAd9KK3kATE7/nUhmgcALyKx79X1J50TEodGu50BhZtZ+JgCHImJ+gWNDwKMRcQR4VtIuMoHj8WIXMzOzNpKWHX9W0uXwxnaw706HB4APpvTpZJqiflrseg4UZmbjXFoQcgswV9KQpKuBjwNXS3oS2Mmbu1puAl6U9CPgu8CqiCi6sqyHx5qZWVGuUZiZWVEOFGZmVpQDhZmZFeVAYWZmRTlQmJlZUQ4UZmZWlAOFmZkV9f8B4zWG+OZZ2EQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams,prob_break_limit_ln=-0.001)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 10^-5.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 10^-5.ipynb new file mode 100644 index 0000000..21348a2 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/learn_stage-lr 10^-5.ipynb @@ -0,0 +1,1070 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# from learningBase import ReinforceAlgorithm\n", + "# from environmentModelBase import Model, AdversaryModes\n", + "# from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 2]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 0, 1, 0, 14, 7, 0, 37, 2, 1, 0, 1, 0, 2, 2, 8, 2, 9,\n", + " 0, 0, 0, 0, 1, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651,\n", + " 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651,\n", + " 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651, 0.5651]) return= 144580.61713032398\n", + "probs of actions: tensor([0.2677, 0.4146, 0.2616, 0.4348, 0.0020, 0.0073, 0.4527, 0.0008, 0.1499,\n", + " 0.2899, 0.4434, 0.2722, 0.4143, 0.1398, 0.1448, 0.0067, 0.1560, 0.0057,\n", + " 0.4129, 0.4321, 0.4380, 0.4079, 0.2701, 0.4400, 0.5927],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5402, 0.5512, 0.5606, 0.5420, 0.6108, 0.6160, 0.4520, 0.7242,\n", + " 0.6489, 0.6089, 0.5854, 0.5777, 0.5697, 0.5734, 0.5693, 0.5993, 0.5805,\n", + " 0.6101, 0.5861, 0.5742, 0.5683, 0.5653, 0.5677, 0.5651])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626,\n", + " 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626,\n", + " 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626, 0.5626]) return= 139887.0028572126\n", + "probs of actions: tensor([0.9056, 0.8891, 0.9016, 0.9011, 0.8871, 0.9035, 0.9155, 0.8796, 0.8922,\n", + " 0.0511, 0.9077, 0.9154, 0.0488, 0.9052, 0.9122, 0.0468, 0.8849, 0.0445,\n", + " 0.8796, 0.9043, 0.8997, 0.8847, 0.9058, 0.9048, 0.9894],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5623, 0.5662, 0.5644, 0.5633, 0.5667, 0.5646, 0.5635, 0.5668, 0.5645,\n", + " 0.5673, 0.5649, 0.5637, 0.5631, 0.5628, 0.5627, 0.5626])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([19, 0, 0, 16, 4, 33, 0, 19, 2, 12, 9, 9, 38, 6, 29, 9, 5, 12,\n", + " 21, 0, 0, 3, 2, 19, 0])\n", + "loss= tensor(0.1083, grad_fn=) , base rewards= tensor([1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562,\n", + " 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562,\n", + " 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 1.1562, 0.5729]) return= 153868.923096965\n", + "probs of actions: tensor([6.7453e-03, 2.4359e-01, 2.6405e-01, 4.5853e-02, 3.9187e-02, 1.2979e-03,\n", + " 3.2029e-01, 9.7528e-03, 6.1041e-02, 5.3805e-02, 4.1503e-02, 4.2067e-02,\n", + " 3.5512e-04, 3.3125e-02, 6.7532e-03, 4.8530e-02, 4.1285e-02, 5.2882e-02,\n", + " 1.2649e-02, 2.6483e-01, 1.9902e-01, 3.4315e-02, 6.3572e-02, 6.5753e-02,\n", + " 9.3820e-01], grad_fn=)\n", + "rewards: tensor([0.4751, 0.6084, 0.5852, 0.5482, 0.6284, 0.5024, 0.7198, 0.6027, 0.6755,\n", + " 0.6114, 0.6327, 0.6283, 0.4898, 0.7502, 0.5950, 0.7307, 0.6819, 0.6274,\n", + " 0.6048, 0.6894, 0.6243, 0.5921, 0.5887, 0.5472, 0.6470])\n", + "finalReturns: tensor([0.0381, 0.0742])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 1, 0, 1, 2, 13, 0, 0, 0, 0, 0, 2, 5, 8, 0, 12, 2, 0,\n", + " 12, 9, 9, 3, 13, 13, 0])\n", + "loss= tensor(0.1193, grad_fn=) , base rewards= tensor([1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333,\n", + " 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333,\n", + " 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 1.2333, 0.5982]) return= 145716.00627726328\n", + "probs of actions: tensor([0.4924, 0.1025, 0.4052, 0.0878, 0.0785, 0.0348, 0.4575, 0.3375, 0.4167,\n", + " 0.3210, 0.4148, 0.0771, 0.0259, 0.0369, 0.4270, 0.0963, 0.0827, 0.4002,\n", + " 0.0799, 0.0318, 0.0487, 0.0243, 0.0317, 0.0330, 0.9646],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5365, 0.5532, 0.5577, 0.5635, 0.5538, 0.6166, 0.5892, 0.5758,\n", + " 0.5691, 0.5658, 0.5638, 0.5684, 0.5792, 0.6047, 0.5690, 0.6188, 0.5982,\n", + " 0.5658, 0.6095, 0.6167, 0.6275, 0.5897, 0.6182, 0.6496])\n", + "finalReturns: tensor([0.0344, 0.0513])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([12, 9, 0, 13, 12, 16, 21, 8, 9, 13, 8, 19, 24, 20, 13, 20, 8, 10,\n", + " 12, 8, 2, 8, 16, 19, 0])\n", + "loss= tensor(0.6110, grad_fn=) , base rewards= tensor([1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655,\n", + " 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.7655,\n", + " 1.7655, 1.7655, 1.7655, 1.7655, 1.7655, 1.1495, 0.5606]) return= 157299.7684477885\n", + "probs of actions: tensor([0.1744, 0.0296, 0.0580, 0.1062, 0.2211, 0.0429, 0.0415, 0.0336, 0.0397,\n", + " 0.1072, 0.0398, 0.0347, 0.0191, 0.0228, 0.1049, 0.0267, 0.0370, 0.0374,\n", + " 0.1450, 0.0329, 0.0180, 0.0358, 0.0987, 0.1237, 0.8915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5733, 0.6065, 0.5674, 0.6092, 0.6141, 0.6200, 0.6908, 0.6520,\n", + " 0.6291, 0.6487, 0.6034, 0.6186, 0.6760, 0.7023, 0.6515, 0.7005, 0.6549,\n", + " 0.6380, 0.6478, 0.6387, 0.6016, 0.5904, 0.6158, 0.6826])\n", + "finalReturns: tensor([0.1234, 0.1490, 0.1221])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 19, 13, 0, 8, 12, 21, 12, 27, 16, 15, 30, 19, 19, 31, 0, 11,\n", + " 18, 1, 0, 8, 21, 16, 0])\n", + "loss= tensor(0.6755, grad_fn=) , base rewards= tensor([1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476,\n", + " 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.7476,\n", + " 1.7476, 1.7476, 1.7476, 1.7476, 1.7476, 1.1393, 0.5541]) return= 157154.5783200927\n", + "probs of actions: tensor([0.1052, 0.0519, 0.0165, 0.1318, 0.0639, 0.0443, 0.1467, 0.1016, 0.1574,\n", + " 0.0110, 0.0250, 0.0116, 0.0035, 0.0361, 0.0422, 0.0094, 0.0466, 0.0638,\n", + " 0.0599, 0.0416, 0.0299, 0.0410, 0.2827, 0.0667, 0.9334],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5134, 0.6121, 0.6465, 0.5974, 0.5995, 0.5907, 0.6677,\n", + " 0.5961, 0.6994, 0.6843, 0.6037, 0.7146, 0.6962, 0.6270, 0.7703, 0.6502,\n", + " 0.6228, 0.6800, 0.6239, 0.5864, 0.5642, 0.6427, 0.6785])\n", + "finalReturns: tensor([0.1378, 0.1819, 0.1245])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 21, 21, 18, 18, 2, 21, 21, 11, 22, 31, 29, 21, 18, 21, 22, 20, 21,\n", + " 22, 22, 29, 22, 29, 21, 0])\n", + "loss= tensor(2.4311, grad_fn=) , base rewards= tensor([2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538,\n", + " 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538, 2.5538,\n", + " 2.5538, 2.5538, 2.5538, 2.5538, 1.7850, 1.1234, 0.5337]) return= 166887.4504648441\n", + "probs of actions: tensor([0.0137, 0.2289, 0.1612, 0.0625, 0.0370, 0.0108, 0.2209, 0.2333, 0.0437,\n", + " 0.1131, 0.0219, 0.0175, 0.2343, 0.0663, 0.2709, 0.1197, 0.0565, 0.1557,\n", + " 0.1201, 0.1213, 0.0153, 0.1368, 0.0190, 0.4450, 0.9233],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5919, 0.6386, 0.6743, 0.6737, 0.7055, 0.5960, 0.6407, 0.6956,\n", + " 0.6292, 0.6121, 0.6785, 0.7376, 0.7238, 0.6866, 0.6824, 0.6952, 0.6847,\n", + " 0.6815, 0.6864, 0.6531, 0.7204, 0.6700, 0.7333, 0.7540])\n", + "finalReturns: tensor([0.3239, 0.3723, 0.3639, 0.2203])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([18, 27, 24, 29, 27, 29, 18, 31, 19, 8, 1, 13, 13, 1, 21, 31, 13, 22,\n", + " 18, 18, 19, 30, 31, 16, 0])\n", + "loss= tensor(4.6240, grad_fn=) , base rewards= tensor([2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330,\n", + " 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330, 2.4330,\n", + " 2.4330, 2.4330, 2.4330, 2.4330, 1.7213, 1.0863, 0.5168]) return= 164792.81532247848\n", + "probs of actions: tensor([0.0444, 0.0257, 0.0489, 0.0264, 0.0206, 0.0250, 0.0478, 0.0629, 0.0358,\n", + " 0.0119, 0.0132, 0.0890, 0.0917, 0.0125, 0.2366, 0.0529, 0.0809, 0.0627,\n", + " 0.0594, 0.0539, 0.0401, 0.0073, 0.0562, 0.0219, 0.9404],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5316, 0.6334, 0.6395, 0.6889, 0.6884, 0.7543, 0.6495, 0.7458,\n", + " 0.7412, 0.6843, 0.6090, 0.6280, 0.6544, 0.5675, 0.5739, 0.7257, 0.6545,\n", + " 0.6887, 0.6809, 0.6734, 0.6217, 0.6640, 0.7637, 0.7382])\n", + "finalReturns: tensor([0.3546, 0.4446, 0.4156, 0.2214])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 31, 18, 21, 31, 21, 31, 29, 31, 24, 12, 24, 0, 24, 21, 24, 21, 0,\n", + " 26, 31, 21, 27, 21, 24, 0])\n", + "loss= tensor(4.2829, grad_fn=) , base rewards= tensor([3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480,\n", + " 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480, 3.0480,\n", + " 3.0480, 3.0480, 3.0480, 2.2853, 1.6265, 1.0371, 0.5011]) return= 166985.79053327165\n", + "probs of actions: tensor([0.0153, 0.1539, 0.0354, 0.2007, 0.1461, 0.1883, 0.1508, 0.0368, 0.1541,\n", + " 0.0870, 0.0425, 0.0868, 0.0054, 0.0865, 0.1929, 0.0915, 0.1704, 0.0189,\n", + " 0.0245, 0.1555, 0.2186, 0.0451, 0.2213, 0.0887, 0.9680],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5007, 0.6711, 0.6605, 0.6216, 0.7234, 0.6531, 0.6996, 0.6962,\n", + " 0.7480, 0.7667, 0.6596, 0.7369, 0.5892, 0.6567, 0.6582, 0.6921, 0.7336,\n", + " 0.5776, 0.6122, 0.7186, 0.6739, 0.7208, 0.6903, 0.7524])\n", + "finalReturns: tensor([0.5079, 0.5520, 0.5369, 0.4055, 0.2512])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 31, 31, 31, 22, 31, 26, 31, 31, 27, 17, 31, 31, 31, 13, 21, 31, 31,\n", + " 31, 31, 31, 31, 31, 19, 0])\n", + "loss= tensor(3.1720, grad_fn=) , base rewards= tensor([3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928,\n", + " 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928, 3.0928,\n", + " 3.0928, 3.0928, 3.0928, 2.2793, 1.5971, 1.0063, 0.4801]) return= 172733.5729680412\n", + "probs of actions: tensor([0.0751, 0.4758, 0.4666, 0.5244, 0.0692, 0.5142, 0.0166, 0.5094, 0.4870,\n", + " 0.0485, 0.0051, 0.5040, 0.4339, 0.5063, 0.0046, 0.0832, 0.5138, 0.4380,\n", + " 0.4839, 0.5039, 0.6992, 0.6026, 0.5330, 0.0186, 0.9573],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5241, 0.6200, 0.6706, 0.7443, 0.6698, 0.7246, 0.6872, 0.7050,\n", + " 0.7371, 0.7677, 0.6500, 0.6860, 0.7044, 0.7928, 0.6911, 0.6370, 0.6794,\n", + " 0.7010, 0.7119, 0.7174, 0.7202, 0.7215, 0.7822, 0.7653])\n", + "finalReturns: tensor([0.6138, 0.7099, 0.6720, 0.5412, 0.2852])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 27, 31, 31, 31, 24, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 27, 31, 29, 31, 31, 31, 0])\n", + "loss= tensor(4.8994, grad_fn=) , base rewards= tensor([3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226,\n", + " 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226, 3.5226,\n", + " 3.5226, 3.5226, 2.7216, 2.0451, 1.4570, 0.9302, 0.4485]) return= 174757.78767184287\n", + "probs of actions: tensor([0.7862, 0.7586, 0.0294, 0.8176, 0.7825, 0.8072, 0.0207, 0.7976, 0.7895,\n", + " 0.7703, 0.7915, 0.8017, 0.7380, 0.8028, 0.8266, 0.7872, 0.8071, 0.7630,\n", + " 0.0241, 0.8530, 0.0122, 0.8752, 0.8303, 0.6949, 0.9726],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6624, 0.6630, 0.6927, 0.7077, 0.7538, 0.6878, 0.7053,\n", + " 0.7141, 0.7185, 0.7207, 0.7218, 0.7224, 0.7226, 0.7228, 0.7229, 0.7229,\n", + " 0.7461, 0.7049, 0.7259, 0.7094, 0.7162, 0.7195, 0.8173])\n", + "finalReturns: tensor([0.8706, 0.9667, 0.9174, 0.7960, 0.6066, 0.3688])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 21, 0])\n", + "loss= tensor(2.0205, grad_fn=) , base rewards= tensor([3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498,\n", + " 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498, 3.5498,\n", + " 3.5498, 3.5498, 2.7308, 2.0460, 1.4541, 0.9273, 0.4470]) return= 175369.33354397616\n", + "probs of actions: tensor([0.8780, 0.8573, 0.8730, 0.9065, 0.8867, 0.8989, 0.9029, 0.8870, 0.8921,\n", + " 0.8728, 0.8840, 0.8917, 0.8456, 0.8946, 0.9115, 0.8868, 0.8981, 0.8684,\n", + " 0.8785, 0.9372, 0.9667, 0.9486, 0.9153, 0.0555, 0.9760],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7749, 0.7744])\n", + "finalReturns: tensor([0.8912, 0.9873, 0.9491, 0.8181, 0.6220, 0.3274])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.1789, grad_fn=) , base rewards= tensor([3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.1535, 2.4688, 1.8768, 1.3501, 0.8697, 0.4227]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9456, 0.9385, 0.9475, 0.9667, 0.9544, 0.9637, 0.9643, 0.9583, 0.9566,\n", + " 0.9440, 0.9500, 0.9535, 0.9255, 0.9554, 0.9675, 0.9570, 0.9624, 0.9425,\n", + " 0.9633, 0.9830, 0.9915, 0.9852, 0.9737, 0.9243, 0.9795],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.1840, 1.2801, 1.2420, 1.1110, 0.9148, 0.6722, 0.3963])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0759, grad_fn=) , base rewards= tensor([3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725, 3.9725,\n", + " 3.9725, 3.1535, 2.4688, 1.8768, 1.3501, 0.8697, 0.4227]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9670, 0.9690, 0.9739, 0.9847, 0.9762, 0.9840, 0.9834, 0.9817, 0.9764,\n", + " 0.9688, 0.9722, 0.9747, 0.9550, 0.9755, 0.9850, 0.9789, 0.9829, 0.9690,\n", + " 0.9872, 0.9942, 0.9978, 0.9936, 0.9881, 0.9660, 0.9772],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.1840, 1.2801, 1.2420, 1.1110, 0.9148, 0.6722, 0.3963])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0198, grad_fn=) , base rewards= tensor([4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 3.5585, 2.8737, 2.2818, 1.7551, 1.2747, 0.8277, 0.4050]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9942, 0.9943, 0.9953, 0.9974, 0.9956, 0.9973, 0.9974, 0.9971, 0.9958,\n", + " 0.9948, 0.9951, 0.9956, 0.9908, 0.9961, 0.9976, 0.9962, 0.9971, 0.9963,\n", + " 0.9986, 0.9994, 0.9999, 0.9993, 0.9983, 0.9934, 0.9909],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.5020, 1.5981, 1.5599, 1.4289, 1.2327, 0.9902, 0.7142, 0.4140])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775, 4.3775,\n", + " 3.5585, 2.8737, 2.2818, 1.7551, 1.2747, 0.8277, 0.4050]) return= 175295.58353831372\n", + "probs of actions: tensor([0.9984, 0.9983, 0.9987, 0.9993, 0.9987, 0.9993, 0.9994, 0.9992, 0.9988,\n", + " 0.9986, 0.9986, 0.9988, 0.9970, 0.9990, 0.9994, 0.9989, 0.9992, 0.9992,\n", + " 0.9998, 0.9999, 1.0000, 1.0000, 0.9997, 0.9982, 0.9962],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.5020, 1.5981, 1.5599, 1.4289, 1.2327, 0.9902, 0.7142, 0.4140])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694,\n", + " 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 3.9504,\n", + " 3.2657, 2.6737, 2.1470, 1.6666, 1.2196, 0.7969, 0.3919]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.8330, 1.9291, 1.8909, 1.7599, 1.5638, 1.3212, 1.0453, 0.7451, 0.4271])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.4919e-06, grad_fn=) , base rewards= tensor([4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694,\n", + " 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 4.7694, 3.9504,\n", + " 3.2657, 2.6737, 2.1470, 1.6666, 1.2196, 0.7969, 0.3919]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([1.8330, 1.9291, 1.8909, 1.7599, 1.5638, 1.3212, 1.0453, 0.7451, 0.4271])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.9095e-06, grad_fn=) , base rewards= tensor([5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517,\n", + " 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 4.3327, 3.6479,\n", + " 3.0560, 2.5292, 2.0489, 1.6019, 1.1792, 0.7742, 0.3823]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.1736, 2.2697, 2.2316, 2.1006, 1.9044, 1.6619, 1.3859, 1.0857, 0.7678,\n", + " 0.4368])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(1.9095e-06, grad_fn=) , base rewards= tensor([5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517,\n", + " 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 5.1517, 4.3327, 3.6479,\n", + " 3.0560, 2.5292, 2.0489, 1.6019, 1.1792, 0.7742, 0.3823]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.1736, 2.2697, 2.2316, 2.1006, 1.9044, 1.6619, 1.3859, 1.0857, 0.7678,\n", + " 0.4368])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.3770e-06, grad_fn=) , base rewards= tensor([5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268,\n", + " 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 4.7078, 4.0230, 3.4311,\n", + " 2.9043, 2.4240, 1.9770, 1.5543, 1.1493, 0.7574, 0.3751]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.5215, 2.6176, 2.5794, 2.4484, 2.2522, 2.0097, 1.7337, 1.4335, 1.1156,\n", + " 0.7846, 0.4439])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.3770e-06, grad_fn=) , base rewards= tensor([5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268,\n", + " 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 5.5268, 4.7078, 4.0230, 3.4311,\n", + " 2.9043, 2.4240, 1.9770, 1.5543, 1.1493, 0.7574, 0.3751]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.5215, 2.6176, 2.5794, 2.4484, 2.2522, 2.0097, 1.7337, 1.4335, 1.1156,\n", + " 0.7846, 0.4439])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.8937e-06, grad_fn=) , base rewards= tensor([5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965,\n", + " 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.0775, 4.3928, 3.8009, 3.2741,\n", + " 2.7937, 2.3468, 1.9240, 1.5191, 1.1271, 0.7449, 0.3698]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.8746, 2.9707, 2.9325, 2.8015, 2.6054, 2.3628, 2.0869, 1.7867, 1.4687,\n", + " 1.1377, 0.7971, 0.4492])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(2.8937e-06, grad_fn=) , base rewards= tensor([5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.8965,\n", + " 5.8965, 5.8965, 5.8965, 5.8965, 5.8965, 5.0775, 4.3928, 3.8009, 3.2741,\n", + " 2.7937, 2.3468, 1.9240, 1.5191, 1.1271, 0.7449, 0.3698]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([2.8746, 2.9707, 2.9325, 2.8015, 2.6054, 2.3628, 2.0869, 1.7867, 1.4687,\n", + " 1.1377, 0.7971, 0.4492])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(3.4586e-06, grad_fn=) , base rewards= tensor([6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622,\n", + " 6.2622, 6.2622, 6.2622, 6.2622, 5.4433, 4.7586, 4.1667, 3.6399, 3.1596,\n", + " 2.7126, 2.2899, 1.8849, 1.4930, 1.1107, 0.7356, 0.3658]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.2317, 3.3278, 3.2896, 3.1587, 2.9625, 2.7199, 2.4440, 2.1438, 1.8259,\n", + " 1.4948, 1.1542, 0.8064, 0.4532])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(3.4586e-06, grad_fn=) , base rewards= tensor([6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622, 6.2622,\n", + " 6.2622, 6.2622, 6.2622, 6.2622, 5.4433, 4.7586, 4.1667, 3.6399, 3.1596,\n", + " 2.7126, 2.2899, 1.8849, 1.4930, 1.1107, 0.7356, 0.3658]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.2317, 3.3278, 3.2896, 3.1587, 2.9625, 2.7199, 2.4440, 2.1438, 1.8259,\n", + " 1.4948, 1.1542, 0.8064, 0.4532])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEFCAYAAAD9mKAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmDUlEQVR4nO3df5TV9X3n8eeLYbRDugoKbnWQxfhzg0aIU6V1zfFHAyZplHi0YnVlezylukm2bRpaaTyF+KPqsqk9NhtzTOSoqTEadUdyomHZYxNzUlChoIgNK0arM9hIBKwbRx2G9/7x/YzeGe+vuXPn/nw9zrnHy+f7Y94Xmfv+fn4rIjAzMytkUr0DMDOzxuZEYWZmRTlRmJlZUU4UZmZWlBOFmZkVNbneAVTb9OnTY/bs2fUOw8ysqWzatOmXETEj37GWSxSzZ89m48aN9Q7DzKypSPqXQsfc9GRmZkU5UZiZWVFOFGZmVpQThZmZFeVEYWZmRbXcqCezUno397Nq7Xb69w4goJGWxZw2pZMVn5nDonnd9Q7F7D1qtdVje3p6wsNjbbRrerfy9xterncYZjXz0k2fHtP5kjZFRE++YyWbniStlvSapGdzyu6TtCW9XpK0JZXPljSQc+wbOdecImmrpB2SbpWkVH5gut8OSU9Imp1zzRJJz6fXkjF9arPkE3/zIycJazuzr/5B1e5VTtPTncDXgLuHCyLi4uH3kr4KvJFz/gsRMTfPfW4DlgIbgEeAc4FHgSuAPRFxjKTFwM3AxZIOAVYAPWStA5skrYmIPWV/Omt7J3z5Ed4eaq1as1mtlUwUEfF47lN+rlQr+D3g7GL3kHQ4cFBErE9/vhtYRJYozgdWplMfAL6W7rsQWBcRu9M168iSy72lYrb25mYms+oa76inM4BfRMTzOWVHSdos6ceSzkhl3UBfzjl9qWz42CsAEbGPrHZyaG55nmtGkLRU0kZJG3ft2jXOj2TNzEnCrPrGmyguYeQT/qvArIiYB3wR+I6kgwDluXa4PaDQsWLXjCyMuD0ieiKiZ8aMvGtaWRvo3dzvJGE2ASoeHitpMnABcMpwWUS8A7yT3m+S9AJwHFltYGbO5TOBnel9H3Ak0JfueTCwO5WfOeqaH1Uar7W2S7+5np++sLveYZg1jLGOeipmPPMofgf4WUS816QkaQawOyKGJH0YOBb4eUTslvSmpPnAE8DlwN+ly9YAS4D1wIXAYxERktYCfy1pWjpvAbB8HPFai7qmd6uTxAS7bP4srl900piu6d3cz/KHtjIwOPReWVdnBzdecFLN5ok0QgytoGSikHQv2ZP9dEl9wIqIuANYzAc7lj8OXCtpHzAEXDncGQ1cRTaCqousE/vRVH4H8G1JO8hqEosBUnK5DngqnXdtzr3M3nOPm5smzCTB75829iQBvPdFvGrtdnbuHeCIqV0sW3h8Tb+gGyGGVuAJd9a0ejf3s3LNNvYODNY7lJbgJ+32VmzCnZfwsKbjBFG+gw7s4N/eeb/Z5djDPsRb7+5n594BDu7qRIK9bw36SduKcqKwppKvzbndeX0om2hOFNZUVq3d3vZJQsClFXQum1XKiSIZXlHUHV6NbefegXqHUFfd/rdpdeBEwQebM/r3DrD8oa0A/oVsMEdM7aK/DZPF6Ucfwj1/+Fv1DsPalDcuIn9zxsDgEKvWbq9TRFbImwPv1juECTMp31oEZHMYnCSsnlyjgIJPqO345NpIcpsDD+7qbOlRTlO7Oll53pwRo7ncSW2NwokCCu5yVuABz2pgdHNgKyeJrs4OVp6XJQQnBWtEThQU3gqztaYiNpdWGd2Ur2/BAyes2ThRWENqhWa/qV2defsWXHOwZuPObGtIzd7sN9ycZNYKXKOwhtSMzX5KnV1uTrJW40RhDWO47b5pm50CXqziHgBmjcKJwhpC7+Z+lj3wNINDzViXyBwxtaveIZhNCCcKq5vc0T8ImnnF+67ODpYtPL7eYZhNCHdmW10Mz5Po3ztA0FxJorNDXDZ/Ft1TuxDZ+kvex8FamWsUJfRu7vcXQJX1bu7nz+5/mqFmyg6JF+WzduREUcKqtdv9pVAlWS3iGQYG99c7lDGrZM9os1ZRsulJ0mpJr0l6NqfsPklb0uslSVtyji2XtEPSdkkLc8pPkbQ1HbtVklL5gel+OyQ9IWl2zjVLJD2fXkuq9aHHot2Xta6Wa3q38if3bWnKJAHwDz/bVe8QzOqmnBrFncDXgLuHCyLi4uH3kr4KvJHefwRYDMwBjgD+j6TjImIIuA1YCmwAHgHOBR4FrgD2RMQxkhYDNwMXSzoEWAH0kA2r3yRpTUTsGdcnHiOPZCnP6AX8crfYPOuEGfz9hpfrHeK4+IHB2lnJGkVEPA7szncs1Qp+D7g3FZ0PfDci3omIF4EdwKmSDgcOioj1ERFkSWdRzjV3pfcPAOek+y4E1kXE7pQc1pEll5rySJbSRndM7x0YZM9bgwTZUhzNniTADwzW3sY76ukM4BcR8Xz6czfwSs7xvlTWnd6PLh9xTUTsI6udHFrkXh8gaamkjZI27tpV3SYC90+U1ioL+BXioa/W7sabKC7h/doE5F+iJ4qUV3rNyMKI2yOiJyJ6ZsyYUSRcmwit2CzTIXnoq1lS8agnSZOBC4BTcor7gCNz/jwT2JnKZ+Ypz72mL93zYLKmrj7gzFHX/KjSeCvl4bGltdr2pF2dHU4OZjnGU6P4HeBnEZHbpLQGWJxGMh0FHAs8GRGvAm9Kmp/6Hy4HHs65ZnhE04XAY6kfYy2wQNI0SdOABamsplau2VbrH9l0li08ns5C+3g2IScJs5HKGR57L7AeOF5Sn6Qr0qHFjGx2IiK2AfcDzwE/BD6XRjwBXAV8i6yD+wWyEU8AdwCHStoBfBG4Ot1rN3Ad8FR6XZvKaqqVd1arlkXzuhna33yT5/LpkJwkzEYp2fQUEZcUKP8vBcpvAG7IU74RODFP+dvARQXutRpYXSpGq73c4bC/1jmJ5pwd8UFDEW5uNBvFM7NLaJ0GleoZvZ91s06iK2T5Q1sBj3gzG+ZEUUJrNKiMXyut9FrKwOCQl24xy+FEYSWNrkG0Q/ZsxSG/ZpXyMuNWUqtPqMvHM7HN3udEYSW1+tN1Z8fInijPxDYbyYnCSmrlp+upXZ2suvBkb0JkVoT7KKykVlj9tZCV581h0bxuJwazIlyjsKJ6N/dz35OvlD6xCU3t6nSCMCuDE4UVtWrtdgZbZNZ1rq7ODlaeN6feYZg1BTc9WVGt2JHtfa/NxsaJwoqaOqWTPW+1xnpXAl686dP1DsOs6bjpyYp6o0WSBMCUAzrqHYJZU3KisKJaaRWnt95tr0mDZtXiRGFto5Xng5hNJCcKawsCz7Y2q5A7s9tQ7kqwR7TJCKBL589q+c9oNlGcKNrM6JVg+/cOtMX+C9cvOqneIZg1rXK2Ql0t6TVJz44q/4Kk7ZK2SfrvqWy2pAFJW9LrGznnnyJpq6Qdkm5Ne2eT9te+L5U/IWl2zjVLJD2fXkuwccu3Euzw/guj9W7ur1VYE2ralM56h2DW1MqpUdwJfA24e7hA0lnA+cBHI+IdSYflnP9CRMzNc5/bgKXABuAR4FyyfbOvAPZExDGSFgM3AxdLOgRYAfSQ7YCwSdKaiNgzto9ouQpNoMtX/uX/tXWiw6mJVt5kyawWStYoIuJxYPeo4quAmyLinXTOa8XuIelw4KCIWB8RQZZ0FqXD5wN3pfcPAOek2sZCYF1E7E7JYR1ZcrFxKDTyJ1/5r1pkOOkbA60zF8SsHirtozgOOEPSDcDbwJci4ql07ChJm4F/A66JiJ8A3UBfzvV9qYz031cAImKfpDeAQ3PL81wzgqSlZLUVZs2aVeFHag+FVoLt3zvA3K/8byTY+9YgB3e1TnONh8WajU+liWIyMA2YD/wmcL+kDwOvArMi4nVJpwC9kuaQjU4cbbhBoNCxYteMLIy4HbgdoKenxw0No/Ru7mflmm3sLfFknXu81LnNwpsQmY1fpfMo+oCHIvMk2QTe6RHxTkS8DhARm4AXyGoffcDMnOtnAjtz7nUkgKTJwMFkTV3vlee5xsrUu7mfZd97umW++MvRIXkTIrMqqrRG0QucDfxI0nHAAcAvJc0AdkfEUKphHAv8PCJ2S3pT0nzgCeBy4O/SvdYAS4D1wIXAYxERktYCfy1pWjpvAbC8wnjbVqsuE17M/ggv/mdWRSUThaR7gTOB6ZL6yEYirQZWpyGz7wJL0pf7x4FrJe0DhoArI2K4I/wqshFUXWSjnR5N5XcA35a0g6wmsRggJZfrgOG+j2tz7mVl6m/BZcJLcZ+EWXWVTBQRcUmBQ5flOfdB4MEC99kInJin/G3gogLXrCZLSlahDomhNhof2jFJ7pMwqzKv9VSGa3qbdz5BOyWJAydP4qsXnew+CbMqc6Iow71PNO+e0R3KN3is9Zx+9CFsv/6TThJmE8BrPZWhGZ/Khxf+a8bYK/HS6+3XF2NWK04ULah3cz/LHniawaH2SBLQmnt7mzUKNz21oK98f1tbJQnwSCezieREUYZma+ff00L7XJfDmxKZTSwnijK0Szt/s/KmRGYTy4nCmprwpkRmE82Jwpqa63pmE8+JosU08+TASjRb/5FZM3KiaDHNPDmwEpecdmTpk8xsXDyPosW0esf7JMH+yGoSl5x2pPsnzGrAiaKFXPrN9fUOYUJN7epky4oF9Q7DrO246amF/PSF1l6F3Xtfm9WHE4U1Dc++NqsPJ4oW0eqjnTo7vM+EWb04UZSpd3N/vUMo6p4NL9c7hKqa0vn+P81pUzpZdaH3mTCrl3K2Ql0N/C7wWkScmFP+BeDzwD7gBxHx56l8OXAF2Vao/y0i1qbyU3h/K9RHgD9O26ceCNwNnAK8DlwcES+la5YA16QfeX1E3DXeD1ypVWu3N/QXVSuNdZoEPHfdJ+sdhpkl5dQo7gTOzS2QdBZwPvDRiJgD/I9U/hGyPa/npGu+LqkjXXYbsBQ4Nr2G73kFsCcijgFuAW5O9zqEbH/u04BTgRWSplX0KavAy1jXzt9cPLfeIZhZjpKJIiIeB0YPp7kKuCki3knnvJbKzwe+GxHvRMSLwA7gVEmHAwdFxPqICLIaxKKca4ZrCg8A50gSsBBYFxG7I2IPsI5RCauWGrkjtdGbxcysuVXaR3EccIakJyT9WNJvpvJuIHdqcF8q607vR5ePuCYi9gFvAIcWudcHSFoqaaOkjbt27arwIxXXyB2pq9Zur3cIVdVqn8es2VWaKCYD04D5wDLg/lQLyLfwThQpp8JrRhZG3B4RPRHRM2PGjFKxV6SR+ydarVms1T6PWbOrNFH0AQ9F5klgPzA9lecuvjMT2JnKZ+YpJ/caSZOBg8maugrdqy4auXmnkZvFKtFqn8es2VWaKHqBswEkHQccAPwSWAMslnSgpKPIOq2fjIhXgTclzU81j8uBh9O91gBL0vsLgcdSP8ZaYIGkaakTe0Eqq4uVa7bV60eXdNYJE1OLqpdGbuYza0flDI+9FzgTmC6pj2wk0mpgtaRngXeBJenLfZuk+4HnyIbNfi4ihtKtruL94bGPphfAHcC3Je0gq0ksBoiI3ZKuA55K510bEXVbo2JvAy8f8YNnXq13CFXVyM18Zu2oZKKIiEsKHLqswPk3ADfkKd8InJin/G3gogL3Wk2WlNpS7+Z+Vq3dzs69AxwxtYtlC4/P+yXabntkm1ltefXYBpKbGA7u6uRX7+5jcCjrv+/fO8Dyh7JlOvzEbWa15CU8GkTv5n6WP7SV/r0DBFlT13CSGDYwONTyQ0e7Ov1P0qzR+LeyQaxau52BwaGS57X60NEbL/hovUMws1GcKBpEuQmg2YeOfuiAjqLH3axm1nicKBrElBJfoND8S21PEnz2Y915Z1ICdDd5EjRrVU4Udda7uZ/Tb3qMX71butmp2ZeI3R/w4KZ+fvvoQz6QLLo6O5o6CZq1MieKOrqmdyt/et8W+stsdhrcH03fmT0wOMRLrw9wy8Vz6Z7ahchqEjdecJKbncwalIfH1knv5n7u2fDymCsJo/syGnlpkUJ27h1g0bxuJwazJuEaRZ2sWru9opak0Z3ZjVrDKNQPAc3fIW/Wbpwo6qSSYa752vEbcbhsV2cHl86fxdSuzrzH3Bdh1lycKOrk4DxfoqUMDA7xle9vG9Hc1GhP59OmdHLjBSdx/aKT2LJiAX/rvgizpuc+ijp5d18Zo5zy2PPWIMseeBrI5hycdcIM/n7Dy9UMbVzeHtw/4s/uizBrfq5R1EHv5n7eGvWFOhaDQ++PfvpOAyUJaI9lRszajRPFGFRjhFHv5n6Wfe/pcd9neEht5elm4jRiv4mZVc6JYgz+8qFnxn2PVWu3M7h//DPnBJx+02Pjvs9EaLR+EzMbHyeKMRhPc9Gwaj1tB5Q9Ua+WPKrJrPU4UdRYqz1ti2ykk0c1mbWukolC0mpJr6VtT4fLVkrql7QlvT6VymdLGsgp/0bONadI2ipph6Rb097ZpP2170vlT0ianXPNEknPp9cSWkCrPW1PniRWfGYOL970aX569dlOEmYtqJwaxZ3AuXnKb4mIuen1SE75CznlV+aU3wYsBY5Nr+F7XgHsiYhjgFuAmwEkHUK2P/dpwKnACknTyv9ojanVvkhbYf0pMyuuZKKIiMeB3eP5IZIOBw6KiPUREcDdwKJ0+HzgrvT+AeCcVNtYCKyLiN0RsQdYR/6E1VSacW2mUjzKyay1jaeP4vOSnklNU7lP+kdJ2izpx5LOSGXdQF/OOX2pbPjYKwARsQ94Azg0tzzPNSNIWippo6SNu3btGsdHmljVGhrbaFqt38XMRqo0UdwGHA3MBV4FvprKXwVmRcQ84IvAdyQdRP414obHiBY6VuyakYURt0dET0T0zJgxo+wPUWvVGhrbSDzKyaz1VZQoIuIXETEUEfuBb5L1IRAR70TE6+n9JuAF4Diy2sDMnFvMBHam933AkQCSJgMHkzV1vVee55qm1IjDWcfDo5zM2kNFiSL1OQz7LPBsKp8hqSO9/zBZp/XPI+JV4E1J81P/w+XAw+n6NcDwiKYLgcdSP8ZaYIGkaalpa0Eqq6vx9DGo2NrbTcijnMzaQ8lFASXdC5wJTJfURzYS6UxJc8magl4C/iid/nHgWkn7gCHgyogY7gi/imwEVRfwaHoB3AF8W9IOsprEYoCI2C3pOuCpdN61Ofeqm+UPbQUqG70ULdTq1GI5z8yKKJkoIuKSPMV3FDj3QeDBAsc2AifmKX8buKjANauB1aViHK/OSVDupOvhRe/a/Um6hXKemZXgmdnAAZM7xnS+h4OaWTtxogB+9e7Y9ob4tU7/tZlZ+/A3XgUGBve35MS5sej23AmztuFEAXn3di6l3Zet8NwJs/bhRAH87smHlz5plEr6KVrpL7vdO/PN2kkrfXdV7B9+NvZlPypZtsIjhcysGTlRUFntoJKmFycKM2tGThSMvXYgxt700u6d32bWvJwoGHvt4NL5s8b8M9q989vMmpcTBbXpmPUkPTNrVk4UFbhnw8tjvsZ7NphZs3KiqEAlndJnndC4+2SYmRXjRFEjlQzBNTNrBE4UNdJKfRTTpox9JruZNS8nigqNdbhrK/VRrPjMnHqHYGY15ERRobEOd22VtZG6Oid5+Q6zNuNEUaFWakoqV+ckceMFH613GGZWY04UFZo8xr+5Vphwt+qik12bMGtDJb/uJK2W9JqkZ3PKVkrql7QlvT6Vc2y5pB2StktamFN+iqSt6ditkpTKD5R0Xyp/QtLsnGuWSHo+vZZU7VNXweD+sfVT9DdQDaSryMZLHcq/G3b31C4nCbM2Vc5z8Z3AuXnKb4mIuen1CICkjwCLgTnpmq9LGt5n9DZgKXBseg3f8wpgT0QcA9wC3JzudQiwAjgNOBVYIWnamD/hBPrK97eVfe6k/N+/NTe1q5O3C2wQLuCS046kq3Pk1rBdnR0t08diZmNXMlFExOPA7jLvdz7w3Yh4JyJeBHYAp0o6HDgoItZHRAB3A4tyrrkrvX8AOCfVNhYC6yJid0TsAdaRP2HVzZ63Bss+d38DLB3b2SGkwhMGg2y+x40XnET31C5EVpO48YKTXJswa2OTx3Ht5yVdDmwE/ix9mXcDG3LO6Utlg+n96HLSf18BiIh9kt4ADs0tz3PNCJKWktVWmDVr7Av2jcc1vVu5ftFJNf2ZlfjQAR3c8NmT+NP7thQ9b+feARbN63ZiMLP3VNqZfRtwNDAXeBX4airP18ASRcorvWZkYcTtEdETET0zZtR2qYx7nhj7uk+1NrWrk23Xnsuied0l53O00nwPM6uOihJFRPwiIoYiYj/wTbI+BMie+o/MOXUmsDOVz8xTPuIaSZOBg8maugrdq6FENP5eEyvPe3+C3LKFx3+gD2KY+yLMLJ+KEkXqcxj2WWB4RNQaYHEayXQUWaf1kxHxKvCmpPmp/+Fy4OGca4ZHNF0IPJb6MdYCCyRNS53YC1JZw1n+0NaGTha5zUiL5nW/1wcB749ycl+EmRVSso9C0r3AmcB0SX1kI5HOlDSXrCnoJeCPACJim6T7geeAfcDnImIo3eoqshFUXcCj6QVwB/BtSTvIahKL0712S7oOeCqdd21ElNupXlMDg0OsWru9ab5k3QdhZmOh7OG9dfT09MTGjRvHfN3sq38w7p8tsjb+ZQuP/8AXcTXuX6mXbvp03X62mTUHSZsioiffMc/MTrqr0IkbZBPrRjdF1bNZqtjkOjOzcvhbJKlmJ+5wU9Swei7f4bWZzGy8nCiSarfZ5y7ZUc/lO9wXYWbj5UQxQXLXTCq0fpKZWTNwopggQzmDBIZabMCAmbUXJ4oJkluLcIXCzJqZE0VS7ZFJubUIVyjMrJk5USQTMTLp9Jsea+gZ22Zm5XCiSCZia9P+vQMlV2udSAd0uM3LzMbPiSKZqFVT69nqNOWA8awib2aWcaJIWnHV1DcGyt9YycysECeKpBUnpnlvCTOrBieKFtaKtSQzqz0nihbWirUkM6s9JwozMyvKicLMzIpyoshRjT0pzMxaTclEIWm1pNckPZvn2JckhaTp6c+zJQ1I2pJe38g59xRJWyXtkHRr2jubtL/2fan8CUmzc65ZIun59Foy+udXmzt/zcw+qJwaxZ3AuaMLJR0JfAJ4edShFyJibnpdmVN+G7AUODa9hu95BbAnIo4BbgFuTvc/hGx/7tOAU4EVkqaV+bnMzKxKSiaKiHgc2J3n0C3An1PG5GNJhwMHRcT6yDbpvhtYlA6fD9yV3j8AnJNqGwuBdRGxOyL2AOvIk7CqqZ470ZmZNaqK+igknQf0R8TTeQ4fJWmzpB9LOiOVdQN9Oef0pbLhY68ARMQ+4A3g0NzyPNeMjmeppI2SNu7atauSjwRMzHpPZmbNbsyJQtIU4MvAX+U5/CowKyLmAV8EviPpICDf6nTDNZFCx4pdM7Iw4vaI6ImInhkzZpT6CAV5JrOZ2QdVUqM4GjgKeFrSS8BM4J8k/UZEvBMRrwNExCbgBeA4strAzJx7zAR2pvd9wJEAkiYDB5M1db1XnueaCeHObDOzDxpzooiIrRFxWETMjojZZF/oH4uIf5U0Q1IHgKQPk3Va/zwiXgXelDQ/9T9cDjycbrkGGB7RdCHwWOrHWAsskDQtdWIvSGUTxjOZzcw+qOQ61JLuBc4EpkvqA1ZExB0FTv84cK2kfcAQcGVEDHeEX0U2gqoLeDS9AO4Avi1pB1lNYjFAROyWdB3wVDrv2px7mZlZjZRMFBFxSYnjs3PePwg8WOC8jcCJecrfBi4qcM1qYHWpGKtJ1HcPCTOzRuOZ2aM4SZiZjeREMYqX8TAzG8mJYhSPfDIzG8mJYhSPfDIzG8mJwszMinKiyGPypHyTwmvn2MM+VNefb2aWy4kij3376zf26fSjD2HdF8/ksvmz8q5hYmZWa04UDeaeP/wtAK5fdBK3XDz3vVFYY00apx99SJUjM7N2VXLCndXPonndIzrXZ1/9g7KvHU44Zmbj5RpFHo36ND61q7PeIZhZG3KiyKNRn8ZXnjeHzjI62t23YWbV5KanBlJqVvhwM9Sf3Lel6HmXzp9VrZDMzFyjKGTalNo385QzK3zRvO6iTVCXzZ/F9YtOqmZYZtbmnCgKWPGZOTX/meXOCs/XBNU5SfztxXOdJMys6pwoCqj1Uh6dY/g/sWheN6suOpnuqV2IrMlq1UUne/kRM5sQ7qMoYpKgVnPv9u0f2/mjh86amU0U1yiKOHBy7f56jvDy5mbWoEp+E0paLek1Sc/mOfYlSSFpek7Zckk7JG2XtDCn/BRJW9OxW9Pe2Ug6UNJ9qfwJSbNzrlki6fn0WkKNvT04xsf8CnV2yMubm1nDKueR+U7g3NGFko4EPgG8nFP2EbI9r+eka74uqSMdvg1YChybXsP3vALYExHHALcAN6d7HQKsAE4DTgVWSJo2to83PrV6yl91ofsXzKxxlUwUEfE4sDvPoVuAP2fk7qHnA9+NiHci4kVgB3CqpMOBgyJifUQEcDewKOeau9L7B4BzUm1jIbAuInZHxB5gHXkS1kRatvB4ujo7Sp84Tk4SZtbIKmqEl3Qe0B8RT4861A28kvPnvlTWnd6PLh9xTUTsA94ADi1yr3zxLJW0UdLGXbt2VfKR8lo0r5sbLzjJ26OaWVsbc6KQNAX4MvBX+Q7nKYsi5ZVeM7Iw4vaI6ImInhkzZuQ7pWKL5nXz06vP5kMHTHzNwsysEVVSozgaOAp4WtJLwEzgnyT9BtlT/5E5584EdqbymXnKyb1G0mTgYLKmrkL3qosbPjsxE9k65JWZzKyxjTlRRMTWiDgsImZHxGyyL/SPRcS/AmuAxWkk01FkndZPRsSrwJuS5qf+h8uBh9Mt1wDDI5ouBB5L/RhrgQWSpqVO7AWprC4WzevmsglYQ+mS044sfZKZWR2VMzz2XmA9cLykPklXFDo3IrYB9wPPAT8EPhcRQ+nwVcC3yDq4XwAeTeV3AIdK2gF8Ebg63Ws3cB3wVHpdm8rq5vpFJ1V9DSgvuWFmjU7Zw3vr6OnpiY0bN07Y/Y+6+gf5O0oq8NJNn67SnczMxkfSpojoyXfMM7PHqNjciqldne+tvzS1q5MpeRZwmqRshVcnCTNrFl7raYyWLTyeZd97msFRi0B1doiV583xnAgzazlOFGM0nAhWrtnG3oFBINu7YsVnnCTMrDU5UVSg0MqtvZv7WbV2Ozv3DnDE1C6WLTzeycPMmp4TRZX0bu5n+UNbGRjMBnn17x1g+UNbAS/RYWbNzZ3ZVbJq7fb3ksSwgcEhVq3dXqeIzMyqw4miSnbuHRhTuZlZs3CiqJJCw2a9IZGZNTsniirJtyR5V2eHNyQys6bnzuwqGe6w9qgnM2s1ThRVVGjYrJlZM3PTk5mZFeVEYWZmRTlRmJlZUU4UZmZWlBOFmZkV1XIbF0naBfzLOG4xHfhllcKppWaNGxx7vTj2+mjU2P9DRMzId6DlEsV4SdpYaJenRtascYNjrxfHXh/NGLubnszMrCgnCjMzK8qJ4oNur3cAFWrWuMGx14tjr4+mi919FGZmVpRrFGZmVpQThZmZFdWWiULSuZK2S9oh6eo8xyXp1nT8GUkfq0ec+ZQR+6Up5mck/aOkk+sRZz6lYs857zclDUm6sJbxFVNO7JLOlLRF0jZJP651jIWU8W/mYEnfl/R0iv0P6hHnaJJWS3pN0rMFjjfy72mp2Bv29zSviGirF9ABvAB8GDgAeBr4yKhzPgU8CgiYDzxR77jHEPtvA9PS+082U+w55z0GPAJcWO+4x/D3PhV4DpiV/nxYveMeQ+x/Cdyc3s8AdgMHNEDsHwc+Bjxb4HhD/p6WGXtD/p4WerVjjeJUYEdE/Dwi3gW+C5w/6pzzgbsjswGYKunwWgeaR8nYI+IfI2JP+uMGYGaNYyyknL93gC8ADwKv1TK4EsqJ/feBhyLiZYCIaJT4y4k9gH8nScCvkyWKfbUN84Mi4vEUSyGN+ntaMvYG/j3Nqx0TRTfwSs6f+1LZWM+ph7HGdQXZE1cjKBm7pG7gs8A3ahhXOcr5ez8OmCbpR5I2Sbq8ZtEVV07sXwP+I7AT2Ar8cUTsr01449Kov6dj1Ui/p3m14w53ylM2eoxwOefUQ9lxSTqL7B/gf5rQiMpXTux/C/xFRAxlD7cNo5zYJwOnAOcAXcB6SRsi4v9OdHAllBP7QmALcDZwNLBO0k8i4t8mOLbxatTf07I14O9pXu2YKPqAI3P+PJPsSWqs59RDWXFJ+ijwLeCTEfF6jWIrpZzYe4DvpiQxHfiUpH0R0VuTCAsr99/MLyPiV8CvJD0OnAzUO1GUE/sfADdF1mC+Q9KLwAnAk7UJsWKN+ntalgb9Pc2rHZuengKOlXSUpAOAxcCaUeesAS5PoyrmA29ExKu1DjSPkrFLmgU8BPznBniazVUy9og4KiJmR8Rs4AHgvzZAkoDy/s08DJwhabKkKcBpwD/XOM58yon9ZbKaEJL+PXA88POaRlmZRv09LamBf0/zarsaRUTsk/R5YC3ZiJDVEbFN0pXp+DfIRtx8CtgBvEX2xFV3Zcb+V8ChwNfTk/m+aICVKsuMvSGVE3tE/LOkHwLPAPuBb0VE3qGRtVTm3/t1wJ2StpI15/xFRNR9GWxJ9wJnAtMl9QErgE5o7N9TKCv2hvw9LcRLeJiZWVHt2PRkZmZj4ERhZmZFOVGYmVlRThRmZlaUE4WZWZMrtQhhnvN/T9JzaRHI75Q836OezMyam6SPA/+PbO2rE0uceyxwP3B2ROyRdFiptclcozAza3L5FiGUdLSkH6a1x34i6YR06A+B/zm8KGE5C1g6UZiZtabbgS9ExCnAl4Cvp/LjgOMk/VTSBknnlrpR283MNjNrdZJ+nWzPi+/lLLB5YPrvZOBYspnjM4GfSDoxIvYWup8ThZlZ65kE7I2IuXmO9QEbImIQeFHSdrLE8VSxm5mZWQtJS8S/KOkieG/b2OHtVnuBs1L5dLKmqKKLQDpRmJk1ubQI4XrgeEl9kq4ALgWukPQ0sI33dzZcC7wu6TngH4BlpZY59/BYMzMryjUKMzMryonCzMyKcqIwM7OinCjMzKwoJwozMyvKicLMzIpyojAzs6L+P6I5n46msFRlAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.0710e-06, grad_fn=) , base rewards= tensor([6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249,\n", + " 6.6249, 6.6249, 6.6249, 5.8061, 5.1214, 4.5295, 4.0028, 3.5224, 3.0754,\n", + " 2.6527, 2.2477, 1.8558, 1.4735, 1.0984, 0.7287, 0.3628]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.5918, 3.6879, 3.6497, 3.5187, 3.3226, 3.0800, 2.8041, 2.5039, 2.1859,\n", + " 1.8549, 1.5143, 1.1664, 0.8133, 0.4562])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.0710e-06, grad_fn=) , base rewards= tensor([6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249, 6.6249,\n", + " 6.6249, 6.6249, 6.6249, 5.8061, 5.1214, 4.5295, 4.0028, 3.5224, 3.0754,\n", + " 2.6527, 2.2477, 1.8558, 1.4735, 1.0984, 0.7287, 0.3628]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.5918, 3.6879, 3.6497, 3.5187, 3.3226, 3.0800, 2.8041, 2.5039, 2.1859,\n", + " 1.8549, 1.5143, 1.1664, 0.8133, 0.4562])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.7302e-06, grad_fn=) , base rewards= tensor([6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852,\n", + " 6.9852, 6.9852, 6.1666, 5.4820, 4.8901, 4.3634, 3.8830, 3.4360, 3.0133,\n", + " 2.6083, 2.2164, 1.8342, 1.4591, 1.0893, 0.7235, 0.3606]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.9541, 4.0502, 4.0120, 3.8810, 3.6849, 3.4423, 3.1664, 2.8662, 2.5482,\n", + " 2.2172, 1.8766, 1.5287, 1.1756, 0.8185, 0.4584])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(4.7302e-06, grad_fn=) , base rewards= tensor([6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852, 6.9852,\n", + " 6.9852, 6.9852, 6.1666, 5.4820, 4.8901, 4.3634, 3.8830, 3.4360, 3.0133,\n", + " 2.6083, 2.2164, 1.8342, 1.4591, 1.0893, 0.7235, 0.3606]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([3.9541, 4.0502, 4.0120, 3.8810, 3.6849, 3.4423, 3.1664, 2.8662, 2.5482,\n", + " 2.2172, 1.8766, 1.5287, 1.1756, 0.8185, 0.4584])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(5.4359e-06, grad_fn=) , base rewards= tensor([7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436,\n", + " 7.3436, 6.5252, 5.8408, 5.2490, 4.7223, 4.2420, 3.7950, 3.3723, 2.9673,\n", + " 2.5754, 2.1931, 1.8180, 1.4483, 1.0824, 0.7196, 0.3590]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.3180, 4.4141, 4.3759, 4.2450, 4.0488, 3.8063, 3.5303, 3.2301, 2.9122,\n", + " 2.5812, 2.2405, 1.8927, 1.5395, 1.1824, 0.8223, 0.4601])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(5.4359e-06, grad_fn=) , base rewards= tensor([7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436, 7.3436,\n", + " 7.3436, 6.5252, 5.8408, 5.2490, 4.7223, 4.2420, 3.7950, 3.3723, 2.9673,\n", + " 2.5754, 2.1931, 1.8180, 1.4483, 1.0824, 0.7196, 0.3590]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.3180, 4.4141, 4.3759, 4.2450, 4.0488, 3.8063, 3.5303, 3.2301, 2.9122,\n", + " 2.5812, 2.2405, 1.8927, 1.5395, 1.1824, 0.8223, 0.4601])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.1874e-06, grad_fn=) , base rewards= tensor([7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001,\n", + " 6.8824, 6.1983, 5.6066, 5.0800, 4.5997, 4.1527, 3.7300, 3.3250, 2.9331,\n", + " 2.5509, 2.1758, 1.8060, 1.4402, 1.0773, 0.7167, 0.3577]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.6831, 4.7792, 4.7411, 4.6101, 4.4140, 4.1714, 3.8955, 3.5953, 3.2774,\n", + " 2.9464, 2.6057, 2.2579, 1.9047, 1.5476, 1.1875, 0.8252, 0.4613])\n", + "----------------------------------------\n", + "99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.1874e-06, grad_fn=) , base rewards= tensor([7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001, 7.7001,\n", + " 6.8824, 6.1983, 5.6066, 5.0800, 4.5997, 4.1527, 3.7300, 3.3250, 2.9331,\n", + " 2.5509, 2.1758, 1.8060, 1.4402, 1.0773, 0.7167, 0.3577]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([4.6831, 4.7792, 4.7411, 4.6101, 4.4140, 4.1714, 3.8955, 3.5953, 3.2774,\n", + " 2.9464, 2.6057, 2.2579, 1.9047, 1.5476, 1.1875, 0.8252, 0.4613])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n", + " 31, 31, 31, 31, 31, 31, 0])\n", + "loss= tensor(6.9844e-06, grad_fn=) , base rewards= tensor([8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 8.0544, 7.2380,\n", + " 6.5545, 5.9631, 5.4367, 4.9564, 4.5095, 4.0868, 3.6818, 3.2899, 2.9077,\n", + " 2.5326, 2.1628, 1.7970, 1.4341, 1.0735, 0.7145, 0.3568]) return= 175295.58353831372\n", + "probs of actions: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5600, 0.6392, 0.6805, 0.7016, 0.7122, 0.7176, 0.7202, 0.7216,\n", + " 0.7223, 0.7226, 0.7228, 0.7228, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229,\n", + " 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.7229, 0.8190])\n", + "finalReturns: tensor([5.0490, 5.1451, 5.1070, 4.9762, 4.7801, 4.5375, 4.2616, 3.9614, 3.6435,\n", + " 3.3125, 2.9718, 2.6240, 2.2709, 1.9137, 1.5537, 1.1914, 0.8274, 0.4622])\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 4\u001b[0m ep\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100_000\u001b[39m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(game\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m----> 7\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mep\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m50_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mclc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperParams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\Find the problem\\Actor critic\\learningBase.py:461\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage\u001b[1;34m(self, stage, episodes, print_step, prob_break_limit_ln, clc, options, lr, just_stage)\u001b[0m\n\u001b[0;32m 458\u001b[0m probs_lst_pre \u001b[38;5;241m=\u001b[39m probs_lst\n\u001b[0;32m 460\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolicy\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m--> 461\u001b[0m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 462\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim\u001b[38;5;241m.\u001b[39mstep()\n\u001b[0;32m 464\u001b[0m \u001b[38;5;66;03m# if episode != 0:\u001b[39;00m\n\u001b[0;32m 465\u001b[0m \u001b[38;5;66;03m# self.meanStageValue = (\u001b[39;00m\n\u001b[0;32m 466\u001b[0m \u001b[38;5;66;03m# (self.meanStageValue*episode)+rewards)/(episode+1)\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 469\u001b[0m \u001b[38;5;66;03m# self.returns[iteration][episode] = returns\u001b[39;00m\n\u001b[0;32m 470\u001b[0m \u001b[38;5;66;03m# self.loss[iteration][episode] = loss\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m 477\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m 478\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[0;32m 479\u001b[0m Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[0;32m 480\u001b[0m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 485\u001b[0m inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[0;32m 486\u001b[0m )\n\u001b[1;32m--> 487\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 488\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[0;32m 489\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\autograd\\__init__.py:197\u001b[0m, in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m 192\u001b[0m retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[0;32m 194\u001b[0m \u001b[38;5;66;03m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[0;32m 195\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[0;32m 196\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[1;32m--> 197\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=5000, discountFactor =hyperParams[1])\n", + "algorithm.resetPolicyNet()\n", + "ep=100_000\n", + "\n", + "for stage in range(game.T-1, -1,-1):\n", + " algorithm.learn_stage(stage=stage,episodes=ep,print_step=50_000,clc=hyperParams[2],options=codeParams)\n", + "# ep*=0.95\n", + "# ep=int(ep)\n", + "# lr*=0.95\n", + "# algorithm.learn_stage(stage=1,episodes=1700,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/2)\n", + "# algorithm.learn_stage(stage=0,episodes=1500,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/4)\n", + "# algorithm.learn_stage(stage=2,episodes=1300,print_step=100,clc=hyperParams[2],options=codeParams, lr=lr/5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.loss)),algorithm.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1e-05, 1, 0]-stage 8-1682146185\n" + ] + } + ], + "source": [ + "print(algorithm.name)\n", + "algorithm.neuralNetwork.save(name=algorithm.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'algorithm' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m plt\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[43malgorithm\u001b[49m\u001b[38;5;241m.\u001b[39mreturns)),algorithm\u001b[38;5;241m.\u001b[39mreturns)\n", + "\u001b[1;31mNameError\u001b[0m: name 'algorithm' is not defined" + ] + } + ], + "source": [ + "plt.scatter(range(len(algorithm.returns)),algorithm.returns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/lr 10^-5 advs.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/lr 10^-5 advs.ipynb new file mode 100644 index 0000000..a9d76f9 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/lr 10^-5 advs.ipynb @@ -0,0 +1,9992 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663,\n", + " 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663,\n", + " 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663, 0.5663]) return= 139847.7232627179\n", + "probs of actions: tensor([0.8786, 0.8836, 0.8852, 0.9041, 0.9160, 0.8963, 0.8981, 0.8989, 0.9127,\n", + " 0.9010, 0.9015, 0.9021, 0.0518, 0.8964, 0.8851, 0.9235, 0.9054, 0.0415,\n", + " 0.9164, 0.9023, 0.9071, 0.9030, 0.0111, 0.9274, 0.9877],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5617, 0.5621, 0.5623,\n", + " 0.5624, 0.5624, 0.5625, 0.5624, 0.5662, 0.5644, 0.5634, 0.5630, 0.5626,\n", + " 0.5664, 0.5644, 0.5635, 0.5630, 0.5623, 0.5701, 0.5663])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 0, 0, 4, 8, 14, 0, 0, 1, 0, 22, 20, 0, 5, 5, 0, 0, 16, 0,\n", + " 0, 0, 1, 0, 0, 22, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279,\n", + " 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279,\n", + " 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 1.1279, 0.5635]) return= 145876.19064216543\n", + "probs of actions: tensor([0.4697, 0.5450, 0.0549, 0.0497, 0.0049, 0.4636, 0.4981, 0.0854, 0.5431,\n", + " 0.0618, 0.0067, 0.5533, 0.0268, 0.0303, 0.4079, 0.6228, 0.0022, 0.5265,\n", + " 0.5884, 0.4364, 0.0926, 0.5506, 0.5699, 0.7906, 0.9886],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5479, 0.5646, 0.5776, 0.6343, 0.5978, 0.5799, 0.5750,\n", + " 0.5203, 0.6114, 0.6865, 0.6204, 0.6092, 0.6062, 0.5841, 0.5477, 0.6298,\n", + " 0.5957, 0.5790, 0.5706, 0.5704, 0.5664, 0.5161, 0.6491])\n", + "finalReturns: tensor([0.0372, 0.0856])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 78431 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 0, 22, 22, 0])\n", + "loss= tensor(0.0009, grad_fn=) , base rewards= tensor([1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150,\n", + " 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.8150,\n", + " 1.8150, 1.8150, 1.8150, 1.8150, 1.8150, 1.1670, 0.5625]) return= 167444.53665689877\n", + "probs of actions: tensor([0.9807, 0.9663, 0.9871, 0.9885, 0.9861, 0.9875, 0.9866, 0.9924, 0.9865,\n", + " 0.9892, 0.9886, 0.9758, 0.9819, 0.9908, 0.9891, 0.9866, 0.9716, 0.9830,\n", + " 0.9787, 0.9912, 0.9762, 0.0128, 0.9990, 0.9996, 0.9954],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.7396, 0.5996, 0.6447, 0.7161])\n", + "finalReturns: tensor([0.1454, 0.1938, 0.1536])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 21111 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 0, 22, 22, 22, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420,\n", + " 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420, 2.3420,\n", + " 2.3420, 2.3420, 2.3420, 2.3420, 1.6940, 1.0895, 0.5270]) return= 167326.75936424857\n", + "probs of actions: tensor([0.9970, 0.9941, 0.9981, 0.9980, 0.9979, 0.9981, 0.9981, 0.9989, 0.9977,\n", + " 0.9984, 0.9982, 0.9962, 0.9969, 0.9986, 0.9983, 0.9977, 0.9953, 0.9971,\n", + " 0.9968, 0.9987, 0.0032, 0.9990, 0.9999, 1.0000, 0.9967],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.7396, 0.5996, 0.6447, 0.6677, 0.7278])\n", + "finalReturns: tensor([0.2978, 0.3462, 0.3061, 0.2008])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 788 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 0, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407,\n", + " 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407, 2.8407,\n", + " 2.8407, 2.8407, 2.8407, 2.1927, 1.5882, 1.0257, 0.4987]) return= 167267.7526299165\n", + "probs of actions: tensor([9.9804e-01, 9.9601e-01, 9.9866e-01, 9.9866e-01, 9.9858e-01, 9.9872e-01,\n", + " 9.9872e-01, 9.9925e-01, 9.9842e-01, 9.9895e-01, 9.9880e-01, 9.9754e-01,\n", + " 9.9786e-01, 9.9907e-01, 9.9890e-01, 9.9846e-01, 9.9682e-01, 9.9812e-01,\n", + " 9.9790e-01, 5.2534e-04, 9.9901e-01, 9.9924e-01, 9.9993e-01, 9.9998e-01,\n", + " 9.9636e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.7396, 0.5996, 0.6447, 0.6677, 0.6794, 0.7337])\n", + "finalReturns: tensor([0.4844, 0.5328, 0.4927, 0.3875, 0.2350])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906,\n", + " 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906, 3.4906,\n", + " 3.4906, 3.4906, 2.7510, 2.1030, 1.5197, 0.9827, 0.4792]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9980, 0.9960, 0.9987, 0.9987, 0.9986, 0.9987, 0.9987, 0.9992, 0.9984,\n", + " 0.9989, 0.9988, 0.9975, 0.9979, 0.9991, 0.9989, 0.9985, 0.9968, 0.9981,\n", + " 0.9979, 0.9991, 0.9989, 0.9993, 0.9999, 1.0000, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([0.7050, 0.7534, 0.7102, 0.6023, 0.4481, 0.2604])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 349 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0040, grad_fn=) , base rewards= tensor([3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776,\n", + " 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776, 3.7776,\n", + " 3.7776, 3.1295, 2.5250, 1.9625, 1.4355, 0.9369, 0.4601]) return= 167223.4464147788\n", + "probs of actions: tensor([0.9981, 0.9962, 0.9988, 0.9987, 0.9987, 0.9988, 0.9988, 0.9993, 0.9985,\n", + " 0.9990, 0.9989, 0.9976, 0.9980, 0.9991, 0.9990, 0.9985, 0.9970, 0.0014,\n", + " 0.9991, 0.9995, 0.9988, 0.9994, 0.9999, 1.0000, 0.9965],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396,\n", + " 0.5996, 0.6447, 0.6677, 0.6794, 0.6853, 0.6882, 0.7381])\n", + "finalReturns: tensor([0.9256, 0.9740, 0.9338, 0.8286, 0.6761, 0.4895, 0.2780])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 219 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999,\n", + " 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999, 4.3999,\n", + " 3.6604, 3.0123, 2.4290, 1.8920, 1.3885, 0.9093, 0.4481]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9983, 0.9966, 0.9989, 0.9989, 0.9988, 0.9989, 0.9989, 0.9994, 0.9986,\n", + " 0.9991, 0.9990, 0.9979, 0.9982, 0.9992, 0.9991, 0.9987, 0.9973, 0.9990,\n", + " 0.9992, 0.9996, 0.9990, 0.9995, 1.0000, 1.0000, 0.9965],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.1780, 1.2264, 1.1833, 1.0754, 0.9212, 0.7335, 0.5215, 0.2915])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 16 ep 5672 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630,\n", + " 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.6630, 4.0150,\n", + " 3.4105, 2.8480, 2.3210, 1.8223, 1.3456, 0.8855, 0.4380]) return= 167212.36521898463\n", + "probs of actions: tensor([9.9920e-01, 9.9831e-01, 9.9951e-01, 9.9950e-01, 9.9944e-01, 9.9955e-01,\n", + " 9.9955e-01, 9.9975e-01, 9.9934e-01, 9.9959e-01, 9.9954e-01, 9.9893e-01,\n", + " 9.9910e-01, 9.9968e-01, 9.9960e-01, 5.5382e-04, 9.9908e-01, 9.9982e-01,\n", + " 9.9983e-01, 9.9998e-01, 9.9956e-01, 9.9994e-01, 9.9999e-01, 1.0000e+00,\n", + " 9.9578e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.7396, 0.5996, 0.6447,\n", + " 0.6677, 0.6794, 0.6853, 0.6882, 0.6897, 0.6905, 0.7392])\n", + "finalReturns: tensor([1.4214, 1.4698, 1.4296, 1.3244, 1.1720, 0.9853, 0.7739, 0.5442, 0.3012])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0053, grad_fn=) , base rewards= tensor([5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692,\n", + " 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 5.2692, 4.5296, 3.8816,\n", + " 3.2983, 2.7613, 2.2577, 1.7786, 1.3173, 0.8693, 0.4310]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.6912, 1.7396, 1.6964, 1.5885, 1.4343, 1.2467, 1.0346, 0.8047, 0.5615,\n", + " 0.3086])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0066, grad_fn=) , base rewards= tensor([5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948,\n", + " 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 5.6948, 4.9552, 4.3072, 3.7239,\n", + " 3.1869, 2.6834, 2.2042, 1.7430, 1.2949, 0.8566, 0.4256]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([1.9567, 2.0051, 1.9620, 1.8541, 1.6999, 1.5122, 1.3002, 1.0702, 0.8271,\n", + " 0.5742, 0.3140])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 6.1164,\n", + " 6.1164, 6.1164, 6.1164, 6.1164, 6.1164, 5.3768, 4.7288, 4.1455, 3.6085,\n", + " 3.1049, 2.6258, 2.1645, 1.7165, 1.2782, 0.8472, 0.4216]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9995, 0.9989, 0.9991, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9958],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.2264, 2.2748, 2.2316, 2.1237, 1.9695, 1.7819, 1.5698, 1.3399, 1.0967,\n", + " 0.8438, 0.5836, 0.3180])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0105, grad_fn=) , base rewards= tensor([6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345, 6.5345,\n", + " 6.5345, 6.5345, 6.5345, 6.5345, 5.7952, 5.1473, 4.5640, 4.0270, 3.5235,\n", + " 3.0444, 2.5831, 2.1351, 1.6968, 1.2658, 0.8401, 0.4186]) return= 167235.25059974194\n", + "probs of actions: tensor([9.9920e-01, 9.9831e-01, 3.7954e-04, 9.9957e-01, 9.9935e-01, 9.9952e-01,\n", + " 9.9954e-01, 9.9975e-01, 9.9933e-01, 9.9959e-01, 9.9954e-01, 9.9893e-01,\n", + " 9.9910e-01, 9.9968e-01, 9.9960e-01, 9.9939e-01, 9.9896e-01, 9.9985e-01,\n", + " 9.9984e-01, 9.9998e-01, 9.9957e-01, 9.9994e-01, 9.9999e-01, 1.0000e+00,\n", + " 9.9578e-01], grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6786, 0.5708, 0.6296, 0.6601, 0.6756, 0.6834, 0.6873,\n", + " 0.6892, 0.6902, 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.4990, 2.5474, 2.5042, 2.3963, 2.2421, 2.0545, 1.8424, 1.6125, 1.3693,\n", + " 1.1164, 0.8562, 0.5907, 0.3210])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 13 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0135, grad_fn=) , base rewards= tensor([6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511, 6.9511,\n", + " 6.9511, 6.9511, 6.9511, 6.2116, 5.5636, 4.9804, 4.4434, 3.9398, 3.4607,\n", + " 2.9994, 2.5514, 2.1131, 1.6821, 1.2565, 0.8349, 0.4163]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([2.7739, 2.8223, 2.7791, 2.6712, 2.5170, 2.3294, 2.1173, 1.8874, 1.6442,\n", + " 1.3913, 1.1311, 0.8655, 0.5959, 0.3233])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0155, grad_fn=) , base rewards= tensor([7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655, 7.3655,\n", + " 7.3655, 7.3655, 6.6261, 5.9782, 5.3950, 4.8580, 4.3544, 3.8753, 3.4141,\n", + " 2.9660, 2.5277, 2.0967, 1.6711, 1.2495, 0.8310, 0.4146]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.0504, 3.0988, 3.0557, 2.9478, 2.7936, 2.6059, 2.3939, 2.1639, 1.9208,\n", + " 1.6679, 1.4077, 1.1421, 0.8725, 0.5998, 0.3250])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0175, grad_fn=) , base rewards= tensor([7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784, 7.7784,\n", + " 7.7784, 7.0393, 6.3915, 5.8083, 5.2713, 4.7678, 4.2887, 3.8274, 3.3794,\n", + " 2.9411, 2.5101, 2.0845, 1.6629, 1.2443, 0.8280, 0.4134]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.3282, 3.3766, 3.3335, 3.2256, 3.0714, 2.8838, 2.6717, 2.4418, 2.1986,\n", + " 1.9457, 1.6855, 1.4199, 1.1503, 0.8777, 0.6028, 0.3262])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0204, grad_fn=) , base rewards= tensor([8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899, 8.1899,\n", + " 7.4513, 6.8037, 6.2206, 5.6837, 5.1802, 4.7011, 4.2398, 3.7918, 3.3535,\n", + " 2.9225, 2.4969, 2.0753, 1.6567, 1.2404, 0.8258, 0.4124]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9993,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9994, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9957],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.6069, 3.6553, 3.6122, 3.5043, 3.3502, 3.1625, 2.9505, 2.7205, 2.4774,\n", + " 2.2245, 1.9643, 1.6987, 1.4291, 1.1565, 0.8816, 0.6050, 0.3272])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0220, grad_fn=) , base rewards= tensor([8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 8.5998, 7.8621,\n", + " 7.2150, 6.6321, 6.0953, 5.5919, 5.1128, 4.6515, 4.2035, 3.7652, 3.3342,\n", + " 2.9086, 2.4870, 2.0685, 1.6522, 1.2375, 0.8241, 0.4117]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([3.8863, 3.9347, 3.8916, 3.7838, 3.6296, 3.4420, 3.2300, 3.0000, 2.7569,\n", + " 2.5040, 2.2438, 1.9782, 1.7086, 1.4359, 1.1610, 0.8845, 0.6067, 0.3279])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0243, grad_fn=) , base rewards= tensor([9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 9.0073, 8.2716, 7.6254,\n", + " 7.0429, 6.5063, 6.0030, 5.5239, 5.0627, 4.6147, 4.1764, 3.7454, 3.3198,\n", + " 2.8982, 2.4797, 2.0633, 1.6487, 1.2353, 0.8229, 0.4112]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.1661, 4.2145, 4.1715, 4.0637, 3.9096, 3.7220, 3.5100, 3.2800, 3.0369,\n", + " 2.7840, 2.5238, 2.2582, 1.9886, 1.7159, 1.4411, 1.1645, 0.8867, 0.6079,\n", + " 0.3284])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0267, grad_fn=) , base rewards= tensor([9.4107, 9.4107, 9.4107, 9.4107, 9.4107, 9.4107, 8.6789, 8.0345, 7.4529,\n", + " 6.9167, 6.4136, 5.9346, 5.4735, 5.0255, 4.5872, 4.1562, 3.7306, 3.3090,\n", + " 2.8904, 2.4741, 2.0595, 1.6461, 1.2337, 0.8220, 0.4108]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9998,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.4461, 4.4945, 4.4516, 4.3440, 4.1899, 4.0023, 3.7903, 3.5604, 3.3173,\n", + " 3.0644, 2.8042, 2.5386, 2.2690, 1.9964, 1.7215, 1.4449, 1.1671, 0.8883,\n", + " 0.6088, 0.3288])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0297, grad_fn=) , base rewards= tensor([9.8065, 9.8065, 9.8065, 9.8065, 9.8065, 9.0824, 8.4416, 7.8618, 7.3264,\n", + " 6.8237, 6.3449, 5.8839, 5.4359, 4.9977, 4.5667, 4.1411, 3.7195, 3.3009,\n", + " 2.8846, 2.4700, 2.0566, 1.6442, 1.2325, 0.8213, 0.4105]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9994, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9990, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([4.7261, 4.7745, 4.7318, 4.6243, 4.4704, 4.2829, 4.0710, 3.8411, 3.5980,\n", + " 3.3451, 3.0849, 2.8193, 2.5497, 2.2771, 2.0022, 1.7256, 1.4478, 1.1690,\n", + " 0.8895, 0.6095, 0.3291])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.myopic\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0326, grad_fn=) , base rewards= tensor([10.1875, 10.1875, 10.1875, 10.1875, 9.4787, 8.8452, 8.2688, 7.7351,\n", + " 7.2332, 6.7548, 6.2939, 5.8461, 5.4079, 4.9769, 4.5513, 4.1298,\n", + " 3.7112, 3.2949, 2.8803, 2.4669, 2.0545, 1.6427, 1.2316, 0.8208,\n", + " 0.4103]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9983, 0.9995, 0.9995, 0.9995, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9991, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.0054, 5.0538, 5.0116, 4.9046, 4.7510, 4.5637, 4.3518, 4.1220, 3.8789,\n", + " 3.6260, 3.3658, 3.1002, 2.8306, 2.5580, 2.2831, 2.0065, 1.7287, 1.4499,\n", + " 1.1705, 0.8904, 0.6100, 0.3293])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0355, grad_fn=) , base rewards= tensor([10.5398, 10.5398, 10.5398, 9.8612, 9.2420, 8.6725, 8.1421, 7.6417,\n", + " 7.1642, 6.7037, 6.2560, 5.8179, 5.3870, 4.9614, 4.5399, 4.1213,\n", + " 3.7050, 3.2904, 2.8770, 2.4646, 2.0528, 1.6417, 1.2309, 0.8204,\n", + " 0.4101]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9992, 0.9984, 0.9995, 0.9995, 0.9995, 0.9996, 0.9996, 0.9998, 0.9994,\n", + " 0.9996, 0.9996, 0.9991, 0.9992, 0.9997, 0.9996, 0.9995, 0.9990, 0.9999,\n", + " 0.9998, 1.0000, 0.9996, 0.9999, 1.0000, 1.0000, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.2833, 5.3317, 5.2905, 5.1844, 5.0313, 4.8444, 4.6327, 4.4030, 4.1599,\n", + " 3.9071, 3.6469, 3.3813, 3.1117, 2.8391, 2.5642, 2.2876, 2.0098, 1.7310,\n", + " 1.4516, 1.1715, 0.8911, 0.6104, 0.3295])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 83 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0292, grad_fn=) , base rewards= tensor([10.8367, 10.8367, 10.2165, 9.6255, 9.0696, 8.5458, 8.0486, 7.5726,\n", + " 7.1129, 6.6656, 6.2277, 5.7969, 5.3713, 4.9498, 4.5313, 4.1150,\n", + " 3.7003, 3.2870, 2.8745, 2.4628, 2.0516, 1.6408, 1.2303, 0.8201,\n", + " 0.4100]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9997, 0.9997, 0.9997, 0.9997, 0.9997, 0.9999, 0.9996,\n", + " 0.9998, 0.9997, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997, 0.9992, 0.9999,\n", + " 0.9999, 1.0000, 0.9997, 1.0000, 1.0000, 1.0000, 0.9951],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.5581, 5.6065, 5.5674, 5.4630, 5.3111, 5.1248, 4.9135, 4.6840, 4.4410,\n", + " 4.1882, 3.9281, 3.6625, 3.3929, 3.1203, 2.8454, 2.5689, 2.2910, 2.0123,\n", + " 1.7328, 1.4528, 1.1724, 0.8917, 0.6107, 0.3296])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.0333, grad_fn=) , base rewards= tensor([11.0309, 10.5197, 9.9832, 9.4539, 8.9431, 8.4524, 7.9795, 7.5213,\n", + " 7.0747, 6.6372, 6.2066, 5.7811, 5.3597, 4.9411, 4.5248, 4.1102,\n", + " 3.6968, 3.2844, 2.8727, 2.4615, 2.0507, 1.6402, 1.2300, 0.8199,\n", + " 0.4099]) return= 168576.33348198733\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9997, 0.9997, 0.9997, 0.9997, 0.9997, 0.9999, 0.9996,\n", + " 0.9998, 0.9997, 0.9994, 0.9995, 0.9998, 0.9998, 0.9997, 0.9992, 0.9999,\n", + " 0.9999, 1.0000, 0.9997, 1.0000, 1.0000, 1.0000, 0.9951],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5718, 0.6302, 0.6604, 0.6757, 0.6834, 0.6873, 0.6893, 0.6902,\n", + " 0.6907, 0.6910, 0.6911, 0.6911, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912,\n", + " 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.6912, 0.7396])\n", + "finalReturns: tensor([5.8267, 5.8751, 5.8399, 5.7390, 5.5894, 5.4045, 5.1940, 4.9648, 4.7221,\n", + " 4.4694, 4.2093, 3.9438, 3.6742, 3.4016, 3.1267, 2.8502, 2.5723, 2.2936,\n", + " 2.0141, 1.7341, 1.4537, 1.1730, 0.8920, 0.6109, 0.3297])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682348121 saved\n", + "[346689, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 168576.33348198733, 65680.3332469066, 0.03331249579787254, 1e-05, 1, 0, 'tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\\n 22, 22, 22, 22, 22, 22, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682348121', 25, 50, 168576.3334819873, 205322.17620252006, 83998.798421993, 134475.68800000002, 131523.21866666665, 89197.96159612676, 89197.96159612676, 106340.34718300312, 106308.66365021843, 97483.02777699233, 89197.96159612676, 106308.66365021843]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 139739.47699942059\n", + "probs of actions: tensor([0.8929, 0.8857, 0.9020, 0.8962, 0.8926, 0.8984, 0.0646, 0.9006, 0.8831,\n", + " 0.9026, 0.8910, 0.0521, 0.8824, 0.8858, 0.8784, 0.9028, 0.8894, 0.8959,\n", + " 0.8758, 0.9148, 0.8829, 0.8869, 0.8875, 0.8934, 0.9822],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495, 0.5560, 0.5592, 0.5609, 0.5616, 0.5658, 0.5642,\n", + " 0.5633, 0.5629, 0.5626, 0.5664, 0.5644, 0.5635, 0.5630, 0.5627, 0.5626,\n", + " 0.5626, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([ 1, 0, 11, 0, 0, 0, 16, 19, 0, 0, 0, 4, 14, 8, 0, 12, 11, 0,\n", + " 10, 4, 0, 0, 0, 14, 0])\n", + "loss= tensor(0.0716, grad_fn=) , base rewards= tensor([1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330,\n", + " 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330,\n", + " 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 1.1330, 0.5652]) return= 146956.28276435166\n", + "probs of actions: tensor([0.0785, 0.5092, 0.0653, 0.4961, 0.4847, 0.3295, 0.0636, 0.0042, 0.4223,\n", + " 0.5699, 0.5365, 0.0700, 0.0100, 0.0034, 0.3717, 0.0786, 0.0824, 0.3663,\n", + " 0.0485, 0.0709, 0.4142, 0.4306, 0.3190, 0.1280, 0.9781],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5402, 0.5392, 0.5987, 0.5805, 0.5714, 0.5414, 0.5903, 0.6695,\n", + " 0.6148, 0.5884, 0.5738, 0.5645, 0.6211, 0.6258, 0.5793, 0.6124, 0.6362,\n", + " 0.5888, 0.6176, 0.6060, 0.5840, 0.5732, 0.5482, 0.6190])\n", + "finalReturns: tensor([0.0342, 0.0538])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([16, 12, 28, 1, 0, 23, 12, 16, 26, 22, 0, 27, 16, 27, 12, 19, 19, 26,\n", + " 1, 27, 22, 30, 27, 20, 0])\n", + "loss= tensor(0.9044, grad_fn=) , base rewards= tensor([2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149,\n", + " 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 2.0149,\n", + " 2.0149, 2.0149, 2.0149, 2.0149, 2.0149, 1.2464, 0.5849]) return= 162124.7477856951\n", + "probs of actions: tensor([0.0491, 0.1345, 0.0154, 0.1258, 0.1692, 0.0112, 0.1468, 0.0460, 0.0490,\n", + " 0.0374, 0.2083, 0.0527, 0.0574, 0.0611, 0.2087, 0.0473, 0.0565, 0.0554,\n", + " 0.0369, 0.0536, 0.0429, 0.0126, 0.1198, 0.1008, 0.9626],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5824, 0.5477, 0.7066, 0.6365, 0.5460, 0.6571, 0.6382, 0.6087,\n", + " 0.6761, 0.7320, 0.5716, 0.6866, 0.6276, 0.7269, 0.6619, 0.6699, 0.6424,\n", + " 0.7418, 0.5802, 0.6683, 0.6381, 0.6956, 0.7358, 0.7489])\n", + "finalReturns: tensor([0.1655, 0.2384, 0.1640])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 18, 27, 27, 26, 27, 29, 26, 27, 23, 27, 27, 19, 19, 20, 16, 25, 19,\n", + " 26, 23, 30, 27, 28, 29, 0])\n", + "loss= tensor(3.3616, grad_fn=) , base rewards= tensor([2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627,\n", + " 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627, 2.5627,\n", + " 2.5627, 2.5627, 2.5627, 2.5627, 1.7836, 1.1172, 0.5300]) return= 170297.27457943128\n", + "probs of actions: tensor([0.0463, 0.0392, 0.3955, 0.3738, 0.1785, 0.4352, 0.0531, 0.1506, 0.3757,\n", + " 0.0076, 0.4171, 0.4271, 0.0406, 0.0422, 0.0334, 0.0191, 0.0565, 0.0451,\n", + " 0.2052, 0.0074, 0.0165, 0.5405, 0.0105, 0.0368, 0.9833],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.6156, 0.6036, 0.6560, 0.6882, 0.6922, 0.6900, 0.7199, 0.7080,\n", + " 0.7292, 0.6922, 0.7012, 0.7426, 0.7099, 0.6899, 0.7006, 0.6449, 0.7001,\n", + " 0.6575, 0.6966, 0.6589, 0.7062, 0.7028, 0.7025, 0.7938])\n", + "finalReturns: tensor([0.3426, 0.4155, 0.3792, 0.2638])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([26, 27, 27, 25, 27, 27, 27, 0, 26, 27, 26, 27, 27, 27, 27, 27, 26, 25,\n", + " 26, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.5544, grad_fn=) , base rewards= tensor([3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524,\n", + " 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524, 3.0524,\n", + " 3.0524, 3.0524, 3.0524, 2.2741, 1.6082, 1.0211, 0.4904]) return= 170770.7691723508\n", + "probs of actions: tensor([0.1380, 0.6337, 0.6868, 0.0381, 0.6601, 0.7162, 0.7106, 0.0021, 0.1416,\n", + " 0.6234, 0.1196, 0.6613, 0.6336, 0.6924, 0.6360, 0.6668, 0.1431, 0.0319,\n", + " 0.1411, 0.7074, 0.7916, 0.8418, 0.8417, 0.6480, 0.9773],\n", + " grad_fn=)\n", + "rewards: tensor([0.4436, 0.5631, 0.6348, 0.6825, 0.6824, 0.6963, 0.7033, 0.7797, 0.5991,\n", + " 0.6466, 0.6834, 0.6898, 0.7000, 0.7052, 0.7077, 0.7090, 0.7150, 0.7160,\n", + " 0.7044, 0.7003, 0.7053, 0.7078, 0.7091, 0.7097, 0.7829])\n", + "finalReturns: tensor([0.5625, 0.6354, 0.5935, 0.4715, 0.2926])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 29, 27, 27, 27, 27, 20, 27, 26, 27, 27, 27, 22, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.6967, grad_fn=) , base rewards= tensor([3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200,\n", + " 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200, 3.5200,\n", + " 3.5200, 3.5200, 2.7382, 2.0706, 1.4828, 0.9516, 0.4611]) return= 172225.21784845914\n", + "probs of actions: tensor([0.7112, 0.6666, 0.7444, 0.0828, 0.7037, 0.7520, 0.7450, 0.6938, 0.0091,\n", + " 0.6783, 0.1017, 0.6977, 0.6331, 0.7429, 0.0189, 0.6977, 0.6746, 0.7301,\n", + " 0.7153, 0.8062, 0.8368, 0.8887, 0.8815, 0.7302, 0.9894],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6620, 0.7004, 0.7054, 0.7078, 0.7091, 0.7426,\n", + " 0.6794, 0.7001, 0.6981, 0.7042, 0.7073, 0.7333, 0.6876, 0.6989, 0.7046,\n", + " 0.7075, 0.7089, 0.7096, 0.7100, 0.7101, 0.7102, 0.7832])\n", + "finalReturns: tensor([0.8120, 0.8849, 0.8429, 0.7208, 0.5418, 0.3221])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 29, 27, 26, 26, 27, 29, 29, 27, 27, 27, 27, 29, 27, 27, 27,\n", + " 27, 27, 27, 25, 27, 19, 0])\n", + "loss= tensor(9.2171, grad_fn=) , base rewards= tensor([3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682,\n", + " 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682, 3.9682,\n", + " 3.9682, 3.1839, 2.5150, 1.9267, 1.3953, 0.9046, 0.4417]) return= 172834.79357956513\n", + "probs of actions: tensor([0.7195, 0.6850, 0.7542, 0.0809, 0.7215, 0.1352, 0.1281, 0.7134, 0.0822,\n", + " 0.0737, 0.7545, 0.7188, 0.6647, 0.7534, 0.0863, 0.7126, 0.6873, 0.7424,\n", + " 0.7456, 0.8016, 0.8489, 0.0049, 0.8710, 0.0048, 0.9992],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6620, 0.7004, 0.7107, 0.7087, 0.7025, 0.6952,\n", + " 0.7060, 0.7227, 0.7165, 0.7134, 0.7119, 0.6999, 0.7196, 0.7149, 0.7126,\n", + " 0.7115, 0.7109, 0.7106, 0.7209, 0.7016, 0.7427, 0.7461])\n", + "finalReturns: tensor([1.0760, 1.1489, 1.1069, 0.9846, 0.7951, 0.5842, 0.3044])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 25, 27, 27, 27, 29, 27, 27, 27, 28, 26, 27, 27,\n", + " 26, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(4.8350, grad_fn=) , base rewards= tensor([4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889,\n", + " 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889, 4.3889,\n", + " 3.6066, 2.9388, 2.3509, 1.8188, 1.3271, 0.8650, 0.4245]) return= 172634.51909284995\n", + "probs of actions: tensor([0.7646, 0.7255, 0.7889, 0.7591, 0.7688, 0.8019, 0.0085, 0.7527, 0.7150,\n", + " 0.7432, 0.0773, 0.7542, 0.7013, 0.8001, 0.0441, 0.0799, 0.7366, 0.7465,\n", + " 0.0758, 0.8491, 0.8635, 0.9027, 0.9119, 0.8123, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5671, 0.6369, 0.6732, 0.6916, 0.7010, 0.7160, 0.6992, 0.7047,\n", + " 0.7075, 0.6977, 0.7185, 0.7144, 0.7124, 0.7058, 0.7206, 0.7084, 0.7093,\n", + " 0.7151, 0.7057, 0.7080, 0.7092, 0.7097, 0.7100, 0.7831])\n", + "finalReturns: tensor([1.3613, 1.4342, 1.3869, 1.2691, 1.0932, 0.8757, 0.6281, 0.3586])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 29, 27, 27, 29, 27, 27, 27, 29, 27, 29, 28, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(2.6017, grad_fn=) , base rewards= tensor([4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995,\n", + " 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.7995, 4.0157,\n", + " 3.3471, 2.7589, 2.2275, 1.7369, 1.2757, 0.8361, 0.4122]) return= 172966.5624334948\n", + "probs of actions: tensor([0.7289, 0.1692, 0.7443, 0.7138, 0.1311, 0.7670, 0.7516, 0.7013, 0.1616,\n", + " 0.7016, 0.1237, 0.0473, 0.6433, 0.7727, 0.6639, 0.7063, 0.7170, 0.6757,\n", + " 0.8066, 0.8157, 0.8129, 0.8741, 0.9036, 0.8123, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5559, 0.6454, 0.6775, 0.6826, 0.7109, 0.7106, 0.7105, 0.6992,\n", + " 0.7192, 0.7036, 0.7159, 0.7203, 0.7153, 0.7128, 0.7116, 0.7109, 0.7106,\n", + " 0.7105, 0.7104, 0.7104, 0.7103, 0.7103, 0.7103, 0.7832])\n", + "finalReturns: tensor([1.6675, 1.7404, 1.6984, 1.5761, 1.3971, 1.1774, 0.9282, 0.6575, 0.3710])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([27, 29, 27, 27, 27, 29, 29, 27, 28, 29, 29, 27, 29, 27, 29, 27, 27, 29,\n", + " 29, 29, 27, 27, 27, 27, 0])\n", + "loss= tensor(11.3290, grad_fn=) , base rewards= tensor([5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989,\n", + " 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 5.1989, 4.4036, 3.7298,\n", + " 3.1391, 2.6065, 2.1171, 1.6595, 1.2254, 0.8070, 0.3996]) return= 173351.18255934515\n", + "probs of actions: tensor([0.5099, 0.3595, 0.5167, 0.4838, 0.5129, 0.3033, 0.3360, 0.4651, 0.0750,\n", + " 0.3347, 0.3011, 0.4653, 0.3972, 0.5718, 0.3602, 0.4803, 0.4625, 0.3816,\n", + " 0.2773, 0.3271, 0.6014, 0.6833, 0.7747, 0.6614, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5559, 0.6454, 0.6775, 0.6938, 0.6909, 0.7038, 0.7216, 0.7104,\n", + " 0.7064, 0.7116, 0.7255, 0.7067, 0.7230, 0.7054, 0.7224, 0.7163, 0.7021,\n", + " 0.7095, 0.7132, 0.7263, 0.7183, 0.7143, 0.7123, 0.7842])\n", + "finalReturns: tensor([2.0200, 2.0929, 2.0505, 1.9390, 1.7621, 1.5383, 1.2696, 0.9855, 0.6895,\n", + " 0.3846])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 28, 28, 29, 29, 29, 29, 30, 27, 29, 26, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 26, 29, 0])\n", + "loss= tensor(7.7630, grad_fn=) , base rewards= tensor([5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612,\n", + " 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 5.5612, 4.7621, 4.0865, 3.4969,\n", + " 2.9681, 2.4827, 2.0287, 1.5976, 1.1832, 0.7812, 0.3884]) return= 173825.5551842266\n", + "probs of actions: tensor([0.7370, 0.0655, 0.0614, 0.7672, 0.7414, 0.7641, 0.7839, 0.0485, 0.0853,\n", + " 0.7527, 0.0260, 0.7726, 0.7826, 0.7109, 0.7644, 0.8093, 0.8081, 0.7662,\n", + " 0.7728, 0.8169, 0.8252, 0.7849, 0.0323, 0.6756, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5696, 0.6399, 0.6706, 0.6936, 0.7052, 0.7111, 0.7081, 0.7311,\n", + " 0.7095, 0.7297, 0.7017, 0.7093, 0.7131, 0.7150, 0.7160, 0.7164, 0.7167,\n", + " 0.7168, 0.7169, 0.7169, 0.7169, 0.7334, 0.7036, 0.7943])\n", + "finalReturns: tensor([2.4016, 2.4857, 2.4454, 2.3186, 2.1307, 1.8993, 1.6364, 1.3506, 1.0481,\n", + " 0.7166, 0.4059])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 13 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 30, 29, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 27, 29, 29, 29, 0])\n", + "loss= tensor(8.1818, grad_fn=) , base rewards= tensor([5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.9484,\n", + " 5.9484, 5.9484, 5.9484, 5.9484, 5.9484, 5.1476, 4.4712, 3.8812, 3.3522,\n", + " 2.8668, 2.4127, 1.9816, 1.5672, 1.1652, 0.7708, 0.3828]) return= 174002.82550723848\n", + "probs of actions: tensor([0.7929, 0.8025, 0.8118, 0.8192, 0.7962, 0.8142, 0.0197, 0.8157, 0.0652,\n", + " 0.8068, 0.8006, 0.8221, 0.8335, 0.7760, 0.8249, 0.8528, 0.8706, 0.7983,\n", + " 0.8249, 0.8632, 0.0896, 0.8470, 0.7300, 0.7179, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7060, 0.7189, 0.7236,\n", + " 0.7129, 0.7149, 0.7159, 0.7164, 0.7167, 0.7168, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7281, 0.7080, 0.7125, 0.7147, 0.7999])\n", + "finalReturns: tensor([2.7328, 2.8169, 2.7765, 2.6496, 2.4617, 2.2302, 1.9674, 1.6816, 1.3678,\n", + " 1.0618, 0.7438, 0.4171])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 28, 29, 29, 29, 29, 29, 29, 30, 29, 27, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(12.7920, grad_fn=) , base rewards= tensor([6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411, 6.3411,\n", + " 6.3411, 6.3411, 6.3411, 6.3411, 5.5357, 4.8572, 4.2662, 3.7349, 3.2471,\n", + " 2.7909, 2.3581, 1.9423, 1.5393, 1.1457, 0.7590, 0.3776]) return= 173992.11630517073\n", + "probs of actions: tensor([0.8624, 0.8648, 0.8793, 0.8813, 0.0524, 0.8886, 0.8990, 0.8753, 0.8682,\n", + " 0.8730, 0.8802, 0.0325, 0.8614, 0.0400, 0.8668, 0.9117, 0.9162, 0.8509,\n", + " 0.9006, 0.9281, 0.9482, 0.9433, 0.8928, 0.8473, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.7026, 0.7024, 0.7097, 0.7133, 0.7151,\n", + " 0.7160, 0.7165, 0.7108, 0.7213, 0.7303, 0.7091, 0.7130, 0.7150, 0.7159,\n", + " 0.7164, 0.7167, 0.7168, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([3.0651, 3.1492, 3.0974, 2.9793, 2.7976, 2.5705, 2.3107, 2.0271, 1.7261,\n", + " 1.4124, 1.0892, 0.7589, 0.4235])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 30, 27, 29, 30, 30, 28, 29, 28, 29, 29, 29, 29, 29, 30,\n", + " 30, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(27.1738, grad_fn=) , base rewards= tensor([6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912, 6.6912,\n", + " 6.6912, 6.6912, 6.6912, 5.8911, 5.2150, 4.6242, 4.0942, 3.6077, 3.1528,\n", + " 2.7210, 2.3062, 1.9046, 1.5132, 1.1288, 0.7493, 0.3734]) return= 174079.33224464272\n", + "probs of actions: tensor([0.8209, 0.8254, 0.8419, 0.8423, 0.0719, 0.0270, 0.8679, 0.0696, 0.0810,\n", + " 0.0624, 0.8521, 0.0596, 0.7923, 0.8248, 0.8013, 0.8720, 0.8975, 0.0851,\n", + " 0.0489, 0.8874, 0.9414, 0.9314, 0.8985, 0.8402, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6910, 0.7225, 0.7052, 0.7052, 0.7126,\n", + " 0.7279, 0.7151, 0.7217, 0.7120, 0.7145, 0.7157, 0.7163, 0.7166, 0.7109,\n", + " 0.7154, 0.7236, 0.7203, 0.7186, 0.7178, 0.7173, 0.8012])\n", + "finalReturns: tensor([3.4307, 3.5091, 3.4732, 3.3495, 3.1639, 2.9340, 2.6723, 2.3932, 2.0926,\n", + " 1.7706, 1.4418, 1.1075, 0.7693, 0.4279])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 26, 29, 29, 29, 29, 29, 29, 28, 29, 29, 28, 29, 30, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(21.4632, grad_fn=) , base rewards= tensor([7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587, 7.0587,\n", + " 7.0587, 7.0587, 6.2626, 5.5883, 4.9994, 4.4709, 3.9847, 3.5298, 3.0985,\n", + " 2.6844, 2.2827, 1.8901, 1.5043, 1.1236, 0.7465, 0.3722]) return= 173927.67848376333\n", + "probs of actions: tensor([0.7494, 0.7613, 0.0041, 0.7772, 0.7584, 0.8050, 0.8112, 0.7614, 0.7421,\n", + " 0.0720, 0.8168, 0.7777, 0.0912, 0.7630, 0.1784, 0.7979, 0.8219, 0.7332,\n", + " 0.8220, 0.8517, 0.9236, 0.9042, 0.8870, 0.8024, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6549, 0.6641, 0.6903, 0.7036, 0.7102, 0.7136, 0.7152,\n", + " 0.7218, 0.7120, 0.7145, 0.7214, 0.7118, 0.7085, 0.7201, 0.7185, 0.7177,\n", + " 0.7173, 0.7171, 0.7170, 0.7170, 0.7170, 0.7169, 0.8010])\n", + "finalReturns: tensor([3.7693, 3.8534, 3.8131, 3.6807, 3.4974, 3.2750, 3.0098, 2.7226, 2.4190,\n", + " 2.1033, 1.7788, 1.4476, 1.1114, 0.7715, 0.4288])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 30, 30, 29, 30, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28,\n", + " 29, 29, 29, 29, 29, 28, 0])\n", + "loss= tensor(16.1739, grad_fn=) , base rewards= tensor([7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444, 7.4444,\n", + " 7.4444, 6.6425, 5.9655, 5.3753, 4.8462, 4.3607, 3.9066, 3.4755, 3.0611,\n", + " 2.6591, 2.2663, 1.8794, 1.4975, 1.1193, 0.7442, 0.3712]) return= 174131.5237391631\n", + "probs of actions: tensor([0.8230, 0.8277, 0.8443, 0.0909, 0.0966, 0.8673, 0.0717, 0.8321, 0.8166,\n", + " 0.8434, 0.8727, 0.8568, 0.7877, 0.8095, 0.7937, 0.8621, 0.8774, 0.0635,\n", + " 0.8763, 0.9007, 0.9587, 0.9444, 0.9358, 0.0460, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6713, 0.6954, 0.7136, 0.7093, 0.7206, 0.7187,\n", + " 0.7178, 0.7174, 0.7172, 0.7170, 0.7170, 0.7170, 0.7169, 0.7169, 0.7226,\n", + " 0.7125, 0.7147, 0.7158, 0.7164, 0.7166, 0.7225, 0.7965])\n", + "finalReturns: tensor([4.1104, 4.1945, 4.1540, 4.0271, 3.8392, 3.6077, 3.3448, 3.0590, 2.7564,\n", + " 2.4358, 2.1162, 1.7883, 1.4545, 1.1163, 0.7748, 0.4253])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(30.2489, grad_fn=) , base rewards= tensor([7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061, 7.8061,\n", + " 7.0063, 6.3304, 5.7406, 5.2108, 4.7243, 4.2693, 3.8374, 3.4231, 3.0216,\n", + " 2.6293, 2.2438, 1.8632, 1.4863, 1.1121, 0.7400, 0.3694]) return= 174058.37645850837\n", + "probs of actions: tensor([0.8582, 0.8629, 0.8798, 0.8764, 0.8638, 0.9002, 0.9004, 0.8670, 0.8585,\n", + " 0.0301, 0.9124, 0.8797, 0.8310, 0.0907, 0.8367, 0.8905, 0.9087, 0.8720,\n", + " 0.9059, 0.9327, 0.9686, 0.9607, 0.9600, 0.9044, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7220, 0.7121, 0.7145, 0.7157, 0.7104, 0.7211, 0.7190, 0.7180, 0.7174,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([4.4630, 4.5471, 4.5011, 4.3787, 4.1940, 3.9647, 3.7093, 3.4202, 3.1154,\n", + " 2.7989, 2.4738, 2.1422, 1.8057, 1.4656, 1.1228, 0.7779, 0.4316])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(4.4280, grad_fn=) , base rewards= tensor([8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 8.1717, 7.3731,\n", + " 6.6978, 6.1083, 5.5795, 5.0942, 4.6402, 4.2091, 3.7948, 3.3928, 2.9999,\n", + " 2.6139, 2.2329, 1.8557, 1.4813, 1.1089, 0.7382, 0.3687]) return= 174060.25019204617\n", + "probs of actions: tensor([0.9034, 0.9041, 0.9183, 0.9161, 0.9079, 0.9342, 0.9338, 0.9166, 0.9100,\n", + " 0.9035, 0.9549, 0.9257, 0.8960, 0.9082, 0.8750, 0.9167, 0.9458, 0.9095,\n", + " 0.9417, 0.9605, 0.9816, 0.9780, 0.9770, 0.9405, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([4.8121, 4.8962, 4.8558, 4.7290, 4.5412, 4.3098, 4.0469, 3.7611, 3.4586,\n", + " 3.1436, 2.8196, 2.4887, 2.1528, 1.8131, 1.4705, 1.1259, 0.7797, 0.4324])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 6 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 28, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(17.8648, grad_fn=) , base rewards= tensor([8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 8.5390, 7.7430, 7.0688,\n", + " 6.4798, 5.9513, 5.4661, 5.0122, 4.5811, 4.1668, 3.7648, 3.3719, 2.9859,\n", + " 2.6049, 2.2277, 1.8533, 1.4802, 1.1085, 0.7381, 0.3686]) return= 174029.23196541704\n", + "probs of actions: tensor([0.8938, 0.8960, 0.9100, 0.9065, 0.9003, 0.9289, 0.9158, 0.9051, 0.9186,\n", + " 0.8903, 0.9594, 0.9238, 0.8900, 0.9022, 0.8511, 0.9066, 0.9395, 0.9038,\n", + " 0.0062, 0.9561, 0.9805, 0.9749, 0.9774, 0.9416, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7226, 0.7125, 0.7147, 0.7158, 0.7164, 0.7166, 0.8009])\n", + "finalReturns: tensor([5.1535, 5.2376, 5.1974, 5.0707, 4.8829, 4.6515, 4.3887, 4.1029, 3.8004,\n", + " 3.4854, 3.1614, 2.8305, 2.4946, 2.1492, 1.8111, 1.4695, 1.1254, 0.7795,\n", + " 0.4323])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(2.6399, grad_fn=) , base rewards= tensor([8.8931, 8.8931, 8.8931, 8.8931, 8.8931, 8.8931, 8.1021, 7.4302, 6.8424,\n", + " 6.3143, 5.8294, 5.3756, 4.9445, 4.5302, 4.1283, 3.7354, 3.3494, 2.9684,\n", + " 2.5912, 2.2168, 1.8445, 1.4737, 1.1042, 0.7355, 0.3675]) return= 174060.25019204617\n", + "probs of actions: tensor([0.9462, 0.9455, 0.9555, 0.9534, 0.9488, 0.9645, 0.9683, 0.9549, 0.9581,\n", + " 0.9596, 0.9844, 0.9700, 0.9389, 0.9530, 0.9245, 0.9614, 0.9708, 0.9519,\n", + " 0.9705, 0.9807, 0.9920, 0.9906, 0.9916, 0.9737, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7144, 0.7157,\n", + " 0.7163, 0.7166, 0.7168, 0.7168, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([5.5094, 5.5935, 5.5535, 5.4270, 5.2393, 5.0080, 4.7452, 4.4594, 4.1569,\n", + " 3.8420, 3.5179, 3.1870, 2.8511, 2.5114, 2.1689, 1.8243, 1.4781, 1.1307,\n", + " 0.7824, 0.4335])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(32.6679, grad_fn=) , base rewards= tensor([9.2297, 9.2297, 9.2297, 9.2297, 9.2297, 8.4486, 7.7814, 7.1957, 6.6687,\n", + " 6.1842, 5.7315, 5.3016, 4.8883, 4.4871, 4.0950, 3.7094, 3.3296, 2.9536,\n", + " 2.5804, 2.2090, 1.8390, 1.4701, 1.1018, 0.7342, 0.3669]) return= 174121.3274714346\n", + "probs of actions: tensor([0.9370, 0.9376, 0.9482, 0.9457, 0.9450, 0.9597, 0.9723, 0.0570, 0.9488,\n", + " 0.9538, 0.9850, 0.9677, 0.9243, 0.0438, 0.9097, 0.9542, 0.9587, 0.9397,\n", + " 0.9704, 0.9754, 0.9915, 0.9905, 0.9908, 0.9710, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7119, 0.7085, 0.7201,\n", + " 0.7185, 0.7177, 0.7173, 0.7171, 0.7111, 0.7215, 0.7192, 0.7181, 0.7175,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([5.8759, 5.9600, 5.9204, 5.7942, 5.6126, 5.3770, 5.1112, 4.8233, 4.5193,\n", + " 4.2033, 3.8844, 3.5484, 3.2091, 2.8670, 2.5228, 2.1769, 1.8298, 1.4818,\n", + " 1.1331, 0.7838, 0.4341])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 30, 29, 29, 29, 29, 30, 29, 29, 29, 29, 30, 29, 29, 29, 30, 29,\n", + " 30, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(41.6779, grad_fn=) , base rewards= tensor([9.5587, 9.5587, 9.5587, 9.5587, 8.7930, 8.1329, 7.5505, 7.0251, 6.5414,\n", + " 6.0882, 5.6583, 5.2451, 4.8442, 4.4522, 4.0668, 3.6871, 3.3112, 2.9380,\n", + " 2.5667, 2.1975, 1.8295, 1.4630, 1.0971, 0.7314, 0.3657]) return= 174209.913456734\n", + "probs of actions: tensor([0.8751, 0.8809, 0.1046, 0.8975, 0.8943, 0.9066, 0.9349, 0.1239, 0.8953,\n", + " 0.9055, 0.9732, 0.9129, 0.1605, 0.9055, 0.8477, 0.9023, 0.0858, 0.8891,\n", + " 0.0721, 0.9442, 0.9840, 0.9776, 0.9772, 0.9326, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6325, 0.6815, 0.6991, 0.7080, 0.7125, 0.7088, 0.7203,\n", + " 0.7186, 0.7178, 0.7173, 0.7112, 0.7215, 0.7192, 0.7181, 0.7116, 0.7217,\n", + " 0.7134, 0.7226, 0.7198, 0.7183, 0.7176, 0.7173, 0.8012])\n", + "finalReturns: tensor([6.2388, 6.3229, 6.2839, 6.1583, 5.9712, 5.7461, 5.4791, 5.1904, 4.8858,\n", + " 4.5694, 4.2501, 3.9140, 3.5745, 3.2323, 2.8939, 2.5435, 2.1993, 1.8447,\n", + " 1.4914, 1.1390, 0.7871, 0.4355])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 30, 29, 29, 30, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 30, 0])\n", + "loss= tensor(40.5944, grad_fn=) , base rewards= tensor([9.8524, 9.8524, 9.8524, 9.1299, 8.4899, 7.9170, 7.3961, 6.9146, 6.4624,\n", + " 6.0330, 5.6201, 5.2193, 4.8281, 4.4437, 4.0642, 3.6881, 3.3147, 2.9431,\n", + " 2.5729, 2.2038, 1.8354, 1.4677, 1.1003, 0.7333, 0.3666]) return= 174107.14165860406\n", + "probs of actions: tensor([0.8416, 0.8520, 0.8595, 0.8623, 0.8794, 0.8895, 0.0793, 0.8476, 0.8646,\n", + " 0.1119, 0.9667, 0.8832, 0.7889, 0.8842, 0.7762, 0.8842, 0.8902, 0.8377,\n", + " 0.9165, 0.9302, 0.9792, 0.9674, 0.9688, 0.0917, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5639, 0.6384, 0.6772, 0.6969, 0.7069, 0.7060, 0.7189, 0.7179,\n", + " 0.7115, 0.7217, 0.7193, 0.7181, 0.7175, 0.7172, 0.7171, 0.7170, 0.7170,\n", + " 0.7169, 0.7169, 0.7169, 0.7169, 0.7169, 0.7110, 0.8055])\n", + "finalReturns: tensor([6.5673, 6.6514, 6.6142, 6.4902, 6.3042, 6.0797, 5.8130, 5.5245, 5.2259,\n", + " 4.9051, 4.5769, 4.2432, 3.9053, 3.5641, 3.2205, 2.8751, 2.5283, 2.1805,\n", + " 1.8319, 1.4827, 1.1331, 0.7832, 0.4389])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 30, 30, 29, 29, 29, 29, 30, 29, 29, 29, 29, 29, 30, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(54.3465, grad_fn=) , base rewards= tensor([10.0714, 10.0714, 9.4193, 8.8129, 8.2569, 7.7457, 7.2699, 6.8214,\n", + " 6.3935, 5.9812, 5.5814, 5.1904, 4.8059, 4.4262, 4.0499, 3.6762,\n", + " 3.3052, 2.9359, 2.5675, 2.1999, 1.8327, 1.4658, 1.0991, 0.7327,\n", + " 0.3663]) return= 174202.79502442433\n", + "probs of actions: tensor([0.2038, 0.1953, 0.1608, 0.8084, 0.8417, 0.8700, 0.8805, 0.2281, 0.8222,\n", + " 0.8522, 0.9632, 0.8519, 0.6879, 0.1521, 0.7490, 0.8204, 0.8533, 0.7903,\n", + " 0.8795, 0.8923, 0.9703, 0.9507, 0.9572, 0.8827, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5621, 0.6389, 0.6848, 0.7008, 0.7088, 0.7129, 0.7090, 0.7204,\n", + " 0.7187, 0.7178, 0.7174, 0.7171, 0.7111, 0.7215, 0.7192, 0.7181, 0.7175,\n", + " 0.7172, 0.7171, 0.7170, 0.7170, 0.7169, 0.7169, 0.8010])\n", + "finalReturns: tensor([6.9277, 7.0177, 6.9853, 6.8564, 6.6668, 6.4338, 6.1694, 5.8883, 5.5802,\n", + " 5.2614, 4.9345, 4.6017, 4.2643, 3.9294, 3.5817, 3.2335, 2.8847, 2.5356,\n", + " 2.1860, 1.8362, 1.4861, 1.1358, 0.7853, 0.4347])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([30, 29, 29, 30, 30, 29, 29, 29, 29, 30, 29, 29, 30, 29, 29, 29, 29, 29,\n", + " 29, 30, 29, 30, 29, 29, 0])\n", + "loss= tensor(69.6359, grad_fn=) , base rewards= tensor([10.1501, 9.6388, 9.1023, 8.5803, 8.0846, 7.6157, 7.1709, 6.7459,\n", + " 6.3358, 5.9369, 5.5462, 5.1617, 4.7827, 4.4073, 4.0344, 3.6641,\n", + " 3.2953, 2.9274, 2.5601, 2.1932, 1.8265, 1.4600, 1.0944, 0.7290,\n", + " 0.3645]) return= 174253.3722751547\n", + "probs of actions: tensor([0.2702, 0.7677, 0.7977, 0.2116, 0.2319, 0.8234, 0.8262, 0.7327, 0.7965,\n", + " 0.1930, 0.9485, 0.7959, 0.3707, 0.8006, 0.6535, 0.7538, 0.8028, 0.7528,\n", + " 0.8439, 0.1603, 0.9571, 0.0712, 0.9422, 0.8500, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5680, 0.6405, 0.6723, 0.6960, 0.7139, 0.7154, 0.7162, 0.7165,\n", + " 0.7108, 0.7213, 0.7191, 0.7121, 0.7220, 0.7194, 0.7182, 0.7176, 0.7172,\n", + " 0.7171, 0.7111, 0.7214, 0.7133, 0.7225, 0.7197, 0.8024])\n", + "finalReturns: tensor([7.2753, 7.3653, 7.3339, 7.2154, 7.0387, 6.8116, 6.5426, 6.2521, 5.9461,\n", + " 5.6285, 5.3083, 4.9715, 4.6314, 4.2947, 3.9456, 3.5965, 3.2471, 2.8974,\n", + " 2.5475, 2.1973, 1.8529, 1.4980, 1.1503, 0.7931, 0.4380])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0,[1e-05,1][1, 10000, 1, 1],1682423487 saved\n", + "[3000000, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 174210.39338284553, 57605.93776875555, 65.17557525634766, 1e-05, 1, 0, 'tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 29, 29, 29, 30, 29, 29,\\n 29, 30, 29, 29, 29, 29, 0])', '[0.69 0.75 0.77 0.78 0.75 0.8 0.8 0.7 0.77 0.2 0.06 0.24 0.6 0.77\\n 0.62 0.27 0.78 0.72 0.82 0.18 0.95 0.92 0.94 0.84 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1682423487', 25, 50, 174199.95044967832, 226157.05867704182, 94851.05074168817, 131012.56797668608, 127973.03513660273, 64641.60648389723, 62848.849838023714, 78979.431849868, 79951.69168142487, 109515.23673882235, 64159.865982403535, 79875.30170982817]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625]) return= 140290.89393391204\n", + "probs of actions: tensor([0.9195, 0.0062, 0.9061, 0.9295, 0.9160, 0.9197, 0.9265, 0.9012, 0.8971,\n", + " 0.9135, 0.9181, 0.9058, 0.9080, 0.9095, 0.0020, 0.9082, 0.9207, 0.9140,\n", + " 0.9216, 0.8805, 0.9001, 0.9244, 0.8986, 0.9275, 0.9888],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5350, 0.5644, 0.5634, 0.5630, 0.5627, 0.5626, 0.5626, 0.5625,\n", + " 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5589, 0.5852, 0.5738, 0.5681,\n", + " 0.5653, 0.5639, 0.5632, 0.5629, 0.5627, 0.5626, 0.5625])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([17, 0, 1, 22, 8, 0, 9, 17, 19, 7, 14, 7, 0, 1, 14, 0, 7, 1,\n", + " 0, 10, 17, 0, 2, 21, 0])\n", + "loss= tensor(0.1059, grad_fn=) , base rewards= tensor([1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688,\n", + " 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688,\n", + " 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 1.1688, 0.5770]) return= 150673.14503249113\n", + "probs of actions: tensor([0.0195, 0.3042, 0.0644, 0.0075, 0.0056, 0.3819, 0.0345, 0.0280, 0.0135,\n", + " 0.0520, 0.0902, 0.0551, 0.2481, 0.0579, 0.0623, 0.3358, 0.0548, 0.0627,\n", + " 0.5367, 0.0444, 0.0219, 0.4604, 0.0402, 0.0654, 0.9866],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.6006, 0.5813, 0.5273, 0.6487, 0.6395, 0.5923, 0.5872, 0.6199,\n", + " 0.6798, 0.6304, 0.6563, 0.6385, 0.5998, 0.5653, 0.6279, 0.5898, 0.6053,\n", + " 0.5876, 0.5650, 0.5782, 0.6514, 0.6057, 0.5477, 0.6596])\n", + "finalReturns: tensor([0.0384, 0.0825])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([23, 19, 13, 24, 23, 1, 23, 25, 24, 24, 23, 17, 24, 24, 13, 7, 21, 16,\n", + " 23, 23, 24, 23, 24, 24, 0])\n", + "loss= tensor(0.3284, grad_fn=) , base rewards= tensor([1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812,\n", + " 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.9812,\n", + " 1.9812, 1.9812, 1.9812, 1.9812, 1.9812, 1.2344, 0.5830]) return= 165779.32260088876\n", + "probs of actions: tensor([0.1627, 0.0385, 0.0941, 0.1479, 0.1835, 0.0145, 0.1909, 0.0031, 0.2096,\n", + " 0.1863, 0.2033, 0.2533, 0.2315, 0.1846, 0.2161, 0.0282, 0.0494, 0.0190,\n", + " 0.1273, 0.1832, 0.1901, 0.1711, 0.5221, 0.3500, 0.9898],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5880, 0.6514, 0.6087, 0.6580, 0.7293, 0.5944, 0.6343, 0.6732,\n", + " 0.6862, 0.6974, 0.7204, 0.6654, 0.6823, 0.7315, 0.7008, 0.6161, 0.6696,\n", + " 0.6391, 0.6670, 0.6764, 0.6925, 0.6892, 0.6942, 0.7544])\n", + "finalReturns: tensor([0.1566, 0.2142, 0.1714])\n", + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 24, 24, 19, 24, 24, 24, 24, 17, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 23, 0])\n", + "loss= tensor(0.6763, grad_fn=) , base rewards= tensor([2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329,\n", + " 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329, 2.5329,\n", + " 2.5329, 2.5329, 2.5329, 2.5329, 1.7760, 1.1199, 0.5347]) return= 169798.62492291527\n", + "probs of actions: tensor([0.7248, 0.6904, 0.7508, 0.0141, 0.7384, 0.7358, 0.8043, 0.6820, 0.0194,\n", + " 0.7494, 0.7018, 0.6975, 0.7651, 0.7216, 0.7007, 0.7041, 0.7644, 0.6917,\n", + " 0.7048, 0.7520, 0.7286, 0.8208, 0.8729, 0.1889, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5705, 0.6334, 0.6875, 0.6612, 0.6801, 0.6897, 0.6945, 0.7256,\n", + " 0.6680, 0.6836, 0.6914, 0.6953, 0.6973, 0.6983, 0.6988, 0.6991, 0.6992,\n", + " 0.6992, 0.6993, 0.6993, 0.6993, 0.6993, 0.7040, 0.7526])\n", + "finalReturns: tensor([0.3222, 0.3798, 0.3366, 0.2178])\n", + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([24, 24, 28, 24, 23, 16, 24, 28, 24, 24, 24, 24, 24, 28, 23, 23, 24, 23,\n", + " 24, 23, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.6225, grad_fn=) , base rewards= tensor([3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211,\n", + " 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211, 3.0211,\n", + " 3.0211, 3.0211, 3.0211, 2.2697, 1.6162, 1.0322, 0.4981]) return= 170179.017451197\n", + "probs of actions: tensor([0.6627, 0.6456, 0.1464, 0.6529, 0.1292, 0.0016, 0.7567, 0.1929, 0.6563,\n", + " 0.6988, 0.6466, 0.6345, 0.7108, 0.1598, 0.1356, 0.1445, 0.7143, 0.1483,\n", + " 0.6384, 0.1183, 0.6669, 0.7142, 0.8405, 0.7487, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5705, 0.6126, 0.6831, 0.6959, 0.7229, 0.6608, 0.6591, 0.7070,\n", + " 0.7031, 0.7012, 0.7003, 0.6998, 0.6787, 0.7216, 0.7084, 0.6972, 0.7029,\n", + " 0.6944, 0.7016, 0.6937, 0.6965, 0.6979, 0.6986, 0.7566])\n", + "finalReturns: tensor([0.5223, 0.5799, 0.5369, 0.4229, 0.2585])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 24,\n", + " 28, 28, 28, 28, 28, 24, 0])\n", + "loss= tensor(1.3065, grad_fn=) , base rewards= tensor([3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129,\n", + " 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129, 3.5129,\n", + " 3.5129, 3.5129, 2.7297, 2.0614, 1.4742, 0.9450, 0.4574]) return= 173274.47945104944\n", + "probs of actions: tensor([0.8751, 0.8362, 0.8357, 0.8808, 0.8721, 0.8655, 0.8324, 0.8766, 0.8592,\n", + " 0.8549, 0.8751, 0.8901, 0.8497, 0.8566, 0.8846, 0.8587, 0.8459, 0.0844,\n", + " 0.8948, 0.8662, 0.9174, 0.9180, 0.8195, 0.2077, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7345,\n", + " 0.6960, 0.7048, 0.7093, 0.7115, 0.7126, 0.7339, 0.7741])\n", + "finalReturns: tensor([0.8333, 0.9117, 0.8708, 0.7464, 0.5631, 0.3168])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.1852, grad_fn=) , base rewards= tensor([3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647,\n", + " 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647, 3.9647,\n", + " 3.9647, 3.1726, 2.5002, 1.9112, 1.3810, 0.8930, 0.4354]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9707, 0.9563, 0.9583, 0.9732, 0.9703, 0.9683, 0.9593, 0.9722, 0.9662,\n", + " 0.9654, 0.9716, 0.9762, 0.9634, 0.9665, 0.9740, 0.9665, 0.9630, 0.9683,\n", + " 0.9812, 0.9737, 0.9835, 0.9850, 0.9637, 0.8965, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([1.1096, 1.1880, 1.1467, 1.0220, 0.8385, 0.6128, 0.3567])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 17 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 24, 0])\n", + "loss= tensor(2.0490, grad_fn=) , base rewards= tensor([4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838,\n", + " 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838, 4.3838,\n", + " 3.5917, 2.9193, 2.3303, 1.8001, 1.3121, 0.8545, 0.4191]) return= 173418.33352108797\n", + "probs of actions: tensor([0.9850, 0.9761, 0.9782, 0.9864, 0.9851, 0.9837, 0.9794, 0.9861, 0.9826,\n", + " 0.9821, 0.9857, 0.9883, 0.9811, 0.9831, 0.9868, 0.9828, 0.9808, 0.9828,\n", + " 0.9931, 0.9881, 0.9930, 0.9938, 0.9869, 0.0494, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7345, 0.7744])\n", + "finalReturns: tensor([1.4073, 1.4857, 1.4444, 1.3197, 1.1362, 0.9105, 0.6544, 0.3553])\n", + "----------------------------------------\n", + "iter 2 stage 16 ep 99999 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0740, grad_fn=) , base rewards= tensor([4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909,\n", + " 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 4.7909, 3.9988,\n", + " 3.3264, 2.7373, 2.2072, 1.7191, 1.2616, 0.8262, 0.4071]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9933, 0.9884, 0.9898, 0.9939, 0.9933, 0.9926, 0.9907, 0.9940, 0.9921,\n", + " 0.9919, 0.9937, 0.9949, 0.9914, 0.9925, 0.9942, 0.9922, 0.9930, 0.9938,\n", + " 0.9980, 0.9958, 0.9973, 0.9978, 0.9959, 0.9567, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([1.7108, 1.7892, 1.7479, 1.6233, 1.4397, 1.2141, 0.9579, 0.6796, 0.3850])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 52341 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891,\n", + " 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 5.1891, 4.3970, 3.7246,\n", + " 3.1355, 2.6054, 2.1173, 1.6598, 1.2244, 0.8053, 0.3982]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9987, 0.9975, 0.9980, 0.9989, 0.9988, 0.9986, 0.9983, 0.9989, 0.9985,\n", + " 0.9985, 0.9988, 0.9991, 0.9984, 0.9986, 0.9990, 0.9990, 0.9989, 0.9991,\n", + " 0.9998, 0.9995, 0.9998, 0.9999, 0.9996, 0.9912, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([2.0263, 2.1047, 2.0634, 1.9388, 1.7552, 1.5296, 1.2734, 0.9951, 0.7005,\n", + " 0.3939])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 17 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 5.5806,\n", + " 5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 5.5806, 4.7886, 4.1162, 3.5271,\n", + " 2.9969, 2.5089, 2.0513, 1.6160, 1.1969, 0.7898, 0.3916]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9987, 0.9975, 0.9980, 0.9989, 0.9988, 0.9986, 0.9983, 0.9989, 0.9985,\n", + " 0.9985, 0.9989, 0.9991, 0.9984, 0.9986, 0.9990, 0.9990, 0.9989, 0.9991,\n", + " 0.9998, 0.9995, 0.9998, 0.9999, 0.9996, 0.9913, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([2.3484, 2.4268, 2.3855, 2.2609, 2.0774, 1.8517, 1.5956, 1.3172, 1.0226,\n", + " 0.7160, 0.4005])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 4970 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0175, grad_fn=) , base rewards= tensor([5.9673, 5.9673, 5.9673, 5.9673, 5.9673, 5.9673, 5.9673, 5.9673, 5.9673,\n", + " 5.9673, 5.9673, 5.9673, 5.9673, 5.9673, 5.1752, 4.5028, 3.9138, 3.3836,\n", + " 2.8956, 2.4380, 2.0026, 1.5835, 1.1764, 0.7783, 0.3867]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9990, 0.9979, 0.9984, 0.9991, 0.9990, 0.9989, 0.9986, 0.9991, 0.9988,\n", + " 0.9988, 0.9991, 0.9993, 0.9987, 0.9990, 0.9992, 0.9992, 0.9992, 0.9993,\n", + " 0.9999, 0.9996, 0.9999, 0.9999, 0.9997, 0.9930, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([2.6755, 2.7539, 2.7126, 2.5879, 2.4044, 2.1787, 1.9226, 1.6443, 1.3497,\n", + " 1.0431, 0.7275, 0.4054])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 205 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0208, grad_fn=) , base rewards= tensor([6.3502, 6.3502, 6.3502, 6.3502, 6.3502, 6.3502, 6.3502, 6.3502, 6.3502,\n", + " 6.3502, 6.3502, 6.3502, 6.3502, 5.5582, 4.8858, 4.2968, 3.7666, 3.2786,\n", + " 2.8210, 2.3856, 1.9665, 1.5594, 1.1613, 0.7697, 0.3830]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9990, 0.9980, 0.9985, 0.9991, 0.9990, 0.9989, 0.9987, 0.9992, 0.9988,\n", + " 0.9988, 0.9991, 0.9993, 0.9990, 0.9990, 0.9993, 0.9992, 0.9992, 0.9993,\n", + " 0.9999, 0.9996, 0.9999, 0.9999, 0.9997, 0.9933, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([3.0062, 3.0846, 3.0433, 2.9186, 2.7351, 2.5094, 2.2533, 1.9750, 1.6804,\n", + " 1.3738, 1.0582, 0.7361, 0.4091])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0242, grad_fn=) , base rewards= tensor([6.7303, 6.7303, 6.7303, 6.7303, 6.7303, 6.7303, 6.7303, 6.7303, 6.7303,\n", + " 6.7303, 6.7303, 6.7303, 5.9384, 5.2660, 4.6770, 4.1469, 3.6588, 3.2013,\n", + " 2.7659, 2.3468, 1.9397, 1.5415, 1.1499, 0.7633, 0.3803]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9990, 0.9980, 0.9985, 0.9991, 0.9990, 0.9989, 0.9987, 0.9992, 0.9988,\n", + " 0.9988, 0.9991, 0.9993, 0.9990, 0.9990, 0.9993, 0.9992, 0.9992, 0.9993,\n", + " 0.9999, 0.9996, 0.9999, 0.9999, 0.9997, 0.9933, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([3.3396, 3.4180, 3.3767, 3.2521, 3.0685, 2.8429, 2.5867, 2.3084, 2.0138,\n", + " 1.7072, 1.3917, 1.0696, 0.7425, 0.4118])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0286, grad_fn=) , base rewards= tensor([7.1082, 7.1082, 7.1082, 7.1082, 7.1082, 7.1082, 7.1082, 7.1082, 7.1082,\n", + " 7.1082, 7.1082, 6.3164, 5.6442, 5.0552, 4.5251, 4.0370, 3.5795, 3.1441,\n", + " 2.7250, 2.3179, 1.9197, 1.5281, 1.1415, 0.7585, 0.3782]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9990, 0.9980, 0.9985, 0.9991, 0.9990, 0.9989, 0.9987, 0.9992, 0.9988,\n", + " 0.9988, 0.9991, 0.9993, 0.9990, 0.9990, 0.9993, 0.9992, 0.9992, 0.9993,\n", + " 0.9999, 0.9996, 0.9999, 0.9999, 0.9997, 0.9933, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([3.6751, 3.7535, 3.7122, 3.5875, 3.4040, 3.1783, 2.9222, 2.6439, 2.3493,\n", + " 2.0427, 1.7272, 1.4051, 1.0780, 0.7473, 0.4139])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 9 ep 72 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0319, grad_fn=) , base rewards= tensor([7.4843, 7.4843, 7.4843, 7.4843, 7.4843, 7.4843, 7.4843, 7.4843, 7.4843,\n", + " 7.4843, 6.6929, 6.0207, 5.4318, 4.9017, 4.4137, 3.9561, 3.5208, 3.1017,\n", + " 2.6946, 2.2964, 1.9048, 1.5181, 1.1352, 0.7549, 0.3767]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9990, 0.9981, 0.9985, 0.9992, 0.9991, 0.9989, 0.9988, 0.9992, 0.9989,\n", + " 0.9990, 0.9992, 0.9994, 0.9991, 0.9991, 0.9993, 0.9993, 0.9992, 0.9994,\n", + " 0.9999, 0.9996, 0.9999, 1.0000, 0.9997, 0.9935, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([4.0120, 4.0904, 4.0492, 3.9245, 3.7410, 3.5154, 3.2592, 2.9809, 2.6863,\n", + " 2.3797, 2.0642, 1.7421, 1.4151, 1.0843, 0.7509, 0.4154])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 58 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0356, grad_fn=) , base rewards= tensor([7.8587, 7.8587, 7.8587, 7.8587, 7.8587, 7.8587, 7.8587, 7.8587, 7.8587,\n", + " 7.0679, 6.3960, 5.8072, 5.2772, 4.7892, 4.3317, 3.8963, 3.4772, 3.0701,\n", + " 2.6719, 2.2803, 1.8937, 1.5107, 1.1304, 0.7522, 0.3755]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9981, 0.9986, 0.9992, 0.9991, 0.9990, 0.9988, 0.9992, 0.9990,\n", + " 0.9991, 0.9993, 0.9995, 0.9991, 0.9991, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9997, 0.9937, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([4.3501, 4.4285, 4.3873, 4.2627, 4.0792, 3.8535, 3.5974, 3.3191, 3.0245,\n", + " 2.7179, 2.4024, 2.0803, 1.7532, 1.4225, 1.0891, 0.7536, 0.4166])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0404, grad_fn=) , base rewards= tensor([8.2311, 8.2311, 8.2311, 8.2311, 8.2311, 8.2311, 8.2311, 8.2311, 7.4415,\n", + " 6.7702, 6.1817, 5.6517, 5.1638, 4.7063, 4.2709, 3.8519, 3.4448, 3.0466,\n", + " 2.6550, 2.2684, 1.8854, 1.5051, 1.1269, 0.7502, 0.3747]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9981, 0.9986, 0.9992, 0.9991, 0.9990, 0.9988, 0.9992, 0.9990,\n", + " 0.9991, 0.9993, 0.9995, 0.9991, 0.9991, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9937, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([4.6890, 4.7674, 4.7262, 4.6016, 4.4182, 4.1925, 3.9364, 3.6581, 3.3635,\n", + " 3.0569, 2.7414, 2.4193, 2.0922, 1.7615, 1.4281, 1.0926, 0.7556, 0.4174])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 80 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0427, grad_fn=) , base rewards= tensor([8.6006, 8.6006, 8.6006, 8.6006, 8.6006, 8.6006, 8.6006, 7.8134, 7.1432,\n", + " 6.5552, 6.0255, 5.5377, 5.0803, 4.6449, 4.2259, 3.8188, 3.4206, 3.0290,\n", + " 2.6424, 2.2594, 1.8791, 1.5009, 1.1242, 0.7487, 0.3740]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9982, 0.9986, 0.9992, 0.9992, 0.9990, 0.9990, 0.9994, 0.9991,\n", + " 0.9992, 0.9994, 0.9995, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([5.0284, 5.1068, 5.0657, 4.9412, 4.7578, 4.5322, 4.2761, 3.9978, 3.7032,\n", + " 3.3966, 3.0811, 2.7589, 2.4319, 2.1012, 1.7678, 1.4323, 1.0953, 0.7571,\n", + " 0.4181])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0490, grad_fn=) , base rewards= tensor([8.9651, 8.9651, 8.9651, 8.9651, 8.9651, 8.9651, 8.1827, 7.5147, 6.9278,\n", + " 6.3986, 5.9111, 5.4537, 5.0184, 4.5994, 4.1923, 3.7942, 3.4026, 3.0159,\n", + " 2.6329, 2.2527, 1.8745, 1.4978, 1.1222, 0.7476, 0.3735]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9982, 0.9986, 0.9992, 0.9992, 0.9990, 0.9990, 0.9994, 0.9991,\n", + " 0.9992, 0.9994, 0.9995, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([5.3679, 5.4463, 5.4054, 5.2811, 5.0978, 4.8722, 4.6162, 4.3379, 4.0433,\n", + " 3.7367, 3.4212, 3.0991, 2.7721, 2.4414, 2.1079, 1.7724, 1.4354, 1.0973,\n", + " 0.7582, 0.4186])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0550, grad_fn=) , base rewards= tensor([9.3201, 9.3201, 9.3201, 9.3201, 9.3201, 8.5474, 7.8839, 7.2990, 6.7709,\n", + " 6.2838, 5.8267, 5.3915, 4.9725, 4.5655, 4.1673, 3.7758, 3.3891, 3.0061,\n", + " 2.6259, 2.2476, 1.8710, 1.4954, 1.1208, 0.7467, 0.3732]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9982, 0.9986, 0.9992, 0.9992, 0.9990, 0.9990, 0.9994, 0.9991,\n", + " 0.9992, 0.9994, 0.9995, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([5.7072, 5.7856, 5.7451, 5.6211, 5.4380, 5.2126, 4.9566, 4.6784, 4.3838,\n", + " 4.0772, 3.7617, 3.4396, 3.1126, 2.7819, 2.4484, 2.1130, 1.7759, 1.4378,\n", + " 1.0987, 0.7591, 0.4189])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0607, grad_fn=) , base rewards= tensor([9.6570, 9.6570, 9.6570, 9.6570, 8.9034, 8.2488, 7.6681, 7.1419, 6.6558,\n", + " 6.1991, 5.7642, 5.3453, 4.9384, 4.5402, 4.1487, 3.7620, 3.3790, 2.9988,\n", + " 2.6206, 2.2439, 1.8683, 1.4937, 1.1196, 0.7461, 0.3729]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9982, 0.9986, 0.9992, 0.9992, 0.9990, 0.9990, 0.9994, 0.9991,\n", + " 0.9992, 0.9994, 0.9995, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([6.0455, 6.1239, 6.0842, 5.9609, 5.7782, 5.5531, 5.2972, 5.0191, 4.7246,\n", + " 4.4180, 4.1025, 3.7804, 3.4534, 3.1227, 2.7892, 2.4537, 2.1167, 1.7786,\n", + " 1.4395, 1.0999, 0.7597, 0.4192])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 2 ep 339 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0615, grad_fn=) , base rewards= tensor([9.9587, 9.9587, 9.9587, 9.2425, 8.6055, 8.0331, 7.5109, 7.0267, 6.5710,\n", + " 6.1365, 5.7178, 5.3110, 4.9129, 4.5213, 4.1347, 3.7517, 3.3715, 2.9933,\n", + " 2.6166, 2.2411, 1.8664, 1.4924, 1.1188, 0.7456, 0.3727]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9991, 0.9983, 0.9990, 0.9994, 0.9992, 0.9990, 0.9992, 0.9995, 0.9993,\n", + " 0.9993, 0.9994, 0.9996, 0.9993, 0.9992, 0.9993, 0.9993, 0.9993, 0.9994,\n", + " 0.9999, 0.9997, 0.9999, 1.0000, 0.9998, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([6.3816, 6.4600, 6.4218, 6.2998, 6.1181, 5.8934, 5.6379, 5.3599, 5.0655,\n", + " 4.7589, 4.4435, 4.1214, 3.7944, 3.4637, 3.1302, 2.7947, 2.4577, 2.1195,\n", + " 1.7805, 1.4408, 1.1007, 0.7602, 0.4194])\n", + "----------------------------------------\n", + "iter 2 stage 1 ep 14789 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0368, grad_fn=) , base rewards= tensor([10.1929, 10.1929, 9.5489, 8.9464, 8.3904, 7.8761, 7.3956, 6.9417,\n", + " 6.5082, 6.0900, 5.6833, 5.2853, 4.8939, 4.5072, 4.1243, 3.7440,\n", + " 3.3658, 2.9891, 2.6136, 2.2389, 1.8649, 1.4914, 1.1182, 0.7453,\n", + " 0.3726]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9995, 0.9998, 0.9995, 0.9994, 0.9997, 0.9999, 0.9997,\n", + " 1.0000, 0.9997, 1.0000, 0.9996, 0.9996, 0.9996, 0.9996, 0.9996, 0.9998,\n", + " 1.0000, 0.9999, 1.0000, 1.0000, 0.9999, 0.9959, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([6.7130, 6.7914, 6.7562, 6.6369, 6.4569, 6.2333, 5.9784, 5.7007, 5.4064,\n", + " 5.1000, 4.7846, 4.4625, 4.1355, 3.8048, 3.4714, 3.1359, 2.7989, 2.4607,\n", + " 2.1217, 1.7820, 1.4418, 1.1013, 0.7605, 0.4195])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 0 adversary: AdversaryModes.myopic\n", + " actions: tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\n", + " 28, 28, 28, 28, 28, 28, 0])\n", + "loss= tensor(0.0418, grad_fn=) , base rewards= tensor([10.3041, 9.7929, 9.2563, 8.7325, 8.2337, 7.7608, 7.3106, 6.8789,\n", + " 6.4615, 6.0553, 5.6576, 5.2662, 4.8796, 4.4967, 4.1164, 3.7383,\n", + " 3.3616, 2.9860, 2.6114, 2.2374, 1.8638, 1.4906, 1.1177, 0.7450,\n", + " 0.3724]) return= 173387.3335190018\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9995, 0.9998, 0.9995, 0.9994, 0.9997, 0.9999, 0.9997,\n", + " 1.0000, 0.9997, 1.0000, 0.9996, 0.9996, 0.9996, 0.9996, 0.9996, 0.9998,\n", + " 1.0000, 0.9999, 1.0000, 1.0000, 0.9999, 0.9959, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4328, 0.5656, 0.6377, 0.6752, 0.6944, 0.7040, 0.7088, 0.7113, 0.7125,\n", + " 0.7131, 0.7134, 0.7135, 0.7136, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137,\n", + " 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7137, 0.7921])\n", + "finalReturns: tensor([7.0346, 7.1130, 7.0840, 6.9701, 6.7936, 6.5721, 6.3183, 6.0413, 5.7473,\n", + " 5.4411, 5.1257, 4.8037, 4.4767, 4.1460, 3.8126, 3.4771, 3.1401, 2.8019,\n", + " 2.4629, 2.1232, 1.7831, 1.4426, 1.1018, 0.7608, 0.4197])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682452608 saved\n", + "[1152887, 'tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 173387.3335190018, 58923.33323528369, 0.041793305426836014, 1e-05, 1, 0, 'tensor([28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,\\n 28, 28, 28, 28, 28, 28, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682452608', 25, 50, 173387.33351900178, 222740.53173358264, 93054.95743178323, 131763.112, 128763.66666666667, 68687.38784334851, 68702.99934306633, 84336.85885052304, 84336.85885052304, 107493.35770590571, 68702.99934306633, 84336.85885052304]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662,\n", + " 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662,\n", + " 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662]) return= 138591.14106947038\n", + "probs of actions: tensor([0.9412, 0.9369, 0.9014, 0.9244, 0.9103, 0.9282, 0.9200, 0.9465, 0.9221,\n", + " 0.9313, 0.9320, 0.9221, 0.9166, 0.9288, 0.9280, 0.9255, 0.9292, 0.9279,\n", + " 0.9284, 0.9441, 0.9064, 0.9456, 0.9071, 0.0328, 0.9943],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5613, 0.5616, 0.5618, 0.5620, 0.5621,\n", + " 0.5622, 0.5623, 0.5623, 0.5624, 0.5624, 0.5623, 0.5662])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 1, 0, 23, 15, 2, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 14, 1, 0,\n", + " 13, 1, 1, 3, 0, 15, 0])\n", + "loss= tensor(0.0938, grad_fn=) , base rewards= tensor([1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960,\n", + " 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960,\n", + " 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 1.1960, 0.5929]) return= 150337.40439247817\n", + "probs of actions: tensor([0.0699, 0.5186, 0.0031, 0.0702, 0.0520, 0.4937, 0.4496, 0.6094, 0.4886,\n", + " 0.5172, 0.5479, 0.4457, 0.5186, 0.0648, 0.4107, 0.0057, 0.0700, 0.4843,\n", + " 0.0029, 0.0619, 0.0670, 0.0427, 0.5052, 0.0788, 0.9895],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5274, 0.4832, 0.6082, 0.6730, 0.6528, 0.6296, 0.6125, 0.5998,\n", + " 0.5903, 0.5833, 0.5781, 0.5742, 0.5487, 0.6270, 0.5910, 0.6536, 0.6343,\n", + " 0.5990, 0.6537, 0.6342, 0.6190, 0.6170, 0.5807, 0.6520])\n", + "finalReturns: tensor([0.0367, 0.0592])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 0, 22, 22, 22, 18, 23, 22, 22, 27, 22, 22, 21, 22, 26, 22, 0, 17, 0,\n", + " 22, 22, 16, 0, 28, 22, 0])\n", + "loss= tensor(0.8564, grad_fn=) , base rewards= tensor([2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470,\n", + " 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 2.1470,\n", + " 2.1470, 2.1470, 2.1470, 2.1470, 2.1470, 1.3829, 0.6721]) return= 193459.92049804344\n", + "probs of actions: tensor([0.2512, 0.3682, 0.3488, 0.2969, 0.0235, 0.0110, 0.3700, 0.3502, 0.0278,\n", + " 0.3349, 0.3164, 0.0416, 0.3236, 0.0325, 0.4630, 0.1016, 0.0405, 0.1303,\n", + " 0.3723, 0.4079, 0.0380, 0.3571, 0.0170, 0.6691, 0.9944],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4754, 0.5683, 0.6430, 0.7178, 0.7252, 0.7735, 0.8025, 0.8000,\n", + " 0.8650, 0.8719, 0.8813, 0.8760, 0.8609, 0.9026, 0.9485, 0.8137, 0.8435,\n", + " 0.7196, 0.7612, 0.8159, 0.8381, 0.6857, 0.7853, 0.8599])\n", + "finalReturns: tensor([0.1839, 0.2623, 0.1878])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 22, 19, 30, 30, 30, 27, 20, 27, 30, 28, 30, 30, 26, 30, 26, 22,\n", + " 30, 24, 30, 24, 17, 27, 0])\n", + "loss= tensor(4.5377, grad_fn=) , base rewards= tensor([3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209,\n", + " 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209, 3.5209,\n", + " 3.5209, 3.5209, 3.5209, 3.5209, 2.4752, 1.5642, 0.7482]) return= 219456.57013693356\n", + "probs of actions: tensor([0.3420, 0.3385, 0.2044, 0.0172, 0.4148, 0.3398, 0.4331, 0.0786, 0.0263,\n", + " 0.0908, 0.4014, 0.0236, 0.3730, 0.3527, 0.1123, 0.3745, 0.1065, 0.2665,\n", + " 0.3297, 0.0252, 0.3049, 0.0192, 0.0083, 0.0535, 0.9814],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6939, 0.7536, 0.7227, 0.7910, 0.8441, 0.9020, 0.9510,\n", + " 0.8956, 0.8963, 0.9363, 0.9362, 0.9550, 0.9916, 0.9594, 0.9949, 1.0034,\n", + " 0.9335, 0.9854, 0.9371, 0.9881, 1.0002, 0.9088, 0.9963])\n", + "finalReturns: tensor([0.3725, 0.4301, 0.3409, 0.2480])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 27, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.1581, grad_fn=) , base rewards= tensor([4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714,\n", + " 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714, 4.3714,\n", + " 4.3714, 4.3714, 4.3714, 3.2718, 2.3232, 1.4805, 0.7132]) return= 228028.54094405496\n", + "probs of actions: tensor([0.9125, 0.9169, 0.9037, 0.9342, 0.9368, 0.8968, 0.9510, 0.9254, 0.0124,\n", + " 0.9645, 0.9396, 0.9534, 0.9234, 0.9067, 0.9477, 0.9371, 0.9293, 0.8873,\n", + " 0.8996, 0.9431, 0.9692, 0.9912, 0.9642, 0.8582, 0.9988],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9603,\n", + " 0.9450, 0.9617, 0.9743, 0.9838, 0.9909, 0.9963, 1.0003, 1.0034, 1.0056,\n", + " 1.0074, 1.0086, 1.0096, 1.0103, 1.0109, 1.0113, 1.1016])\n", + "finalReturns: tensor([0.7723, 0.8623, 0.8006, 0.6324, 0.3884])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0536, grad_fn=) , base rewards= tensor([5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447,\n", + " 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447, 5.0447,\n", + " 5.0447, 5.0447, 3.9452, 2.9968, 2.1542, 1.3869, 0.6738]) return= 228200.9420715731\n", + "probs of actions: tensor([0.9825, 0.9829, 0.0017, 0.9874, 0.9864, 0.9742, 0.9898, 0.9839, 0.9872,\n", + " 0.9938, 0.9878, 0.9901, 0.9837, 0.9793, 0.9897, 0.9861, 0.9859, 0.9749,\n", + " 0.9783, 0.9932, 0.9963, 0.9995, 0.9941, 0.9526, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6639, 0.7266, 0.7941, 0.8464, 0.8867, 0.9174, 0.9408,\n", + " 0.9585, 0.9719, 0.9820, 0.9895, 0.9953, 0.9996, 1.0028, 1.0052, 1.0070,\n", + " 1.0084, 1.0094, 1.0102, 1.0108, 1.0112, 1.0115, 1.1018])\n", + "finalReturns: tensor([1.1102, 1.2002, 1.1385, 0.9703, 0.7264, 0.4280])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 86927 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0098, grad_fn=) , base rewards= tensor([5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869,\n", + " 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869, 5.6869,\n", + " 5.6869, 4.5884, 3.6405, 2.7984, 2.0314, 1.3185, 0.6449]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9982, 0.9981, 0.9972, 0.9989, 0.9985, 0.9973, 0.9989, 0.9984, 0.9987,\n", + " 0.9994, 0.9987, 0.9990, 0.9983, 0.9981, 0.9990, 0.9985, 0.9986, 0.9974,\n", + " 0.9990, 0.9997, 1.0000, 1.0000, 0.9995, 0.9908, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([1.4768, 1.5668, 1.5052, 1.3371, 1.0932, 0.7948, 0.4569])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 20360 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0088, grad_fn=) , base rewards= tensor([6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064,\n", + " 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064, 6.3064,\n", + " 5.2092, 4.2623, 3.4208, 2.6543, 1.9417, 1.2684, 0.6236]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9995, 0.9992, 0.9992, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([1.8645, 1.9545, 1.8929, 1.7249, 1.4811, 1.1829, 0.8450, 0.4782])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0114, grad_fn=) , base rewards= tensor([6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087,\n", + " 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 6.9087, 5.8133,\n", + " 4.8675, 4.0269, 3.2610, 2.5489, 1.8759, 1.2314, 0.6079]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9995, 0.9992, 0.9992, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([2.2677, 2.3577, 2.2962, 2.1283, 1.8847, 1.5865, 1.2487, 0.8820, 0.4939])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0146, grad_fn=) , base rewards= tensor([7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973,\n", + " 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 7.4973, 6.4042, 5.4601,\n", + " 4.6206, 3.8555, 3.1440, 2.4714, 1.8273, 1.2040, 0.5963]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9995, 0.9992, 0.9992, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([2.6823, 2.7723, 2.7109, 2.5432, 2.2997, 2.0017, 1.6640, 1.2973, 0.9093,\n", + " 0.5055])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0173, grad_fn=) , base rewards= tensor([8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 8.0744,\n", + " 8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 8.0744, 6.9844, 6.0425, 5.2046,\n", + " 4.4406, 3.7299, 3.0579, 2.4141, 1.7912, 1.1837, 0.5876]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9995, 0.9992, 0.9992, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([3.1051, 3.1951, 3.1339, 2.9664, 2.7231, 2.4253, 2.0878, 1.7213, 1.3334,\n", + " 0.9296, 0.5142])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 13 ep 2683 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0196, grad_fn=) , base rewards= tensor([8.6415, 8.6415, 8.6415, 8.6415, 8.6415, 8.6415, 8.6415, 8.6415, 8.6415,\n", + " 8.6415, 8.6415, 8.6415, 8.6415, 8.6415, 7.5556, 6.6166, 5.7807, 5.0182,\n", + " 4.3086, 3.6373, 2.9942, 2.3717, 1.7645, 1.1686, 0.5812]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([3.5339, 3.6239, 3.5629, 3.3957, 3.1527, 2.8552, 2.5179, 2.1515, 1.7637,\n", + " 1.3601, 0.9448, 0.5206])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0243, grad_fn=) , base rewards= tensor([9.1989, 9.1989, 9.1989, 9.1989, 9.1989, 9.1989, 9.1989, 9.1989, 9.1989,\n", + " 9.1989, 9.1989, 9.1989, 9.1989, 8.1186, 7.1834, 6.3502, 5.5897, 4.8815,\n", + " 4.2112, 3.5688, 2.9469, 2.3401, 1.7445, 1.1573, 0.5763]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([3.9668, 4.0568, 3.9962, 3.8293, 3.5867, 3.2895, 2.9525, 2.5864, 2.1988,\n", + " 1.7953, 1.3801, 0.9560, 0.5255])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0279, grad_fn=) , base rewards= tensor([9.7463, 9.7463, 9.7463, 9.7463, 9.7463, 9.7463, 9.7463, 9.7463, 9.7463,\n", + " 9.7463, 9.7463, 9.7463, 8.6733, 7.7432, 6.9137, 6.1557, 5.4494, 4.7805,\n", + " 4.1391, 3.5180, 2.9117, 2.3166, 1.7297, 1.1489, 0.5727]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([4.4025, 4.4925, 4.4322, 4.2659, 4.0238, 3.7270, 3.3904, 3.0246, 2.6373,\n", + " 2.2340, 1.8189, 1.3949, 0.9645, 0.5291])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0325, grad_fn=) , base rewards= tensor([10.2824, 10.2824, 10.2824, 10.2824, 10.2824, 10.2824, 10.2824, 10.2824,\n", + " 10.2824, 10.2824, 10.2824, 9.2192, 8.2959, 7.4712, 6.7167, 6.0129,\n", + " 5.3459, 4.7058, 4.0856, 3.4801, 2.8855, 2.2990, 1.7185, 1.1426,\n", + " 0.5700]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([4.8396, 4.9296, 4.8698, 4.7042, 4.4628, 4.1667, 3.8306, 3.4652, 3.0782,\n", + " 2.6751, 2.2602, 1.8364, 1.4061, 0.9708, 0.5318])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0354, grad_fn=) , base rewards= tensor([10.8052, 10.8052, 10.8052, 10.8052, 10.8052, 10.8052, 10.8052, 10.8052,\n", + " 10.8052, 10.8052, 9.7549, 8.8407, 8.0224, 7.2725, 6.5720, 5.9074,\n", + " 5.2692, 4.6503, 4.0457, 3.4519, 2.8659, 2.2859, 1.7102, 1.1379,\n", + " 0.5680]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([5.2771, 5.3671, 5.3080, 5.1433, 4.9029, 4.6075, 4.2721, 3.9073, 3.5207,\n", + " 3.1180, 2.7034, 2.2798, 1.8496, 1.4144, 0.9755, 0.5338])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0407, grad_fn=) , base rewards= tensor([11.3115, 11.3115, 11.3115, 11.3115, 11.3115, 11.3115, 11.3115, 11.3115,\n", + " 11.3115, 10.2783, 9.3761, 8.5663, 7.8226, 7.1265, 6.4652, 5.8293,\n", + " 5.2122, 4.6089, 4.0160, 3.4308, 2.8513, 2.2760, 1.7040, 1.1344,\n", + " 0.5665]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([5.7139, 5.8039, 5.7458, 5.5824, 5.3432, 5.0489, 4.7144, 4.3503, 3.9643,\n", + " 3.5620, 3.1477, 2.7244, 2.2944, 1.8594, 1.4206, 0.9790, 0.5353])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0468, grad_fn=) , base rewards= tensor([11.7970, 11.7970, 11.7970, 11.7970, 11.7970, 11.7970, 11.7970, 11.7970,\n", + " 10.7864, 9.9001, 9.1016, 8.3659, 7.6757, 7.0187, 6.3860, 5.7712,\n", + " 5.1697, 4.5781, 3.9938, 3.4150, 2.8403, 2.2687, 1.6994, 1.1317,\n", + " 0.5654]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([6.1490, 6.2390, 6.1822, 6.0204, 5.7828, 5.4900, 5.1567, 4.7936, 4.4084,\n", + " 4.0067, 3.5929, 3.1699, 2.7402, 2.3054, 1.8667, 1.4252, 0.9816, 0.5364])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0518, grad_fn=) , base rewards= tensor([12.2557, 12.2557, 12.2557, 12.2557, 12.2557, 12.2557, 12.2557, 11.2749,\n", + " 10.4095, 9.6259, 8.9010, 8.2186, 7.5673, 6.9388, 6.3271, 5.7279,\n", + " 5.1380, 4.5550, 3.9772, 3.4032, 2.8321, 2.2632, 1.6959, 1.1297,\n", + " 0.5645]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9986, 0.9994, 0.9992, 0.9986, 0.9994, 0.9992, 0.9993,\n", + " 0.9997, 0.9993, 0.9995, 0.9991, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9926, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([6.5812, 6.6712, 6.6160, 6.4564, 6.2210, 5.9301, 5.5985, 5.2366, 4.8524,\n", + " 4.4516, 4.0384, 3.6159, 3.1865, 2.7520, 2.3136, 1.8722, 1.4287, 0.9836,\n", + " 0.5373])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 5 ep 280 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0541, grad_fn=) , base rewards= tensor([12.6800, 12.6800, 12.6800, 12.6800, 12.6800, 12.6800, 11.7381, 10.9002,\n", + " 10.1362, 9.4255, 8.7535, 8.1098, 7.4869, 6.8794, 6.2833, 5.6957,\n", + " 5.1144, 4.5378, 3.9648, 3.3944, 2.8260, 2.2591, 1.6933, 1.1283,\n", + " 0.5639]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9990, 0.9994, 0.9994, 0.9995,\n", + " 0.9998, 0.9995, 0.9996, 0.9993, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9921, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([7.0088, 7.0988, 7.0459, 6.8892, 6.6567, 6.3684, 6.0389, 5.6789, 5.2960,\n", + " 4.8963, 4.4839, 4.0621, 3.6332, 3.1990, 2.7608, 2.3197, 1.8764, 1.4313,\n", + " 0.9851, 0.5379])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0616, grad_fn=) , base rewards= tensor([13.0598, 13.0598, 13.0598, 13.0598, 13.0598, 12.1686, 11.3667, 10.6286,\n", + " 9.9366, 9.2783, 8.6446, 8.0291, 7.4271, 6.8351, 6.2506, 5.6715,\n", + " 5.0967, 4.5249, 3.9555, 3.3878, 2.8214, 2.2560, 1.6913, 1.1272,\n", + " 0.5634]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9990, 0.9994, 0.9994, 0.9995,\n", + " 0.9998, 0.9995, 0.9996, 0.9993, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9921, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([7.4301, 7.5201, 7.4702, 7.3174, 7.0888, 6.8040, 6.4773, 6.1196, 5.7386,\n", + " 5.3403, 4.9290, 4.5080, 4.0798, 3.6460, 3.2083, 2.7674, 2.3243, 1.8794,\n", + " 1.4333, 0.9862, 0.5384])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0675, grad_fn=) , base rewards= tensor([13.3829, 13.3829, 13.3829, 13.3829, 12.5572, 11.8020, 11.0977, 10.4303,\n", + " 9.7900, 9.1696, 8.5639, 7.9692, 7.3826, 6.8021, 6.2261, 5.6535,\n", + " 5.0835, 4.5153, 3.9485, 3.3828, 2.8180, 2.2537, 1.6898, 1.1263,\n", + " 0.5631]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9989, 0.9985, 0.9994, 0.9992, 0.9990, 0.9994, 0.9994, 0.9995,\n", + " 0.9998, 0.9995, 0.9996, 0.9993, 0.9990, 0.9997, 0.9993, 0.9995, 0.9990,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9921, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([7.8427, 7.9327, 7.8868, 7.7392, 7.5158, 7.2355, 6.9127, 6.5581, 6.1795,\n", + " 5.7831, 5.3733, 4.9534, 4.5260, 4.0930, 3.6557, 3.2152, 2.7724, 2.3277,\n", + " 1.8818, 1.4348, 0.9870, 0.5387])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 258 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 26, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(34.8480, grad_fn=) , base rewards= tensor([13.6344, 13.6344, 13.6344, 12.8921, 12.1971, 11.5366, 10.9012, 10.2846,\n", + " 9.6816, 9.0890, 8.5039, 7.9245, 7.3494, 6.7774, 6.2078, 5.6400,\n", + " 5.0735, 4.5081, 3.9433, 3.3791, 2.8154, 2.2519, 1.6887, 1.1257,\n", + " 0.5628]) return= 227922.18817761683\n", + "probs of actions: tensor([9.9912e-01, 9.9896e-01, 9.9900e-01, 9.9960e-01, 9.9942e-01, 9.9922e-01,\n", + " 9.9947e-01, 9.9954e-01, 9.9955e-01, 9.9982e-01, 9.9957e-01, 9.9970e-01,\n", + " 9.9947e-01, 9.9904e-01, 9.9969e-01, 4.2794e-04, 9.9954e-01, 9.9905e-01,\n", + " 9.9980e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00, 9.9995e-01, 9.9227e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0255, 0.9846, 0.9916,\n", + " 0.9968, 1.0007, 1.0036, 1.0059, 1.0075, 1.0088, 1.0997])\n", + "finalReturns: tensor([8.1886, 8.2786, 8.2379, 8.0973, 7.8807, 7.6066, 7.2889, 6.9384, 6.5631,\n", + " 6.1693, 5.7614, 5.3431, 4.9168, 4.4846, 4.0256, 3.6064, 3.1796, 2.7470,\n", + " 2.3101, 1.8699, 1.4272, 0.9828, 0.5369])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 23 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0766, grad_fn=) , base rewards= tensor([13.7976, 13.7976, 13.1596, 12.5410, 11.9366, 11.3428, 10.7569, 10.1769,\n", + " 9.6013, 9.0290, 8.4592, 7.8912, 7.3246, 6.7590, 6.1942, 5.6299,\n", + " 5.0661, 4.5026, 3.9394, 3.3764, 2.8134, 2.2506, 1.6879, 1.1252,\n", + " 0.5626]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9990, 0.9990, 0.9996, 0.9994, 0.9992, 0.9995, 0.9995, 0.9996,\n", + " 0.9998, 0.9996, 0.9997, 0.9995, 0.9990, 0.9997, 0.9993, 0.9995, 0.9991,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9922, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([8.6283, 8.7183, 8.6847, 8.5534, 8.3460, 8.0800, 7.7691, 7.4241, 7.0532,\n", + " 6.6628, 6.2575, 5.8412, 5.4164, 4.9854, 4.5496, 4.1103, 3.6683, 3.2244,\n", + " 2.7789, 2.3323, 1.8848, 1.4367, 0.9881, 0.5392])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n", + " 30, 30, 30, 30, 30, 30, 0])\n", + "loss= tensor(0.0858, grad_fn=) , base rewards= tensor([13.8555, 13.3442, 12.8204, 12.2871, 11.7465, 11.2005, 10.6504, 10.0972,\n", + " 9.5417, 8.9844, 8.4258, 7.8663, 7.3060, 6.7452, 6.1839, 5.6224,\n", + " 5.0606, 4.4986, 3.9365, 3.3743, 2.8120, 2.2497, 1.6873, 1.1249,\n", + " 0.5624]) return= 228471.31797735966\n", + "probs of actions: tensor([0.9991, 0.9990, 0.9990, 0.9996, 0.9994, 0.9992, 0.9995, 0.9995, 0.9996,\n", + " 0.9998, 0.9996, 0.9997, 0.9995, 0.9990, 0.9997, 0.9993, 0.9995, 0.9991,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 0.9999, 0.9922, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4212, 0.5480, 0.6523, 0.7357, 0.8011, 0.8519, 0.8908, 0.9206, 0.9432,\n", + " 0.9603, 0.9732, 0.9830, 0.9903, 0.9959, 1.0000, 1.0031, 1.0055, 1.0072,\n", + " 1.0085, 1.0095, 1.0103, 1.0108, 1.0112, 1.0116, 1.1018])\n", + "finalReturns: tensor([8.9917, 9.0817, 9.0575, 8.9385, 8.7434, 8.4883, 8.1865, 7.8489, 7.4838,\n", + " 7.0979, 6.6961, 6.2824, 5.8597, 5.4302, 4.9956, 4.5572, 4.1159, 3.6724,\n", + " 3.2273, 2.7810, 2.3337, 1.8858, 1.4373, 0.9885, 0.5393])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682476508 saved\n", + "[830550, 'tensor([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 228471.31797735966, 18758.68173295266, 0.08583260327577591, 1e-05, 1, 0, 'tensor([30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,\\n 30, 30, 30, 30, 30, 30, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.99 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1682476508', 25, 50, 174696.33353181678, 228471.31797735966, 95930.56714139864, 130490.57866666671, 127475.47466666666, 61768.648600928995, 61760.04937694948, 76910.22725950743, 76910.22725950743, 110767.6026843345, 61768.648600928995, 76910.22725950743]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 14, 0, 23, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712,\n", + " 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712,\n", + " 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712, 0.5712]) return= 143712.4363256526\n", + "probs of actions: tensor([9.1195e-01, 9.0448e-01, 9.2248e-01, 9.3650e-01, 9.1132e-01, 4.6668e-03,\n", + " 9.2003e-01, 9.1205e-01, 8.9672e-01, 9.0821e-01, 9.1395e-01, 9.0437e-01,\n", + " 4.1970e-04, 9.3013e-01, 4.8654e-04, 9.3345e-01, 9.3245e-01, 9.2076e-01,\n", + " 9.3494e-01, 9.0264e-01, 9.2735e-01, 9.1623e-01, 9.3351e-01, 9.3845e-01,\n", + " 9.9369e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5492, 0.5644, 0.5639, 0.5636,\n", + " 0.5633, 0.5631, 0.5630, 0.5432, 0.6165, 0.5499, 0.6844, 0.6528, 0.6296,\n", + " 0.6125, 0.5998, 0.5903, 0.5833, 0.5781, 0.5742, 0.5712])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 2, 13, 8, 3, 8, 11, 1, 0, 10, 1, 4, 0, 11, 10, 11, 11, 0, 11,\n", + " 3, 19, 5, 11, 0, 16, 0])\n", + "loss= tensor(0.1585, grad_fn=) , base rewards= tensor([1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100,\n", + " 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100,\n", + " 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 1.3100, 0.6413]) return= 158781.70950982286\n", + "probs of actions: tensor([0.1258, 0.0380, 0.0482, 0.0496, 0.0497, 0.0659, 0.0877, 0.3758, 0.0628,\n", + " 0.0816, 0.0299, 0.1993, 0.0989, 0.0494, 0.1139, 0.0767, 0.3202, 0.0930,\n", + " 0.0514, 0.0096, 0.0470, 0.1015, 0.3275, 0.0204, 0.9615],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5142, 0.5812, 0.6113, 0.6048, 0.6181, 0.6566, 0.6365, 0.6076,\n", + " 0.6429, 0.6247, 0.6258, 0.5975, 0.6310, 0.6488, 0.6680, 0.6948, 0.6483,\n", + " 0.6789, 0.6255, 0.7116, 0.6831, 0.7061, 0.6431, 0.7070])\n", + "finalReturns: tensor([0.0401, 0.0657])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([17, 17, 22, 9, 27, 10, 23, 1, 11, 22, 19, 22, 11, 22, 23, 17, 21, 19,\n", + " 14, 19, 1, 22, 27, 21, 0])\n", + "loss= tensor(0.9555, grad_fn=) , base rewards= tensor([2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835,\n", + " 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 2.2835,\n", + " 2.2835, 2.2835, 2.2835, 2.2835, 2.2835, 1.4586, 0.7040]) return= 189588.30780201865\n", + "probs of actions: tensor([0.0446, 0.0415, 0.1311, 0.0181, 0.0726, 0.0367, 0.0968, 0.0634, 0.0767,\n", + " 0.1486, 0.0753, 0.1825, 0.1011, 0.2034, 0.0902, 0.0444, 0.0571, 0.0620,\n", + " 0.0055, 0.0769, 0.0473, 0.1604, 0.1186, 0.1233, 0.9659],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.5582, 0.5991, 0.7076, 0.6403, 0.7792, 0.7194, 0.8173, 0.7414,\n", + " 0.7016, 0.7596, 0.7689, 0.8353, 0.7713, 0.7963, 0.8475, 0.8247, 0.8458,\n", + " 0.8627, 0.8232, 0.8652, 0.7396, 0.7520, 0.8324, 0.8876])\n", + "finalReturns: tensor([0.1885, 0.2614, 0.1837])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 2, 23, 29, 27, 27, 33, 22, 22, 29, 27, 27, 27, 29, 27, 27, 23, 19, 23,\n", + " 27, 27, 29, 29, 21, 29, 0])\n", + "loss= tensor(2.9230, grad_fn=) , base rewards= tensor([3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631,\n", + " 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631, 3.4631,\n", + " 3.4631, 3.4631, 3.4631, 3.4631, 2.4400, 1.5449, 0.7401]) return= 213779.62568054372\n", + "probs of actions: tensor([0.0017, 0.1390, 0.2575, 0.2755, 0.2901, 0.0024, 0.1132, 0.1030, 0.2525,\n", + " 0.3007, 0.2977, 0.2952, 0.2668, 0.3061, 0.2577, 0.1412, 0.0256, 0.1252,\n", + " 0.2708, 0.2615, 0.2655, 0.2885, 0.0294, 0.2154, 0.9868],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.4782, 0.5425, 0.6559, 0.7286, 0.7494, 0.8825, 0.8850, 0.8512,\n", + " 0.8980, 0.9151, 0.9281, 0.9267, 0.9554, 0.9584, 0.9807, 0.9789, 0.9284,\n", + " 0.9032, 0.9191, 0.9199, 0.9390, 0.9935, 0.9238, 1.0261])\n", + "finalReturns: tensor([0.4193, 0.5034, 0.4050, 0.2860])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 27, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.3539, grad_fn=) , base rewards= tensor([4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058,\n", + " 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058, 4.3058,\n", + " 4.3058, 4.3058, 4.3058, 3.2296, 2.2973, 1.4662, 0.7072]) return= 225339.17689685564\n", + "probs of actions: tensor([0.8154, 0.8062, 0.8327, 0.8258, 0.8574, 0.8441, 0.8384, 0.8128, 0.8276,\n", + " 0.8399, 0.8353, 0.8444, 0.8512, 0.8138, 0.8433, 0.0926, 0.8387, 0.8597,\n", + " 0.8749, 0.8681, 0.9106, 0.8920, 0.9257, 0.8106, 0.9973],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9997, 0.9804, 0.9847,\n", + " 0.9879, 0.9903, 0.9921, 0.9934, 0.9944, 0.9952, 1.0799])\n", + "finalReturns: tensor([0.7493, 0.8334, 0.7722, 0.6089, 0.3727])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 27, 29, 29, 29, 29, 29, 29, 29, 29, 27, 29, 29, 29,\n", + " 29, 27, 29, 29, 29, 29, 0])\n", + "loss= tensor(3.4990, grad_fn=) , base rewards= tensor([4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724,\n", + " 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724, 4.9724,\n", + " 4.9724, 4.9724, 3.8972, 2.9656, 2.1349, 1.3762, 0.6693]) return= 224839.01113301513\n", + "probs of actions: tensor([0.9082, 0.9036, 0.9186, 0.9093, 0.9285, 0.0573, 0.9221, 0.9087, 0.9121,\n", + " 0.9198, 0.9195, 0.9243, 0.9271, 0.9111, 0.0542, 0.9275, 0.9204, 0.9342,\n", + " 0.9394, 0.0433, 0.9618, 0.9606, 0.9649, 0.9095, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8542, 0.8707, 0.9017, 0.9252,\n", + " 0.9431, 0.9565, 0.9667, 0.9744, 0.9801, 0.9957, 0.9774, 0.9824, 0.9862,\n", + " 0.9890, 1.0023, 0.9824, 0.9861, 0.9890, 0.9911, 1.0768])\n", + "finalReturns: tensor([1.0553, 1.1282, 1.0774, 0.9220, 0.6917, 0.4075])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.1558, grad_fn=) , base rewards= tensor([5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221,\n", + " 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221,\n", + " 5.6221, 4.5443, 3.6109, 2.7790, 2.0194, 1.3118, 0.6421]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9589, 0.9574, 0.9638, 0.9603, 0.9687, 0.9671, 0.9659, 0.9609, 0.9606,\n", + " 0.9646, 0.9645, 0.9679, 0.9693, 0.9613, 0.9680, 0.9688, 0.9643, 0.9729,\n", + " 0.9797, 0.9749, 0.9883, 0.9855, 0.9864, 0.9523, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([1.4313, 1.5154, 1.4541, 1.2907, 1.0544, 0.7657, 0.4389])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0674, grad_fn=) , base rewards= tensor([6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397,\n", + " 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397,\n", + " 5.1632, 4.2307, 3.3994, 2.6402, 1.9330, 1.2634, 0.6215]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9847, 0.9841, 0.9869, 0.9858, 0.9886, 0.9888, 0.9882, 0.9863, 0.9859,\n", + " 0.9873, 0.9876, 0.9891, 0.9897, 0.9864, 0.9889, 0.9893, 0.9873, 0.9919,\n", + " 0.9960, 0.9936, 0.9962, 0.9956, 0.9956, 0.9809, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([1.8061, 1.8902, 1.8290, 1.6657, 1.4295, 1.1409, 0.8141, 0.4594])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 16 ep 85058 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0069, grad_fn=) , base rewards= tensor([6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407,\n", + " 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 5.7658,\n", + " 4.8345, 4.0040, 3.2454, 2.5386, 1.8694, 1.2278, 0.6064]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9980, 0.9978, 0.9983, 0.9983, 0.9986, 0.9987, 0.9986, 0.9983, 0.9983,\n", + " 0.9985, 0.9986, 0.9988, 0.9989, 0.9985, 0.9988, 0.9988, 0.9990, 0.9992,\n", + " 0.9998, 0.9997, 1.0000, 0.9997, 0.9997, 0.9987, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([2.1959, 2.2800, 2.2189, 2.0557, 1.8196, 1.5311, 1.2044, 0.8498, 0.4745])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 2201 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0087, grad_fn=) , base rewards= tensor([7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283,\n", + " 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 6.3558, 5.4260,\n", + " 4.5967, 3.8389, 3.1326, 2.4638, 1.8225, 1.2013, 0.5951]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9982, 0.9985, 0.9985, 0.9988, 0.9989, 0.9988, 0.9985, 0.9985,\n", + " 0.9987, 0.9988, 0.9990, 0.9991, 0.9987, 0.9990, 0.9990, 0.9993, 0.9993,\n", + " 0.9999, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([2.5967, 2.6808, 2.6198, 2.4567, 2.2208, 1.9324, 1.6059, 1.2513, 0.8762,\n", + " 0.4858])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 15 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0127, grad_fn=) , base rewards= tensor([8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050,\n", + " 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 6.9354, 6.0078, 5.1799,\n", + " 4.4232, 3.7177, 3.0495, 2.4086, 1.7877, 1.1817, 0.5868]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9982, 0.9986, 0.9986, 0.9988, 0.9989, 0.9988, 0.9985, 0.9985,\n", + " 0.9987, 0.9988, 0.9990, 0.9991, 0.9987, 0.9990, 0.9990, 0.9993, 0.9993,\n", + " 0.9999, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.0055, 3.0896, 3.0288, 2.8659, 2.6302, 2.3420, 2.0156, 1.6611, 1.2861,\n", + " 0.8958, 0.4942])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 280 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0172, grad_fn=) , base rewards= tensor([8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720,\n", + " 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 7.5064, 6.5815, 5.7556, 5.0003,\n", + " 4.2958, 3.6284, 2.9880, 2.3676, 1.7619, 1.1671, 0.5805]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9981, 0.9985, 0.9985, 0.9988, 0.9989, 0.9988, 0.9985, 0.9985,\n", + " 0.9987, 0.9988, 0.9990, 0.9991, 0.9990, 0.9991, 0.9990, 0.9993, 0.9993,\n", + " 0.9999, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.4201, 3.5042, 3.4436, 3.2810, 3.0455, 2.7576, 2.4313, 2.0771, 1.7022,\n", + " 1.3119, 0.9104, 0.5004])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0222, grad_fn=) , base rewards= tensor([9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296,\n", + " 9.1296, 9.1296, 9.1296, 9.1296, 8.0693, 7.1481, 6.3249, 5.5714, 4.8684,\n", + " 4.2019, 3.5622, 2.9423, 2.3370, 1.7426, 1.1562, 0.5759]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9981, 0.9985, 0.9985, 0.9988, 0.9989, 0.9988, 0.9985, 0.9985,\n", + " 0.9987, 0.9988, 0.9990, 0.9991, 0.9990, 0.9991, 0.9990, 0.9993, 0.9993,\n", + " 0.9999, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.8386, 3.9227, 3.8624, 3.7002, 3.4651, 3.1775, 2.8515, 2.4975, 2.1227,\n", + " 1.7327, 1.3312, 0.9213, 0.5051])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 2 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0279, grad_fn=) , base rewards= tensor([9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775,\n", + " 9.6775, 9.6775, 9.6775, 8.6243, 7.7080, 6.8883, 6.1374, 5.4361, 4.7710,\n", + " 4.1323, 3.5131, 2.9084, 2.3143, 1.7282, 1.1481, 0.5724]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9981, 0.9985, 0.9985, 0.9988, 0.9989, 0.9988, 0.9985, 0.9985,\n", + " 0.9987, 0.9988, 0.9990, 0.9991, 0.9990, 0.9991, 0.9990, 0.9993, 0.9993,\n", + " 0.9999, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([4.2598, 4.3439, 4.2840, 4.1223, 3.8877, 3.6005, 3.2749, 2.9211, 2.5466,\n", + " 2.1567, 1.7554, 1.3456, 0.9294, 0.5085])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 14016 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0265, grad_fn=) , base rewards= tensor([10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146,\n", + " 10.2146, 10.2146, 10.2146, 9.1707, 8.2611, 7.4460, 6.6984, 5.9995,\n", + " 5.3362, 4.6988, 4.0806, 3.4765, 2.8830, 2.2973, 1.7175, 1.1420,\n", + " 0.5698]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9981, 0.9985, 0.9985, 0.9987, 0.9989, 0.9987, 0.9984, 0.9984,\n", + " 0.9987, 0.9990, 1.0000, 0.9997, 0.9990, 0.9990, 0.9989, 0.9993, 0.9993,\n", + " 1.0000, 0.9998, 1.0000, 0.9998, 0.9998, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([4.6825, 4.7666, 4.7072, 4.5461, 4.3122, 4.0255, 3.7004, 3.3470, 2.9728,\n", + " 2.5832, 2.1820, 1.7724, 1.3563, 0.9355, 0.5111])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 9 ep 432 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0336, grad_fn=) , base rewards= tensor([10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388,\n", + " 10.7388, 10.7388, 9.7074, 8.8064, 7.9975, 7.2544, 6.5588, 5.8977,\n", + " 5.2621, 4.6452, 4.0421, 3.4493, 2.8641, 2.2847, 1.7095, 1.1375,\n", + " 0.5678]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9981, 0.9980, 0.9984, 0.9984, 0.9987, 0.9988, 0.9987, 0.9984, 0.9984,\n", + " 0.9990, 0.9989, 1.0000, 0.9997, 0.9990, 0.9990, 0.9988, 0.9993, 0.9993,\n", + " 1.0000, 0.9998, 1.0000, 0.9997, 0.9998, 0.9988, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.1056, 5.1897, 5.1309, 4.9707, 4.7377, 4.4518, 4.1273, 3.7745, 3.4007,\n", + " 3.0113, 2.6104, 2.2010, 1.7851, 1.3643, 0.9401, 0.5131])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 6551 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0253, grad_fn=) , base rewards= tensor([11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472,\n", + " 11.2472, 10.2322, 9.3428, 8.5420, 7.8048, 7.1135, 6.4556, 5.8223,\n", + " 5.2071, 4.6052, 4.0134, 3.4289, 2.8500, 2.2752, 1.7035, 1.1341,\n", + " 0.5664]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9987, 0.9987, 0.9989, 0.9990, 0.9991, 0.9992, 0.9991, 0.9989, 0.9990,\n", + " 0.9995, 0.9994, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.5282, 5.6123, 5.5544, 5.3953, 5.1634, 4.8785, 4.5549, 4.2028, 3.8295,\n", + " 3.4406, 3.0400, 2.6308, 2.2151, 1.7945, 1.3704, 0.9435, 0.5145])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 30 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0320, grad_fn=) , base rewards= tensor([11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354,\n", + " 10.7421, 9.8680, 9.0781, 8.3488, 7.6631, 7.0094, 6.3791, 5.7662,\n", + " 5.1660, 4.5754, 3.9919, 3.4137, 2.8394, 2.2681, 1.6990, 1.1315,\n", + " 0.5653]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9989, 0.9990, 0.9992, 0.9992, 0.9991, 0.9990, 0.9990,\n", + " 0.9995, 0.9994, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.9491, 6.0332, 5.9765, 5.8190, 5.5886, 5.3051, 4.9826, 4.6314, 4.2589,\n", + " 3.8705, 3.4704, 3.0615, 2.6460, 2.2257, 1.8016, 1.3749, 0.9460, 0.5156])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0387, grad_fn=) , base rewards= tensor([12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 11.2331,\n", + " 10.3791, 9.6037, 8.8847, 8.2066, 7.5584, 6.9322, 6.3223, 5.7244,\n", + " 5.1354, 4.5532, 3.9759, 3.4023, 2.8315, 2.2627, 1.6956, 1.1296,\n", + " 0.5645]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9989, 0.9990, 0.9992, 0.9992, 0.9991, 0.9990, 0.9990,\n", + " 0.9995, 0.9994, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([6.3673, 6.4514, 6.3962, 6.2408, 6.0125, 5.7308, 5.4098, 5.0598, 4.6882,\n", + " 4.3007, 3.9011, 3.4927, 3.0775, 2.6574, 2.2336, 1.8070, 1.3782, 0.9479,\n", + " 0.5165])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0451, grad_fn=) , base rewards= tensor([12.6268, 12.6268, 12.6268, 12.6268, 12.6268, 12.6268, 11.6997, 10.8722,\n", + " 10.1157, 9.4104, 8.7424, 8.1016, 7.4808, 6.8749, 6.2799, 5.6932,\n", + " 5.1126, 4.5365, 3.9639, 3.3937, 2.8255, 2.2588, 1.6931, 1.1282,\n", + " 0.5639]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9990, 0.9990, 0.9992, 0.9992, 0.9991, 0.9990, 0.9990,\n", + " 0.9995, 0.9994, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([6.7813, 6.8654, 6.8123, 6.6596, 6.4340, 6.1547, 5.8358, 5.4874, 5.1172,\n", + " 4.7306, 4.3318, 3.9240, 3.5093, 3.0895, 2.6660, 2.2395, 1.8109, 1.3808,\n", + " 0.9494, 0.5171])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0525, grad_fn=) , base rewards= tensor([13.0129, 13.0129, 13.0129, 13.0129, 13.0129, 12.1346, 11.3419, 10.6103,\n", + " 9.9232, 9.2683, 8.6372, 8.0237, 7.4231, 6.8321, 6.2483, 5.6699,\n", + " 5.0955, 4.5241, 3.9549, 3.3874, 2.8211, 2.2558, 1.6912, 1.1271,\n", + " 0.5634]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9990, 0.9990, 0.9992, 0.9992, 0.9991, 0.9990, 0.9990,\n", + " 0.9995, 0.9994, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([7.1893, 7.2734, 7.2232, 7.0741, 6.8522, 6.5761, 6.2599, 5.9137, 5.5452,\n", + " 5.1599, 4.7622, 4.3551, 3.9411, 3.5218, 3.0985, 2.6724, 2.2440, 1.8139,\n", + " 1.3826, 0.9504, 0.5175])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 14 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0604, grad_fn=) , base rewards= tensor([13.3441, 13.3441, 13.3441, 13.3441, 12.5289, 11.7813, 11.0824, 10.4190,\n", + " 9.7816, 9.1633, 8.5593, 7.9657, 7.3800, 6.8002, 6.2247, 5.6525,\n", + " 5.0827, 4.5147, 3.9481, 3.3826, 2.8178, 2.2535, 1.6897, 1.1263,\n", + " 0.5630]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9990, 0.9990, 0.9992, 0.9993, 0.9992, 0.9990, 0.9990,\n", + " 0.9995, 0.9995, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([7.5892, 7.6733, 7.6268, 7.4827, 7.2655, 6.9938, 6.6811, 6.3379, 5.9716,\n", + " 5.5882, 5.1918, 4.7858, 4.3726, 3.9539, 3.5311, 3.1053, 2.6771, 2.2473,\n", + " 1.8162, 1.3841, 0.9512, 0.5179])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 2 ep 19 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0680, grad_fn=) , base rewards= tensor([13.6060, 13.6060, 13.6060, 12.8713, 12.1817, 11.5251, 10.8928, 10.2782,\n", + " 9.6769, 9.0855, 8.5013, 7.9226, 7.3479, 6.7763, 6.2070, 5.6394,\n", + " 5.0731, 4.5077, 3.9431, 3.3790, 2.8153, 2.2519, 1.6887, 1.1257,\n", + " 0.5628]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9990, 0.9990, 0.9992, 0.9993, 0.9992, 0.9991, 0.9990,\n", + " 0.9995, 0.9995, 1.0000, 0.9998, 0.9994, 0.9994, 0.9993, 0.9997, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([7.9780, 8.0621, 8.0205, 7.8829, 7.6723, 7.4063, 7.0984, 6.7590, 6.3958,\n", + " 6.0148, 5.6203, 5.2157, 4.8035, 4.3856, 3.9635, 3.5381, 3.1103, 2.6807,\n", + " 2.2498, 1.8178, 1.3851, 0.9518, 0.5181])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 2390 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0622, grad_fn=) , base rewards= tensor([13.7821, 13.7821, 13.1481, 12.5324, 11.9302, 11.3380, 10.7533, 10.1743,\n", + " 9.5993, 9.0276, 8.4581, 7.8904, 7.3239, 6.7585, 6.1938, 5.6297,\n", + " 5.0659, 4.5025, 3.9393, 3.3763, 2.8134, 2.2506, 1.6879, 1.1252,\n", + " 0.5626]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9989, 0.9990, 0.9991, 0.9992, 0.9994, 0.9997, 0.9997, 0.9993, 0.9991,\n", + " 0.9995, 0.9995, 1.0000, 0.9999, 0.9995, 0.9995, 0.9994, 0.9998, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([8.3518, 8.4359, 8.4010, 8.2721, 8.0700, 7.8117, 7.5102, 7.1760, 6.8169,\n", + " 6.4390, 6.0470, 5.6443, 5.2335, 4.8167, 4.3954, 3.9706, 3.5433, 3.1141,\n", + " 2.6834, 2.2517, 1.8191, 1.3859, 0.9523, 0.5183])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 100 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0722, grad_fn=) , base rewards= tensor([13.8555, 13.3442, 12.8204, 12.2871, 11.7465, 11.2005, 10.6504, 10.0972,\n", + " 9.5417, 8.9844, 8.4258, 7.8663, 7.3060, 6.7452, 6.1839, 5.6224,\n", + " 5.0606, 4.4986, 3.9365, 3.3743, 2.8120, 2.2497, 1.6873, 1.1249,\n", + " 0.5624]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9991, 0.9992, 0.9994, 0.9997, 0.9997, 0.9993, 0.9991,\n", + " 0.9995, 0.9995, 1.0000, 0.9999, 0.9995, 0.9995, 0.9994, 0.9998, 0.9996,\n", + " 1.0000, 0.9999, 1.0000, 0.9999, 0.9999, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([8.7056, 8.7897, 8.7636, 8.6463, 8.4558, 8.2076, 7.9147, 7.5873, 7.2337,\n", + " 6.8601, 6.4713, 6.0711, 5.6622, 5.2469, 4.8266, 4.4027, 3.9760, 3.5472,\n", + " 3.1169, 2.6854, 2.2531, 1.8200, 1.3865, 0.9526, 0.5185])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682506150 saved\n", + "[1071125, 'tensor([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 225610.63312213228, 21262.174331621536, 0.07217718660831451, 1e-05, 1, 0, 'tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\\n 29, 29, 29, 29, 29, 29, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682506150', 25, 50, 174060.25019204617, 225610.63312213225, 94497.47055325202, 131154.89666666667, 128142.59199999999, 65231.33608163523, 65242.24251310914, 80629.96159612676, 80629.96159612676, 109128.78816076377, 65242.24251310914, 80629.96159612676]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700,\n", + " 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700,\n", + " 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700, 0.5700]) return= 139801.3687034911\n", + "probs of actions: tensor([0.0586, 0.8760, 0.8988, 0.8761, 0.8584, 0.9093, 0.8702, 0.8950, 0.8991,\n", + " 0.8972, 0.9039, 0.0053, 0.8843, 0.0620, 0.8891, 0.8950, 0.8928, 0.0581,\n", + " 0.9003, 0.8979, 0.0050, 0.9160, 0.9029, 0.8696, 0.9885],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.5274, 0.5361, 0.5426, 0.5476, 0.5513, 0.5541, 0.5562, 0.5578,\n", + " 0.5589, 0.5598, 0.5596, 0.5723, 0.5697, 0.5718, 0.5694, 0.5677, 0.5663,\n", + " 0.5692, 0.5675, 0.5647, 0.5805, 0.5759, 0.5726, 0.5700])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([22, 0, 0, 15, 13, 0, 11, 0, 0, 0, 20, 5, 3, 0, 3, 0, 26, 25,\n", + " 0, 11, 0, 6, 2, 12, 0])\n", + "loss= tensor(0.1463, grad_fn=) , base rewards= tensor([1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831,\n", + " 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831,\n", + " 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 1.2831, 0.6299]) return= 159276.00506941756\n", + "probs of actions: tensor([0.0025, 0.2966, 0.3466, 0.0218, 0.0535, 0.3252, 0.0605, 0.3943, 0.3766,\n", + " 0.3660, 0.0257, 0.0161, 0.0400, 0.3518, 0.0500, 0.3720, 0.0043, 0.0210,\n", + " 0.4237, 0.0692, 0.2962, 0.0161, 0.0380, 0.0140, 0.9845],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.6065, 0.5953, 0.5645, 0.6225, 0.6719, 0.6316, 0.6670, 0.6401,\n", + " 0.6202, 0.5655, 0.6717, 0.6647, 0.6510, 0.6274, 0.6233, 0.5402, 0.6384,\n", + " 0.7707, 0.7035, 0.7216, 0.6763, 0.6735, 0.6388, 0.6784])\n", + "finalReturns: tensor([0.0341, 0.0485])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([ 1, 23, 0, 24, 0, 23, 25, 0, 0, 1, 23, 23, 1, 23, 31, 20, 0, 25,\n", + " 23, 15, 20, 18, 23, 23, 0])\n", + "loss= tensor(0.1068, grad_fn=) , base rewards= tensor([2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746,\n", + " 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 2.3746,\n", + " 2.3746, 2.3746, 2.3746, 2.3746, 2.3746, 1.5088, 0.7250]) return= 180250.60124621165\n", + "probs of actions: tensor([0.0518, 0.3167, 0.1523, 0.0385, 0.0575, 0.4545, 0.1042, 0.2132, 0.0763,\n", + " 0.1119, 0.3796, 0.3270, 0.1043, 0.3741, 0.0090, 0.0816, 0.1816, 0.1185,\n", + " 0.2634, 0.0165, 0.0844, 0.0138, 0.7915, 0.7690, 0.9828],\n", + " grad_fn=)\n", + "rewards: tensor([0.5111, 0.4745, 0.6236, 0.5504, 0.6928, 0.6060, 0.6665, 0.7927, 0.7315,\n", + " 0.6871, 0.6060, 0.6760, 0.7837, 0.6764, 0.6880, 0.8233, 0.8730, 0.7265,\n", + " 0.7865, 0.8464, 0.8140, 0.8336, 0.8128, 0.8360, 0.9065])\n", + "finalReturns: tensor([0.1808, 0.2337, 0.1815])\n", + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([31, 23, 25, 25, 25, 25, 23, 25, 23, 23, 23, 25, 25, 23, 25, 23, 25, 25,\n", + " 27, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.7501, grad_fn=) , base rewards= tensor([3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017,\n", + " 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017, 3.4017,\n", + " 3.4017, 3.4017, 3.4017, 3.4017, 2.4026, 1.5243, 0.7315]) return= 213022.8652278334\n", + "probs of actions: tensor([0.0111, 0.2492, 0.4587, 0.4976, 0.4984, 0.5060, 0.2525, 0.4668, 0.3060,\n", + " 0.2324, 0.2723, 0.5297, 0.4819, 0.2750, 0.5488, 0.2651, 0.5455, 0.4659,\n", + " 0.0139, 0.5334, 0.5165, 0.6597, 0.5791, 0.4736, 0.9465],\n", + " grad_fn=)\n", + "rewards: tensor([0.4151, 0.5891, 0.6531, 0.7198, 0.7717, 0.8117, 0.8520, 0.8561, 0.8857,\n", + " 0.8912, 0.8952, 0.8887, 0.9008, 0.9195, 0.9069, 0.9241, 0.9103, 0.9171,\n", + " 0.9118, 0.9360, 0.9363, 0.9366, 0.9369, 0.9370, 0.9996])\n", + "finalReturns: tensor([0.4084, 0.4709, 0.4124, 0.2681])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 25, 24, 25, 25, 31, 23, 25, 23, 24, 25, 29, 25, 25, 25, 25, 23, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.3533, grad_fn=) , base rewards= tensor([4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790,\n", + " 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790, 4.0790,\n", + " 4.0790, 4.0790, 4.0790, 3.0833, 2.2075, 1.4165, 0.6863]) return= 214816.26798917833\n", + "probs of actions: tensor([0.0574, 0.6796, 0.0284, 0.7525, 0.7721, 0.0030, 0.1141, 0.6917, 0.1161,\n", + " 0.0350, 0.8065, 0.0533, 0.7493, 0.7699, 0.8023, 0.8069, 0.0802, 0.7284,\n", + " 0.7459, 0.8124, 0.8481, 0.9153, 0.8995, 0.8177, 0.9781],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5715, 0.6601, 0.7170, 0.7696, 0.7765, 0.8795, 0.8768, 0.9014,\n", + " 0.8982, 0.8994, 0.8872, 0.9358, 0.9363, 0.9366, 0.9368, 0.9466, 0.9271,\n", + " 0.9297, 0.9317, 0.9331, 0.9342, 0.9350, 0.9357, 0.9986])\n", + "finalReturns: tensor([0.6577, 0.7202, 0.6618, 0.5178, 0.3124])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 25, 25, 25, 25, 29, 29, 27, 29, 25, 29, 29, 25, 25, 29, 25, 25,\n", + " 25, 29, 25, 25, 25, 25, 0])\n", + "loss= tensor(2.2123, grad_fn=) , base rewards= tensor([4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950,\n", + " 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950, 4.7950,\n", + " 4.7950, 4.7950, 3.7789, 2.8886, 2.0874, 1.3497, 0.6581]) return= 219146.74992654673\n", + "probs of actions: tensor([0.3673, 0.4170, 0.5130, 0.5435, 0.5898, 0.5895, 0.4646, 0.4325, 0.0031,\n", + " 0.4868, 0.5454, 0.4070, 0.3855, 0.5566, 0.5777, 0.3509, 0.5618, 0.4698,\n", + " 0.4669, 0.3693, 0.5363, 0.7391, 0.8429, 0.8211, 0.9920],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6723, 0.7348, 0.7833, 0.8206, 0.8276, 0.8687, 0.9113,\n", + " 0.9140, 0.9562, 0.9299, 0.9466, 0.9808, 0.9699, 0.9401, 0.9759, 0.9663,\n", + " 0.9590, 0.9320, 0.9698, 0.9617, 0.9556, 0.9511, 1.0102])\n", + "finalReturns: tensor([0.9853, 1.0694, 0.9899, 0.8295, 0.6115, 0.3521])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 25, 0])\n", + "loss= tensor(1.4374, grad_fn=) , base rewards= tensor([5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221,\n", + " 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221, 5.6221,\n", + " 5.6221, 4.5443, 3.6109, 2.7790, 2.0194, 1.3118, 0.6421]) return= 225619.69834256533\n", + "probs of actions: tensor([0.9429, 0.9464, 0.9397, 0.9376, 0.9270, 0.9454, 0.9617, 0.9620, 0.9437,\n", + " 0.9725, 0.9606, 0.9671, 0.9557, 0.9405, 0.9506, 0.9565, 0.9554, 0.9611,\n", + " 0.9799, 0.9698, 0.9807, 0.9492, 0.8315, 0.2472, 0.9998],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 1.0182, 1.0602])\n", + "finalReturns: tensor([1.4322, 1.5163, 1.4550, 1.2916, 1.0553, 0.7666, 0.4182])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.1282, grad_fn=) , base rewards= tensor([6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397,\n", + " 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397, 6.2397,\n", + " 5.1632, 4.2307, 3.3994, 2.6402, 1.9330, 1.2634, 0.6215]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9887, 0.9903, 0.9890, 0.9885, 0.9857, 0.9906, 0.9939, 0.9941, 0.9898,\n", + " 0.9961, 0.9934, 0.9951, 0.9932, 0.9894, 0.9918, 0.9928, 0.9927, 0.9959,\n", + " 0.9982, 0.9969, 0.9978, 0.9934, 0.9720, 0.9220, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([1.8061, 1.8902, 1.8290, 1.6657, 1.4295, 1.1409, 0.8141, 0.4594])\n", + "----------------------------------------\n", + "iter 2 stage 16 ep 99999 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.2565, grad_fn=) , base rewards= tensor([6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407,\n", + " 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 6.8407, 5.7658,\n", + " 4.8345, 4.0040, 3.2454, 2.5386, 1.8694, 1.2278, 0.6064]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9848, 0.9873, 0.9857, 0.9847, 0.9815, 0.9870, 0.9919, 0.9923, 0.9860,\n", + " 0.9947, 0.9908, 0.9933, 0.9906, 0.9856, 0.9885, 0.9898, 0.9932, 0.9950,\n", + " 0.9983, 0.9976, 0.9975, 0.9915, 0.9593, 0.8347, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([2.1959, 2.2800, 2.2189, 2.0557, 1.8196, 1.5311, 1.2044, 0.8498, 0.4745])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 66414 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0475, grad_fn=) , base rewards= tensor([7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283,\n", + " 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 7.4283, 6.3558, 5.4260,\n", + " 4.5967, 3.8389, 3.1326, 2.4638, 1.8225, 1.2013, 0.5951]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9969, 0.9974, 0.9972, 0.9971, 0.9963, 0.9978, 0.9985, 0.9986, 0.9973,\n", + " 0.9991, 0.9984, 0.9989, 0.9985, 0.9973, 0.9980, 0.9990, 0.9994, 0.9998,\n", + " 1.0000, 0.9998, 1.0000, 0.9991, 0.9926, 0.9648, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([2.5967, 2.6808, 2.6198, 2.4567, 2.2208, 1.9324, 1.6059, 1.2513, 0.8762,\n", + " 0.4858])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 1469 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0459, grad_fn=) , base rewards= tensor([8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050,\n", + " 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 8.0050, 6.9354, 6.0078, 5.1799,\n", + " 4.4232, 3.7177, 3.0495, 2.4086, 1.7877, 1.1817, 0.5868]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9972, 0.9976, 0.9975, 0.9974, 0.9967, 0.9980, 0.9986, 0.9988, 0.9976,\n", + " 0.9992, 0.9986, 0.9990, 0.9986, 0.9976, 0.9990, 0.9991, 0.9994, 0.9998,\n", + " 1.0000, 0.9998, 1.0000, 0.9993, 0.9937, 0.9690, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.0055, 3.0896, 3.0288, 2.8659, 2.6302, 2.3420, 2.0156, 1.6611, 1.2861,\n", + " 0.8958, 0.4942])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 39701 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0311, grad_fn=) , base rewards= tensor([8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 8.5720,\n", + " 8.5720, 8.5720, 8.5720, 8.5720, 8.5720, 7.5064, 6.5815, 5.7556, 5.0003,\n", + " 4.2958, 3.6284, 2.9880, 2.3676, 1.7619, 1.1671, 0.5805]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9985, 0.9984, 0.9979, 0.9988, 0.9992, 0.9993, 0.9985,\n", + " 0.9995, 0.9992, 0.9994, 0.9992, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9960, 0.9792, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.4201, 3.5042, 3.4436, 3.2810, 3.0455, 2.7576, 2.4313, 2.0771, 1.7022,\n", + " 1.3119, 0.9104, 0.5004])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0353, grad_fn=) , base rewards= tensor([9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296, 9.1296,\n", + " 9.1296, 9.1296, 9.1296, 9.1296, 8.0693, 7.1481, 6.3249, 5.5714, 4.8684,\n", + " 4.2019, 3.5622, 2.9423, 2.3370, 1.7426, 1.1562, 0.5759]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9985, 0.9984, 0.9979, 0.9988, 0.9992, 0.9993, 0.9985,\n", + " 0.9995, 0.9992, 0.9994, 0.9992, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9960, 0.9792, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([3.8386, 3.9227, 3.8624, 3.7002, 3.4651, 3.1775, 2.8515, 2.4975, 2.1227,\n", + " 1.7327, 1.3312, 0.9213, 0.5051])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0389, grad_fn=) , base rewards= tensor([9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775, 9.6775,\n", + " 9.6775, 9.6775, 9.6775, 8.6243, 7.7080, 6.8883, 6.1374, 5.4361, 4.7710,\n", + " 4.1323, 3.5131, 2.9084, 2.3143, 1.7282, 1.1481, 0.5724]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9985, 0.9984, 0.9979, 0.9988, 0.9992, 0.9993, 0.9985,\n", + " 0.9995, 0.9992, 0.9994, 0.9992, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9960, 0.9792, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([4.2598, 4.3439, 4.2840, 4.1223, 3.8877, 3.6005, 3.2749, 2.9211, 2.5466,\n", + " 2.1567, 1.7554, 1.3456, 0.9294, 0.5085])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0440, grad_fn=) , base rewards= tensor([10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146, 10.2146,\n", + " 10.2146, 10.2146, 10.2146, 9.1707, 8.2611, 7.4460, 6.6984, 5.9995,\n", + " 5.3362, 4.6988, 4.0806, 3.4765, 2.8830, 2.2973, 1.7175, 1.1420,\n", + " 0.5698]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9985, 0.9984, 0.9980, 0.9988, 0.9992, 0.9993, 0.9985,\n", + " 0.9995, 0.9992, 0.9994, 0.9992, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9961, 0.9792, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([4.6825, 4.7666, 4.7072, 4.5461, 4.3122, 4.0255, 3.7004, 3.3470, 2.9728,\n", + " 2.5832, 2.1820, 1.7724, 1.3563, 0.9355, 0.5111])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0476, grad_fn=) , base rewards= tensor([10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388, 10.7388,\n", + " 10.7388, 10.7388, 9.7074, 8.8064, 7.9975, 7.2544, 6.5588, 5.8977,\n", + " 5.2621, 4.6452, 4.0421, 3.4493, 2.8641, 2.2847, 1.7095, 1.1375,\n", + " 0.5678]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9985, 0.9984, 0.9980, 0.9988, 0.9992, 0.9993, 0.9985,\n", + " 0.9995, 0.9992, 0.9994, 0.9992, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9961, 0.9792, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.1056, 5.1897, 5.1309, 4.9707, 4.7377, 4.4518, 4.1273, 3.7745, 3.4007,\n", + " 3.0113, 2.6104, 2.2010, 1.7851, 1.3643, 0.9401, 0.5131])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 8 ep 12279 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0442, grad_fn=) , base rewards= tensor([11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472, 11.2472,\n", + " 11.2472, 10.2322, 9.3428, 8.5420, 7.8048, 7.1135, 6.4556, 5.8223,\n", + " 5.2071, 4.6052, 4.0134, 3.4289, 2.8500, 2.2752, 1.7035, 1.1341,\n", + " 0.5664]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9984, 0.9984, 0.9979, 0.9988, 0.9991, 0.9993, 0.9990,\n", + " 1.0000, 1.0000, 0.9997, 0.9994, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9958, 0.9800, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.5282, 5.6123, 5.5544, 5.3953, 5.1634, 4.8785, 4.5549, 4.2028, 3.8295,\n", + " 3.4406, 3.0400, 2.6308, 2.2151, 1.7945, 1.3704, 0.9435, 0.5145])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0494, grad_fn=) , base rewards= tensor([11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354, 11.7354,\n", + " 10.7421, 9.8680, 9.0781, 8.3488, 7.6631, 7.0094, 6.3791, 5.7662,\n", + " 5.1660, 4.5754, 3.9919, 3.4137, 2.8394, 2.2681, 1.6990, 1.1315,\n", + " 0.5653]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9984, 0.9984, 0.9979, 0.9988, 0.9991, 0.9993, 0.9990,\n", + " 1.0000, 1.0000, 0.9997, 0.9994, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9958, 0.9800, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([5.9491, 6.0332, 5.9765, 5.8190, 5.5886, 5.3051, 4.9826, 4.6314, 4.2589,\n", + " 3.8705, 3.4704, 3.0615, 2.6460, 2.2257, 1.8016, 1.3749, 0.9460, 0.5156])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 0 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0560, grad_fn=) , base rewards= tensor([12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 12.1977, 11.2331,\n", + " 10.3791, 9.6037, 8.8847, 8.2066, 7.5584, 6.9322, 6.3223, 5.7244,\n", + " 5.1354, 4.5532, 3.9759, 3.4023, 2.8315, 2.2627, 1.6956, 1.1296,\n", + " 0.5645]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9982, 0.9985, 0.9984, 0.9984, 0.9979, 0.9988, 0.9991, 0.9993, 0.9990,\n", + " 1.0000, 1.0000, 0.9997, 0.9994, 0.9990, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9958, 0.9800, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([6.3673, 6.4514, 6.3962, 6.2408, 6.0125, 5.7308, 5.4098, 5.0598, 4.6882,\n", + " 4.3007, 3.9011, 3.4927, 3.0775, 2.6574, 2.2336, 1.8070, 1.3782, 0.9479,\n", + " 0.5165])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 90 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0596, grad_fn=) , base rewards= tensor([12.6268, 12.6268, 12.6268, 12.6268, 12.6268, 12.6268, 11.6997, 10.8722,\n", + " 10.1157, 9.4104, 8.7424, 8.1016, 7.4808, 6.8749, 6.2799, 5.6932,\n", + " 5.1126, 4.5365, 3.9639, 3.3937, 2.8255, 2.2588, 1.6931, 1.1282,\n", + " 0.5639]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9983, 0.9985, 0.9985, 0.9985, 0.9980, 0.9990, 0.9993, 0.9994, 0.9991,\n", + " 1.0000, 1.0000, 0.9997, 0.9994, 0.9991, 0.9994, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9960, 0.9811, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([6.7813, 6.8654, 6.8123, 6.6596, 6.4340, 6.1547, 5.8358, 5.4874, 5.1172,\n", + " 4.7306, 4.3318, 3.9240, 3.5093, 3.0895, 2.6660, 2.2395, 1.8109, 1.3808,\n", + " 0.9494, 0.5171])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 882 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0599, grad_fn=) , base rewards= tensor([13.0129, 13.0129, 13.0129, 13.0129, 13.0129, 12.1346, 11.3419, 10.6103,\n", + " 9.9232, 9.2683, 8.6372, 8.0237, 7.4231, 6.8321, 6.2483, 5.6699,\n", + " 5.0955, 4.5241, 3.9549, 3.3874, 2.8211, 2.2558, 1.6912, 1.1271,\n", + " 0.5634]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9984, 0.9987, 0.9986, 0.9986, 0.9990, 0.9991, 0.9995, 0.9995, 0.9992,\n", + " 1.0000, 1.0000, 0.9997, 0.9995, 0.9992, 0.9995, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9963, 0.9830, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([7.1893, 7.2734, 7.2232, 7.0741, 6.8522, 6.5761, 6.2599, 5.9137, 5.5452,\n", + " 5.1599, 4.7622, 4.3551, 3.9411, 3.5218, 3.0985, 2.6724, 2.2440, 1.8139,\n", + " 1.3826, 0.9504, 0.5175])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 26351 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0595, grad_fn=) , base rewards= tensor([13.3441, 13.3441, 13.3441, 13.3441, 12.5289, 11.7813, 11.0824, 10.4190,\n", + " 9.7816, 9.1633, 8.5593, 7.9657, 7.3800, 6.8002, 6.2247, 5.6525,\n", + " 5.0827, 4.5147, 3.9481, 3.3826, 2.8178, 2.2535, 1.6897, 1.1263,\n", + " 0.5630]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9984, 0.9986, 0.9986, 0.9990, 0.9992, 0.9989, 0.9997, 0.9997, 0.9993,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9993, 0.9996, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 0.9961, 0.9837, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([7.5892, 7.6733, 7.6268, 7.4827, 7.2655, 6.9938, 6.6811, 6.3379, 5.9716,\n", + " 5.5882, 5.1918, 4.7858, 4.3726, 3.9539, 3.5311, 3.1053, 2.6771, 2.2473,\n", + " 1.8162, 1.3841, 0.9512, 0.5179])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 289 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 25, 0])\n", + "loss= tensor(3.9982, grad_fn=) , base rewards= tensor([13.6060, 13.6060, 13.6060, 12.8713, 12.1817, 11.5251, 10.8928, 10.2782,\n", + " 9.6769, 9.0855, 8.5013, 7.9226, 7.3479, 6.7763, 6.2070, 5.6394,\n", + " 5.0731, 4.5077, 3.9431, 3.3790, 2.8153, 2.2519, 1.6887, 1.1257,\n", + " 0.5628]) return= 225619.69834256533\n", + "probs of actions: tensor([0.9984, 0.9987, 0.9990, 0.9990, 0.9992, 0.9989, 0.9997, 0.9997, 0.9993,\n", + " 1.0000, 1.0000, 1.0000, 0.9998, 0.9994, 0.9996, 1.0000, 0.9999, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 0.9961, 0.0159, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 1.0182, 1.0602])\n", + "finalReturns: tensor([7.9789, 8.0630, 8.0214, 7.8838, 7.6732, 7.4072, 7.0993, 6.7599, 6.3967,\n", + " 6.0157, 5.6212, 5.2166, 4.8044, 4.3865, 3.9644, 3.5390, 3.1112, 2.6816,\n", + " 2.2507, 1.8188, 1.3860, 0.9528, 0.4974])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 1 ep 7933 adversary: AdversaryModes.constant_132\n", + " actions: tensor([25, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0748, grad_fn=) , base rewards= tensor([13.7203, 13.7203, 13.1021, 12.4981, 11.9046, 11.3189, 10.7391, 10.1636,\n", + " 9.5914, 9.0216, 8.4536, 7.8870, 7.3215, 6.7567, 6.1925, 5.6287,\n", + " 5.0652, 4.5020, 3.9389, 3.3760, 2.8132, 2.2505, 1.6878, 1.1252,\n", + " 0.5626]) return= 225109.1821149025\n", + "probs of actions: tensor([0.0017, 0.9990, 0.9990, 0.9991, 0.9993, 0.9989, 0.9997, 0.9999, 0.9993,\n", + " 1.0000, 1.0000, 1.0000, 0.9999, 0.9995, 0.9996, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 0.9959, 0.9832, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5341, 0.6379, 0.7210, 0.7863, 0.8369, 0.8759, 0.9056, 0.9282,\n", + " 0.9453, 0.9582, 0.9680, 0.9753, 0.9808, 0.9850, 0.9881, 0.9905, 0.9922,\n", + " 0.9935, 0.9945, 0.9953, 0.9958, 0.9962, 0.9966, 1.0809])\n", + "finalReturns: tensor([8.3419, 8.4260, 8.3922, 8.2647, 8.0641, 7.8069, 7.5065, 7.1732, 6.8147,\n", + " 6.4374, 6.0458, 5.6433, 5.2328, 4.8162, 4.3950, 3.9703, 3.5431, 3.1139,\n", + " 2.6833, 2.2516, 1.8191, 1.3859, 0.9523, 0.5183])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 8878 adversary: AdversaryModes.constant_132\n", + " actions: tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\n", + " 29, 29, 29, 29, 29, 29, 0])\n", + "loss= tensor(0.0617, grad_fn=) , base rewards= tensor([13.8555, 13.3442, 12.8204, 12.2871, 11.7465, 11.2005, 10.6504, 10.0972,\n", + " 9.5417, 8.9844, 8.4258, 7.8663, 7.3060, 6.7452, 6.1839, 5.6224,\n", + " 5.0606, 4.4986, 3.9365, 3.3743, 2.8120, 2.2497, 1.6873, 1.1249,\n", + " 0.5624]) return= 225610.63312213228\n", + "probs of actions: tensor([0.9990, 0.9992, 0.9993, 0.9995, 0.9995, 0.9992, 0.9998, 0.9999, 0.9996,\n", + " 1.0000, 1.0000, 1.0000, 0.9999, 0.9999, 0.9997, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 0.9972, 0.9874, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4271, 0.5499, 0.6507, 0.7311, 0.7942, 0.8430, 0.8805, 0.9091, 0.9309,\n", + " 0.9473, 0.9598, 0.9691, 0.9762, 0.9815, 0.9855, 0.9885, 0.9907, 0.9924,\n", + " 0.9937, 0.9946, 0.9954, 0.9959, 0.9963, 0.9966, 1.0809])\n", + "finalReturns: tensor([8.7056, 8.7897, 8.7636, 8.6463, 8.4558, 8.2076, 7.9147, 7.5873, 7.2337,\n", + " 6.8601, 6.4713, 6.0711, 5.6622, 5.2469, 4.8266, 4.4027, 3.9760, 3.5472,\n", + " 3.1169, 2.6854, 2.2531, 1.8200, 1.3865, 0.9526, 0.5185])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682631035 saved\n", + "[1244302, 'tensor([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 225610.63312213228, 21262.174331621536, 0.061683181673288345, 1e-05, 1, 0, 'tensor([29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,\\n 29, 29, 29, 29, 29, 29, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.99 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1682631035', 25, 50, 174060.25019204617, 225611.5396441756, 94497.47055325202, 131149.86666666667, 128142.59199999999, 65242.24251310914, 65242.24251310914, 80629.96159612676, 80629.96159612676, 109136.08826110291, 65218.96207421804, 80629.96159612676]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 0, 0, 38, 0, 1, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0,\n", + " 1, 0, 1, 0, 0, 1, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482,\n", + " 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482,\n", + " 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482, 0.1482]) return= 51639.70510999265\n", + "probs of actions: tensor([8.0034e-01, 8.2695e-01, 3.4396e-04, 8.0664e-01, 1.2781e-01, 7.9923e-01,\n", + " 1.9496e-02, 7.3233e-01, 7.9346e-01, 1.3482e-01, 7.8419e-01, 7.5348e-01,\n", + " 1.3699e-01, 7.8668e-01, 7.3267e-01, 7.2963e-01, 7.8819e-01, 7.6218e-01,\n", + " 1.3528e-01, 7.8927e-01, 1.3168e-01, 7.7874e-01, 7.6106e-01, 1.3310e-01,\n", + " 9.4036e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3985, 0.1787, 0.3799, 0.3104, 0.2657, 0.2315, 0.2127, 0.1944,\n", + " 0.1811, 0.1737, 0.1661, 0.1604, 0.1584, 0.1548, 0.1522, 0.1502, 0.1488,\n", + " 0.1476, 0.1488, 0.1476, 0.1488, 0.1477, 0.1468, 0.1482])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 6, 4, 8, 0, 6, 6, 7, 0, 13, 3, 7, 0, 5, 6, 7, 7, 4, 4,\n", + " 0, 7, 6, 0, 1, 4, 0])\n", + "loss= tensor(0.0107, grad_fn=) , base rewards= tensor([0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310,\n", + " 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310,\n", + " 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.3310, 0.1624]) return= 56826.748788899706\n", + "probs of actions: tensor([0.2833, 0.2137, 0.0058, 0.1687, 0.2598, 0.2771, 0.2007, 0.1315, 0.0016,\n", + " 0.0535, 0.2105, 0.1792, 0.0410, 0.2486, 0.2121, 0.2264, 0.1918, 0.1917,\n", + " 0.1469, 0.1903, 0.2626, 0.1697, 0.0305, 0.1974, 0.9888],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.4160, 0.3413, 0.3105, 0.2595, 0.2411, 0.2265, 0.2240, 0.1856,\n", + " 0.2153, 0.1987, 0.2033, 0.1852, 0.1834, 0.1837, 0.1871, 0.1930, 0.1884,\n", + " 0.1865, 0.1706, 0.1785, 0.1849, 0.1742, 0.1670, 0.1706])\n", + "finalReturns: tensor([0.0066, 0.0082])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 7, 7, 7, 7, 7, 14, 7, 7, 7, 7, 12, 7, 7, 6, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 0])\n", + "loss= tensor(0.0059, grad_fn=) , base rewards= tensor([0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673,\n", + " 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.5673,\n", + " 0.5673, 0.5673, 0.5673, 0.5673, 0.5673, 0.3640, 0.1763]) return= 61396.95122420932\n", + "probs of actions: tensor([0.9033, 0.9047, 0.9016, 0.8795, 0.8839, 0.0039, 0.8793, 0.8599, 0.8975,\n", + " 0.8653, 0.0223, 0.8265, 0.8999, 0.0598, 0.8802, 0.8758, 0.8795, 0.8736,\n", + " 0.8427, 0.8736, 0.8772, 0.8745, 0.9073, 0.9292, 0.9986],\n", + " grad_fn=)\n", + "rewards: tensor([0.5063, 0.4160, 0.3540, 0.3107, 0.2801, 0.2435, 0.2600, 0.2436, 0.2317,\n", + " 0.2229, 0.2069, 0.2234, 0.2168, 0.2132, 0.2060, 0.2039, 0.2023, 0.2011,\n", + " 0.2002, 0.1996, 0.1991, 0.1987, 0.1984, 0.1982, 0.2030])\n", + "finalReturns: tensor([0.0323, 0.0372, 0.0267])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12, 7, 12, 12, 7, 7, 12, 12,\n", + " 10, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0066, grad_fn=) , base rewards= tensor([0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348,\n", + " 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348, 0.8348,\n", + " 0.8348, 0.8348, 0.8348, 0.8348, 0.5933, 0.3783, 0.1824]) return= 67207.34217323098\n", + "probs of actions: tensor([0.9530, 0.9572, 0.9566, 0.9385, 0.9367, 0.0018, 0.9516, 0.9293, 0.9447,\n", + " 0.9415, 0.9464, 0.0281, 0.9350, 0.9386, 0.0333, 0.0270, 0.9371, 0.9286,\n", + " 0.0046, 0.9552, 0.9292, 0.9849, 0.9793, 0.9724, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2955, 0.2673, 0.2592, 0.2532,\n", + " 0.2487, 0.2454, 0.2525, 0.2286, 0.2304, 0.2412, 0.2299, 0.2121, 0.2179,\n", + " 0.2266, 0.2207, 0.2244, 0.2271, 0.2292, 0.2308, 0.2464])\n", + "finalReturns: tensor([0.0988, 0.1132, 0.0989, 0.0641])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0034, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9908, 0.9920, 0.9920, 0.9888, 0.9875, 0.9919, 0.9900, 0.9860, 0.9891,\n", + " 0.9871, 0.9900, 0.9854, 0.9871, 0.9887, 0.9851, 0.9900, 0.9875, 0.9859,\n", + " 0.9865, 0.9914, 0.9903, 0.9968, 0.9954, 0.9957, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0025, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9955, 0.9963, 0.9964, 0.9952, 0.9943, 0.9963, 0.9954, 0.9935, 0.9951,\n", + " 0.9938, 0.9956, 0.9930, 0.9943, 0.9949, 0.9932, 0.9956, 0.9942, 0.9936,\n", + " 0.9938, 0.9969, 0.9960, 0.9991, 0.9979, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0020, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9976, 0.9981, 0.9982, 0.9974, 0.9970, 0.9981, 0.9975, 0.9964, 0.9973,\n", + " 0.9966, 0.9977, 0.9961, 0.9969, 0.9973, 0.9962, 0.9976, 0.9969, 0.9965,\n", + " 0.9972, 0.9989, 0.9987, 0.9997, 0.9990, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 45969 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214,\n", + " 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214,\n", + " 1.2697, 1.0477, 0.8466, 0.6606, 0.4855, 0.3183, 0.1570]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9988, 0.9991,\n", + " 0.9989, 0.9993, 0.9987, 0.9990, 0.9992, 0.9989, 0.9992, 0.9991, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3837, 0.3981, 0.3833, 0.3478, 0.2976, 0.2366, 0.1678, 0.0932])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0012, grad_fn=) , base rewards= tensor([1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770,\n", + " 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.4248,\n", + " 1.2024, 1.0011, 0.8148, 0.6396, 0.4723, 0.3109, 0.1538]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9988, 0.9991,\n", + " 0.9989, 0.9993, 0.9987, 0.9990, 0.9992, 0.9989, 0.9992, 0.9991, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.4658, 0.4802, 0.4654, 0.4299, 0.3796, 0.3186, 0.2498, 0.1752, 0.0964])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0019, grad_fn=) , base rewards= tensor([1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309,\n", + " 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.5780, 1.3551,\n", + " 1.1534, 0.9669, 0.7914, 0.6240, 0.4625, 0.3054, 0.1515]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9988, 0.9991,\n", + " 0.9989, 0.9993, 0.9987, 0.9990, 0.9992, 0.9989, 0.9992, 0.9991, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.5504, 0.5648, 0.5499, 0.5144, 0.4641, 0.4030, 0.3342, 0.2596, 0.1807,\n", + " 0.0987])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 14 ep 66 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0025, grad_fn=) , base rewards= tensor([1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839,\n", + " 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.7301, 1.5065, 1.3043,\n", + " 1.1175, 0.9417, 0.7741, 0.6125, 0.4553, 0.3013, 0.1497]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9989, 0.9992,\n", + " 0.9989, 0.9993, 0.9987, 0.9991, 0.9992, 0.9990, 0.9993, 0.9992, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.6368, 0.6512, 0.6363, 0.6007, 0.5503, 0.4892, 0.4203, 0.3457, 0.2668,\n", + " 0.1848, 0.1005])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0034, grad_fn=) , base rewards= tensor([2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368,\n", + " 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 1.8817, 1.6572, 1.4543, 1.2670,\n", + " 1.0910, 0.9231, 0.7613, 0.6040, 0.4499, 0.2982, 0.1484]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9989, 0.9992,\n", + " 0.9989, 0.9993, 0.9987, 0.9991, 0.9992, 0.9990, 0.9993, 0.9992, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.7246, 0.7390, 0.7241, 0.6884, 0.6380, 0.5768, 0.5079, 0.4332, 0.3542,\n", + " 0.2722, 0.1879, 0.1018])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903,\n", + " 2.2903, 2.2903, 2.2903, 2.2903, 2.0334, 1.8077, 1.6040, 1.4161, 1.2396,\n", + " 1.0714, 0.9093, 0.7518, 0.5976, 0.4458, 0.2960, 0.1475]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9995, 0.9992, 0.9991, 0.9994, 0.9992, 0.9989, 0.9992,\n", + " 0.9989, 0.9993, 0.9987, 0.9991, 0.9992, 0.9990, 0.9993, 0.9992, 0.9990,\n", + " 0.9998, 0.9998, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.8136, 0.8280, 0.8130, 0.7773, 0.7267, 0.6655, 0.5964, 0.5217, 0.4427,\n", + " 0.3606, 0.2762, 0.1901, 0.1027])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 5857 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451,\n", + " 2.4451, 2.4451, 2.4451, 2.1859, 1.9586, 1.7537, 1.5650, 1.3879, 1.2192,\n", + " 1.0569, 0.8991, 0.7447, 0.5928, 0.4428, 0.2943, 0.1467]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.9036, 0.9180, 0.9029, 0.8670, 0.8163, 0.7549, 0.6858, 0.6110, 0.5319,\n", + " 0.4498, 0.3654, 0.2792, 0.1918, 0.1035])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021,\n", + " 2.6021, 2.6021, 2.3399, 2.1104, 1.9040, 1.7141, 1.5362, 1.3670, 1.2041,\n", + " 1.0460, 0.8914, 0.7394, 0.5893, 0.4406, 0.2930, 0.1462]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.9944, 1.0088, 0.9935, 0.9575, 0.9066, 0.8451, 0.7758, 0.7009, 0.6218,\n", + " 0.5396, 0.4551, 0.3689, 0.2815, 0.1931, 0.1040])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0047, grad_fn=) , base rewards= tensor([2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625,\n", + " 2.7625, 2.4961, 2.2637, 2.0552, 1.8638, 1.6848, 1.5149, 1.3514, 1.1929,\n", + " 1.0380, 0.8857, 0.7354, 0.5866, 0.4389, 0.2920, 0.1458]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.0860, 1.1004, 1.0850, 1.0487, 0.9976, 0.9359, 0.8664, 0.7913, 0.7121,\n", + " 0.6298, 0.5453, 0.4591, 0.3716, 0.2832, 0.1941, 0.1044])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0057, grad_fn=) , base rewards= tensor([2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276,\n", + " 2.6556, 2.4193, 2.2080, 2.0147, 1.8342, 1.6632, 1.4990, 1.3399, 1.1845,\n", + " 1.0319, 0.8814, 0.7324, 0.5846, 0.4376, 0.2913, 0.1455]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.1785, 1.1929, 1.1773, 1.1406, 1.0892, 1.0272, 0.9575, 0.8823, 0.8029,\n", + " 0.7205, 0.6359, 0.5496, 0.4620, 0.3736, 0.2844, 0.1948, 0.1047])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0070, grad_fn=) , base rewards= tensor([3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 2.8197,\n", + " 2.5781, 2.3632, 2.1671, 1.9848, 1.8123, 1.6471, 1.4872, 1.3313, 1.1783,\n", + " 1.0274, 0.8782, 0.7302, 0.5831, 0.4367, 0.2908, 0.1453]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.2720, 1.2864, 1.2704, 1.2334, 1.1815, 1.1191, 1.0491, 0.9736, 0.8941,\n", + " 0.8115, 0.7268, 0.6404, 0.5528, 0.4643, 0.3751, 0.2854, 0.1953, 0.1050])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.constant_95\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0080, grad_fn=) , base rewards= tensor([3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 2.9902, 2.7415,\n", + " 2.5215, 2.3219, 2.1370, 1.9626, 1.7960, 1.6351, 1.4784, 1.3248, 1.1736,\n", + " 1.0241, 0.8758, 0.7286, 0.5820, 0.4360, 0.2904, 0.1451]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.3666, 1.3810, 1.3646, 1.3270, 1.2746, 1.2117, 1.1413, 1.0654, 0.9856,\n", + " 0.9029, 0.8179, 0.7314, 0.6437, 0.5552, 0.4659, 0.3762, 0.2861, 0.1957,\n", + " 0.1051])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0089, grad_fn=) , base rewards= tensor([3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.1695, 2.9111, 2.6844,\n", + " 2.4799, 2.2915, 2.1146, 1.9461, 1.7839, 1.6262, 1.4718, 1.3200, 1.1701,\n", + " 1.0215, 0.8740, 0.7273, 0.5812, 0.4355, 0.2901, 0.1450]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.4627, 1.4771, 1.4601, 1.4217, 1.3686, 1.3050, 1.2341, 1.1578, 1.0776,\n", + " 0.9945, 0.9094, 0.8228, 0.7349, 0.6463, 0.5570, 0.4672, 0.3770, 0.2866,\n", + " 0.1960, 0.1053])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0102, grad_fn=) , base rewards= tensor([3.6835, 3.6835, 3.6835, 3.6835, 3.6835, 3.3608, 3.0893, 2.8534, 2.6424,\n", + " 2.4492, 2.2689, 2.0980, 1.9339, 1.7748, 1.6195, 1.4669, 1.3164, 1.1675,\n", + " 1.0197, 0.8727, 0.7264, 0.5805, 0.4351, 0.2899, 0.1449]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.5606, 1.5750, 1.5572, 1.5179, 1.4637, 1.3993, 1.3276, 1.2507, 1.1700,\n", + " 1.0866, 1.0012, 0.9143, 0.8264, 0.7376, 0.6482, 0.5583, 0.4681, 0.3777,\n", + " 0.2870, 0.1962, 0.1054])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0114, grad_fn=) , base rewards= tensor([3.9177, 3.9177, 3.9177, 3.9177, 3.5687, 3.2793, 3.0307, 2.8109, 2.6114,\n", + " 2.4265, 2.2522, 2.0856, 1.9247, 1.7680, 1.6145, 1.4632, 1.3137, 1.1655,\n", + " 1.0182, 0.8717, 0.7257, 0.5801, 0.4348, 0.2897, 0.1448]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.6609, 1.6753, 1.6565, 1.6158, 1.5603, 1.4947, 1.4220, 1.3444, 1.2631,\n", + " 1.1792, 1.0934, 1.0062, 0.9180, 0.8291, 0.7395, 0.6496, 0.5593, 0.4688,\n", + " 0.3781, 0.2873, 0.1964, 0.1054])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0123, grad_fn=) , base rewards= tensor([4.1854, 4.1854, 4.1854, 3.7998, 3.4854, 3.2196, 2.9877, 2.7795, 2.5884,\n", + " 2.4096, 2.2397, 2.0764, 1.9179, 1.7630, 1.6108, 1.4605, 1.3117, 1.1640,\n", + " 1.0172, 0.8709, 0.7252, 0.5797, 0.4345, 0.2896, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9991, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.7644, 1.7788, 1.7586, 1.7161, 1.6589, 1.5917, 1.5177, 1.4390, 1.3568,\n", + " 1.2723, 1.1860, 1.0985, 1.0100, 0.9208, 0.8311, 0.7410, 0.6506, 0.5601,\n", + " 0.4693, 0.3785, 0.2875, 0.1965, 0.1055])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([4.5005, 4.5005, 4.0633, 3.7141, 3.4244, 3.1758, 2.9558, 2.7562, 2.5713,\n", + " 2.3970, 2.2304, 2.0695, 1.9128, 1.7592, 1.6080, 1.4584, 1.3102, 1.1629,\n", + " 1.0164, 0.8704, 0.7248, 0.5795, 0.4344, 0.2895, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9992, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.8720, 1.8864, 1.8645, 1.8196, 1.7600, 1.6907, 1.6150, 1.5348, 1.4516,\n", + " 1.3662, 1.2792, 1.1911, 1.1022, 1.0128, 0.9228, 0.8326, 0.7421, 0.6514,\n", + " 0.5606, 0.4697, 0.3787, 0.2877, 0.1966, 0.1055])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([4.8841, 4.3729, 3.9744, 3.6513, 3.3795, 3.1433, 2.9322, 2.7389, 2.5586,\n", + " 2.3875, 2.2234, 2.0643, 1.9089, 1.7564, 1.6059, 1.4569, 1.3091, 1.1621,\n", + " 1.0158, 0.8699, 0.7245, 0.5793, 0.4343, 0.2894, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9995, 0.9996, 0.9996, 0.9994, 0.9993, 0.9996, 0.9994, 0.9992, 0.9994,\n", + " 0.9992, 0.9995, 0.9990, 0.9998, 0.9997, 0.9995, 0.9998, 0.9997, 0.9993,\n", + " 0.9998, 0.9999, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.9853, 1.9997, 1.9753, 1.9272, 1.8645, 1.7924, 1.7143, 1.6323, 1.5475,\n", + " 1.4610, 1.3731, 1.2844, 1.1950, 1.1051, 1.0148, 0.9244, 0.8337, 0.7429,\n", + " 0.6520, 0.5610, 0.4700, 0.3789, 0.2878, 0.1967, 0.1056])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682652460 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[891910, 'tensor([0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 68694.09895647192, 88516.4319236399, 0.014486568048596382, 1e-05, 1, 0, 'tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\\n 12, 12, 12, 12, 12, 12, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682652460', 25, 50, 157611.33342506486, 175538.2609849781, 68707.8951114289, 135313.23466666666, 132439.05866666668, 122329.26544005591, 122329.26544005591, 130254.64915679736, 130254.64915679736, 80045.82189636558, 122329.26544005591, 130254.64915679736]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455,\n", + " 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455,\n", + " 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455, 0.1455]) return= 48892.64112506197\n", + "probs of actions: tensor([0.8787, 0.8940, 0.8694, 0.8601, 0.8593, 0.8601, 0.8369, 0.8052, 0.8556,\n", + " 0.8616, 0.8490, 0.8605, 0.8540, 0.8323, 0.8056, 0.8109, 0.8350, 0.8404,\n", + " 0.8529, 0.8607, 0.0669, 0.8381, 0.8490, 0.8036, 0.9799],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.3985, 0.3231, 0.2718, 0.2362, 0.2111, 0.1933, 0.1804, 0.1710,\n", + " 0.1641, 0.1591, 0.1554, 0.1526, 0.1505, 0.1490, 0.1478, 0.1470, 0.1463,\n", + " 0.1458, 0.1455, 0.1451, 0.1469, 0.1463, 0.1458, 0.1455])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([ 5, 0, 9, 6, 4, 4, 3, 6, 9, 6, 7, 6, 9, 6, 15, 9, 6, 6,\n", + " 5, 5, 6, 7, 5, 9, 0])\n", + "loss= tensor(0.0071, grad_fn=) , base rewards= tensor([0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767,\n", + " 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767,\n", + " 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.3767, 0.1817]) return= 59134.4246096995\n", + "probs of actions: tensor([0.1258, 0.1556, 0.3641, 0.1753, 0.0548, 0.0523, 0.0173, 0.1730, 0.3084,\n", + " 0.1926, 0.1241, 0.1785, 0.2978, 0.1695, 0.0034, 0.2990, 0.1839, 0.1763,\n", + " 0.1376, 0.1150, 0.2031, 0.1178, 0.1148, 0.5464, 0.9951],\n", + " grad_fn=)\n", + "rewards: tensor([0.5087, 0.4144, 0.3258, 0.2998, 0.2721, 0.2458, 0.2276, 0.2089, 0.1996,\n", + " 0.2074, 0.2017, 0.2019, 0.1944, 0.2034, 0.1811, 0.2137, 0.2180, 0.2108,\n", + " 0.2066, 0.2004, 0.1947, 0.1922, 0.1960, 0.1869, 0.2014])\n", + "finalReturns: tensor([0.0116, 0.0197])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0002, grad_fn=) , base rewards= tensor([0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042,\n", + " 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.6042,\n", + " 0.6042, 0.6042, 0.6042, 0.6042, 0.6042, 0.3844, 0.1849]) return= 63727.41292382953\n", + "probs of actions: tensor([0.9949, 0.9901, 0.9940, 0.9882, 0.9920, 0.9925, 0.9934, 0.9894, 0.9914,\n", + " 0.9911, 0.9930, 0.9908, 0.9882, 0.9847, 0.9907, 0.9878, 0.9905, 0.0035,\n", + " 0.9919, 0.9858, 0.9927, 0.9911, 0.9983, 0.9988, 0.9993],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2177,\n", + " 0.2094, 0.2103, 0.2109, 0.2114, 0.2117, 0.2120, 0.2203])\n", + "finalReturns: tensor([0.0398, 0.0479, 0.0354])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 113089 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 9, 9,\n", + " 0])\n", + "loss= tensor(7.9259e-05, grad_fn=) , base rewards= tensor([0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613,\n", + " 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.5613,\n", + " 0.5613, 0.5613, 0.5613, 0.5613, 0.5613, 0.3606, 0.1749]) return= 63459.11549104476\n", + "probs of actions: tensor([9.9744e-01, 9.9532e-01, 9.9700e-01, 9.9432e-01, 9.9599e-01, 9.9599e-01,\n", + " 9.9645e-01, 9.9433e-01, 9.9540e-01, 9.9529e-01, 9.9630e-01, 9.9524e-01,\n", + " 9.9393e-01, 9.9210e-01, 9.9491e-01, 9.9326e-01, 9.9492e-01, 9.9538e-01,\n", + " 9.9567e-01, 9.9287e-01, 9.9599e-01, 8.9096e-04, 9.9901e-01, 9.9946e-01,\n", + " 9.9952e-01], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2214, 0.1925, 0.1975, 0.2094])\n", + "finalReturns: tensor([0.0382, 0.0463, 0.0345])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 25407 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0001, grad_fn=) , base rewards= tensor([0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827,\n", + " 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827, 0.7827,\n", + " 0.7827, 0.7827, 0.7827, 0.7827, 0.5613, 0.3606, 0.1749]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9993, 0.9987, 0.9991, 0.9989, 0.9990, 0.9985, 0.9987,\n", + " 0.9987, 0.9990, 0.9988, 0.9985, 0.9981, 0.9986, 0.9981, 0.9986, 0.9988,\n", + " 0.9988, 0.9983, 0.9989, 0.9990, 0.9998, 1.0000, 0.9996],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.0781, 0.0862, 0.0736, 0.0462])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 42 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502,\n", + " 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502, 0.9502,\n", + " 0.9502, 0.9502, 0.9502, 0.7286, 0.5278, 0.3420, 0.1671]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9994, 0.9990, 0.9993, 0.9987, 0.9991, 0.9989, 0.9991, 0.9985, 0.9987,\n", + " 0.9987, 0.9990, 0.9988, 0.9985, 0.9981, 0.9986, 0.9982, 0.9987, 0.9988,\n", + " 0.9988, 0.9983, 0.9990, 0.9990, 0.9998, 1.0000, 0.9996],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.1241, 0.1322, 0.1196, 0.0922, 0.0541])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 280 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0005, grad_fn=) , base rewards= tensor([1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122,\n", + " 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122, 1.1122,\n", + " 1.1122, 1.1122, 0.8904, 0.6894, 0.5035, 0.3284, 0.1613]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9995, 0.9992, 0.9994, 0.9989, 0.9992, 0.9991, 0.9992, 0.9987, 0.9989,\n", + " 0.9989, 0.9992, 0.9990, 0.9987, 0.9985, 0.9989, 0.9985, 0.9989, 0.9990,\n", + " 0.9990, 0.9990, 0.9994, 0.9992, 0.9998, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.1759, 0.1840, 0.1714, 0.1440, 0.1058, 0.0598])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 1 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0008, grad_fn=) , base rewards= tensor([1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703,\n", + " 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703, 1.2703,\n", + " 1.2703, 1.0481, 0.8469, 0.6608, 0.4856, 0.3184, 0.1570]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9995, 0.9992, 0.9994, 0.9989, 0.9992, 0.9991, 0.9992, 0.9987, 0.9989,\n", + " 0.9990, 0.9992, 0.9990, 0.9987, 0.9985, 0.9989, 0.9985, 0.9989, 0.9990,\n", + " 0.9990, 0.9990, 0.9994, 0.9992, 0.9998, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.2319, 0.2400, 0.2274, 0.2000, 0.1619, 0.1159, 0.0641])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0013, grad_fn=) , base rewards= tensor([1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255,\n", + " 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255, 1.4255,\n", + " 1.2029, 1.0014, 0.8151, 0.6397, 0.4724, 0.3110, 0.1539]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9995, 0.9992, 0.9994, 0.9989, 0.9992, 0.9991, 0.9992, 0.9987, 0.9990,\n", + " 0.9990, 0.9992, 0.9990, 0.9987, 0.9985, 0.9989, 0.9985, 0.9989, 0.9990,\n", + " 0.9990, 0.9990, 0.9994, 0.9992, 0.9998, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.2912, 0.2993, 0.2867, 0.2593, 0.2211, 0.1751, 0.1233, 0.0673])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 16 ep 27 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790,\n", + " 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.5790, 1.3558,\n", + " 1.1539, 0.9672, 0.7917, 0.6242, 0.4626, 0.3055, 0.1515]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9995, 0.9992, 0.9995, 0.9990, 0.9993, 0.9992, 0.9993, 0.9988, 0.9990,\n", + " 0.9990, 0.9992, 0.9991, 0.9988, 0.9985, 0.9989, 0.9985, 0.9990, 0.9991,\n", + " 0.9991, 0.9991, 0.9994, 0.9992, 0.9998, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.3529, 0.3610, 0.3483, 0.3209, 0.2827, 0.2366, 0.1848, 0.1288, 0.0696])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 96 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314,\n", + " 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.7314, 1.5074, 1.3050,\n", + " 1.1179, 0.9421, 0.7744, 0.6127, 0.4554, 0.3014, 0.1498]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9996, 0.9994, 0.9996, 0.9992, 0.9994, 0.9993, 0.9994, 0.9990, 0.9992,\n", + " 0.9992, 0.9994, 0.9993, 0.9991, 0.9988, 0.9991, 0.9990, 0.9993, 0.9994,\n", + " 0.9994, 0.9993, 0.9996, 0.9994, 0.9999, 1.0000, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.4163, 0.4244, 0.4118, 0.3843, 0.3460, 0.3000, 0.2481, 0.1921, 0.1329,\n", + " 0.0714])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0024, grad_fn=) , base rewards= tensor([1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.8835,\n", + " 1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.8835, 1.6585, 1.4553, 1.2677,\n", + " 1.0915, 0.9235, 0.7615, 0.6041, 0.4500, 0.2983, 0.1485]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9996, 0.9994, 0.9996, 0.9992, 0.9994, 0.9993, 0.9994, 0.9990, 0.9992,\n", + " 0.9992, 0.9994, 0.9993, 0.9991, 0.9988, 0.9991, 0.9990, 0.9993, 0.9994,\n", + " 0.9994, 0.9993, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.4812, 0.4893, 0.4766, 0.4490, 0.4108, 0.3646, 0.3128, 0.2567, 0.1975,\n", + " 0.1359, 0.0727])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 29 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0028, grad_fn=) , base rewards= tensor([2.0358, 2.0358, 2.0358, 2.0358, 2.0358, 2.0358, 2.0358, 2.0358, 2.0358,\n", + " 2.0358, 2.0358, 2.0358, 2.0358, 2.0358, 1.8094, 1.6052, 1.4170, 1.2402,\n", + " 1.0719, 0.9097, 0.7520, 0.5977, 0.4459, 0.2960, 0.1475]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9993, 0.9991, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.5471, 0.5552, 0.5425, 0.5149, 0.4765, 0.4303, 0.3784, 0.3223, 0.2631,\n", + " 0.2015, 0.1382, 0.0736])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0035, grad_fn=) , base rewards= tensor([2.1892, 2.1892, 2.1892, 2.1892, 2.1892, 2.1892, 2.1892, 2.1892, 2.1892,\n", + " 2.1892, 2.1892, 2.1892, 2.1892, 1.9609, 1.7554, 1.5662, 1.3887, 1.2199,\n", + " 1.0573, 0.8994, 0.7449, 0.5930, 0.4429, 0.2943, 0.1468]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9993, 0.9991, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.6140, 0.6221, 0.6093, 0.5815, 0.5431, 0.4969, 0.4449, 0.3887, 0.3294,\n", + " 0.2678, 0.2045, 0.1399, 0.0744])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0042, grad_fn=) , base rewards= tensor([2.3442, 2.3442, 2.3442, 2.3442, 2.3442, 2.3442, 2.3442, 2.3442, 2.3442,\n", + " 2.3442, 2.3442, 2.3442, 2.1135, 1.9062, 1.7157, 1.5374, 1.3678, 1.2048,\n", + " 1.0465, 0.8917, 0.7396, 0.5894, 0.4407, 0.2930, 0.1462]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9993, 0.9991, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.6815, 0.6896, 0.6767, 0.6489, 0.6104, 0.5640, 0.5120, 0.4557, 0.3964,\n", + " 0.3347, 0.2714, 0.2068, 0.1412, 0.0749])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0048, grad_fn=) , base rewards= tensor([2.5019, 2.5019, 2.5019, 2.5019, 2.5019, 2.5019, 2.5019, 2.5019, 2.5019,\n", + " 2.5019, 2.5019, 2.2679, 2.0583, 1.8661, 1.6865, 1.5160, 1.3523, 1.1935,\n", + " 1.0384, 0.8860, 0.7356, 0.5867, 0.4390, 0.2921, 0.1458]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9991, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.7498, 0.7579, 0.7449, 0.7169, 0.6782, 0.6317, 0.5795, 0.5232, 0.4638,\n", + " 0.4021, 0.3387, 0.2740, 0.2085, 0.1422, 0.0753])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0055, grad_fn=) , base rewards= tensor([2.6635, 2.6635, 2.6635, 2.6635, 2.6635, 2.6635, 2.6635, 2.6635, 2.6635,\n", + " 2.6635, 2.4249, 2.2121, 2.0177, 1.8364, 1.6648, 1.5002, 1.3408, 1.1852,\n", + " 1.0324, 0.8817, 0.7327, 0.5848, 0.4377, 0.2914, 0.1455]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9991, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.8187, 0.8268, 0.8136, 0.7854, 0.7465, 0.6999, 0.6475, 0.5911, 0.5316,\n", + " 0.4698, 0.4064, 0.3417, 0.2760, 0.2097, 0.1429, 0.0756])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0063, grad_fn=) , base rewards= tensor([2.8303, 2.8303, 2.8303, 2.8303, 2.8303, 2.8303, 2.8303, 2.8303, 2.8303,\n", + " 2.5858, 2.3687, 2.1712, 1.9877, 1.8145, 1.6487, 1.4884, 1.3321, 1.1789,\n", + " 1.0279, 0.8785, 0.7304, 0.5833, 0.4368, 0.2908, 0.1453]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9994, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.8883, 0.8964, 0.8830, 0.8546, 0.8154, 0.7685, 0.7160, 0.6594, 0.5997,\n", + " 0.5378, 0.4743, 0.4096, 0.3439, 0.2775, 0.2107, 0.1434, 0.0759])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0073, grad_fn=) , base rewards= tensor([3.0045, 3.0045, 3.0045, 3.0045, 3.0045, 3.0045, 3.0045, 3.0045, 2.7518,\n", + " 2.5290, 2.3274, 2.1410, 1.9656, 1.7982, 1.6367, 1.4796, 1.3257, 1.1742,\n", + " 1.0245, 0.8761, 0.7288, 0.5822, 0.4361, 0.2904, 0.1451]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.9587, 0.9668, 0.9531, 0.9243, 0.8848, 0.8376, 0.7848, 0.7280, 0.6682,\n", + " 0.6062, 0.5425, 0.4777, 0.4120, 0.3456, 0.2786, 0.2114, 0.1438, 0.0760])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 0 adversary: AdversaryModes.constant_95\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0080, grad_fn=) , base rewards= tensor([3.1888, 3.1888, 3.1888, 3.1888, 3.1888, 3.1888, 3.1888, 2.9251, 2.6945,\n", + " 2.4873, 2.2969, 2.1186, 1.9491, 1.7860, 1.6278, 1.4730, 1.3209, 1.1707,\n", + " 1.0220, 0.8744, 0.7275, 0.5813, 0.4356, 0.2901, 0.1450]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9994, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.0301, 1.0382, 1.0241, 0.9949, 0.9548, 0.9072, 0.8541, 0.7969, 0.7369,\n", + " 0.6747, 0.6110, 0.5460, 0.4802, 0.4138, 0.3468, 0.2795, 0.2119, 0.1441,\n", + " 0.0762])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0089, grad_fn=) , base rewards= tensor([3.3871, 3.3871, 3.3871, 3.3871, 3.3871, 3.3871, 3.1081, 2.8670, 2.6523,\n", + " 2.4565, 2.2743, 2.1019, 1.9368, 1.7770, 1.6211, 1.4681, 1.3173, 1.1681,\n", + " 1.0201, 0.8730, 0.7266, 0.5807, 0.4352, 0.2899, 0.1449]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9990, 0.9993, 0.9991, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.1027, 1.1108, 1.0963, 1.0663, 1.0257, 0.9775, 0.9238, 0.8663, 0.8060,\n", + " 0.7436, 0.6797, 0.6146, 0.5487, 0.4821, 0.4151, 0.3477, 0.2801, 0.2123,\n", + " 0.1443, 0.0763])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0096, grad_fn=) , base rewards= tensor([3.6046, 3.6046, 3.6046, 3.6046, 3.6046, 3.3048, 3.0491, 2.8242, 2.6211,\n", + " 2.4337, 2.2575, 2.0895, 1.9276, 1.7702, 1.6161, 1.4644, 1.3146, 1.1661,\n", + " 1.0187, 0.8720, 0.7259, 0.5802, 0.4349, 0.2897, 0.1448]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9991, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9991, 0.9993, 0.9992, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9994, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.1768, 1.1849, 1.1698, 1.1390, 1.0975, 1.0485, 0.9943, 0.9362, 0.8755,\n", + " 0.8128, 0.7486, 0.6833, 0.6173, 0.5506, 0.4835, 0.4161, 0.3484, 0.2806,\n", + " 0.2126, 0.1445, 0.0763])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0105, grad_fn=) , base rewards= tensor([3.8490, 3.8490, 3.8490, 3.8490, 3.5203, 3.2446, 3.0057, 2.7927, 2.5981,\n", + " 2.4167, 2.2449, 2.0803, 1.9208, 1.7651, 1.6123, 1.4617, 1.3126, 1.1647,\n", + " 1.0176, 0.8713, 0.7254, 0.5799, 0.4346, 0.2896, 0.1447]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9992, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9991, 0.9993, 0.9992, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9995, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.2530, 1.2611, 1.2451, 1.2132, 1.1705, 1.1206, 1.0655, 1.0068, 0.9455,\n", + " 0.8824, 0.8178, 0.7523, 0.6861, 0.6193, 0.5521, 0.4846, 0.4169, 0.3490,\n", + " 0.2809, 0.2128, 0.1446, 0.0764])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0111, grad_fn=) , base rewards= tensor([4.1314, 4.1314, 4.1314, 3.7620, 3.4586, 3.2004, 2.9737, 2.7693, 2.5809,\n", + " 2.4040, 2.2356, 2.0733, 1.9156, 1.7613, 1.6095, 1.4596, 1.3111, 1.1635,\n", + " 1.0168, 0.8707, 0.7250, 0.5796, 0.4345, 0.2895, 0.1447]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9992, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9991, 0.9993, 0.9992, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9995, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.3319, 1.3400, 1.3228, 1.2894, 1.2452, 1.1939, 1.1377, 1.0781, 1.0161,\n", + " 0.9524, 0.8875, 0.8216, 0.7551, 0.6881, 0.6208, 0.5532, 0.4854, 0.4174,\n", + " 0.3493, 0.2812, 0.2130, 0.1447, 0.0764])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0120, grad_fn=) , base rewards= tensor([4.4683, 4.4683, 4.0409, 3.6983, 3.4131, 3.1676, 2.9499, 2.7519, 2.5681,\n", + " 2.3946, 2.2286, 2.0682, 1.9118, 1.7585, 1.6074, 1.4580, 1.3099, 1.1627,\n", + " 1.0162, 0.8703, 0.7247, 0.5794, 0.4343, 0.2894, 0.1447]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9992, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9991, 0.9993, 0.9992, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9995, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([1.4144, 1.4225, 1.4038, 1.3683, 1.3221, 1.2690, 1.2113, 1.1505, 1.0876,\n", + " 1.0231, 0.9576, 0.8913, 0.8245, 0.7572, 0.6897, 0.6219, 0.5540, 0.4860,\n", + " 0.4178, 0.3496, 0.2814, 0.2131, 0.1448, 0.0765])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0125, grad_fn=) , base rewards= tensor([4.8841, 4.3729, 3.9744, 3.6513, 3.3795, 3.1433, 2.9322, 2.7389, 2.5586,\n", + " 2.3875, 2.2234, 2.0643, 1.9089, 1.7564, 1.6059, 1.4569, 1.3091, 1.1621,\n", + " 1.0158, 0.8699, 0.7245, 0.5793, 0.4343, 0.2894, 0.1447]) return= 63858.06679267008\n", + "probs of actions: tensor([0.9997, 0.9995, 0.9996, 0.9993, 0.9995, 0.9994, 0.9995, 0.9992, 0.9993,\n", + " 0.9993, 0.9995, 0.9994, 0.9992, 0.9991, 0.9993, 0.9992, 0.9994, 0.9995,\n", + " 0.9995, 0.9994, 0.9996, 0.9995, 0.9999, 1.0000, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2138, 0.2135, 0.2133, 0.2132, 0.2131, 0.2211])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finalReturns: tensor([1.5017, 1.5098, 1.4889, 1.4507, 1.4019, 1.3464, 1.2867, 1.2243, 1.1600,\n", + " 1.0946, 1.0283, 0.9615, 0.8942, 0.8266, 0.7588, 0.6909, 0.6228, 0.5546,\n", + " 0.4864, 0.4182, 0.3499, 0.2815, 0.2132, 0.1448, 0.0765])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682661769 saved\n", + "[378994, 'tensor([0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 63858.06679267008, 91921.34476753633, 0.012501846998929977, 1e-05, 1, 0, 'tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\\n 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682661769', 25, 50, 153603.58340915042, 166411.3640199337, 63840.19497842904, 134666.6666666667, 131815.9786666667, 116903.27057727946, 116903.27057727946, 134357.5795423984, 134357.5795423984, 74631.0377323958, 116903.27057727946, 134357.5795423984]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469,\n", + " 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469,\n", + " 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469, 0.1469]) return= 49505.75711012355\n", + "probs of actions: tensor([0.0101, 0.8958, 0.8695, 0.8334, 0.8086, 0.8203, 0.8380, 0.8371, 0.8358,\n", + " 0.8111, 0.8296, 0.8712, 0.0919, 0.0101, 0.8609, 0.0820, 0.8421, 0.8506,\n", + " 0.8459, 0.8274, 0.0171, 0.8530, 0.8225, 0.8343, 0.9739],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.4048, 0.3274, 0.2747, 0.2382, 0.2126, 0.1943, 0.1811, 0.1716,\n", + " 0.1646, 0.1594, 0.1556, 0.1526, 0.1517, 0.1564, 0.1532, 0.1530, 0.1509,\n", + " 0.1492, 0.1480, 0.1467, 0.1503, 0.1488, 0.1477, 0.1469])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 5, 5, 5, 6, 0, 5, 6, 4, 5, 2, 3, 4, 7, 4, 5, 5, 0, 3, 5, 5, 0, 2, 5,\n", + " 0])\n", + "loss= tensor(0.0054, grad_fn=) , base rewards= tensor([0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278,\n", + " 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278,\n", + " 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.3278, 0.1610]) return= 55563.48757478318\n", + "probs of actions: tensor([0.0395, 0.4441, 0.3476, 0.4419, 0.0984, 0.2259, 0.3980, 0.0929, 0.1221,\n", + " 0.3735, 0.0178, 0.0503, 0.1371, 0.0706, 0.1347, 0.3186, 0.3156, 0.1818,\n", + " 0.0519, 0.4018, 0.3445, 0.2042, 0.0182, 0.4977, 0.9952],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.4055, 0.3416, 0.2972, 0.2648, 0.2486, 0.2174, 0.2073, 0.2049,\n", + " 0.1962, 0.1948, 0.1852, 0.1799, 0.1753, 0.1841, 0.1808, 0.1812, 0.1840,\n", + " 0.1728, 0.1698, 0.1729, 0.1777, 0.1687, 0.1643, 0.1712])\n", + "finalReturns: tensor([0.0077, 0.0102])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([11, 9, 11, 12, 12, 9, 15, 12, 12, 9, 11, 11, 11, 17, 12, 11, 12, 11,\n", + " 9, 12, 12, 9, 12, 9, 0])\n", + "loss= tensor(0.1197, grad_fn=) , base rewards= tensor([0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472,\n", + " 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.6472,\n", + " 0.6472, 0.6472, 0.6472, 0.6472, 0.6472, 0.4080, 0.1948]) return= 67657.67510325903\n", + "probs of actions: tensor([0.3362, 0.1559, 0.3439, 0.2915, 0.2712, 0.1769, 0.0220, 0.2707, 0.2781,\n", + " 0.1934, 0.3567, 0.3823, 0.3320, 0.0054, 0.2852, 0.3265, 0.2812, 0.3373,\n", + " 0.1603, 0.2767, 0.2689, 0.1686, 0.4401, 0.2747, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.4259, 0.3619, 0.3234, 0.3002, 0.2896, 0.2550, 0.2639, 0.2567,\n", + " 0.2576, 0.2420, 0.2385, 0.2359, 0.2171, 0.2452, 0.2451, 0.2384, 0.2400,\n", + " 0.2410, 0.2275, 0.2295, 0.2373, 0.2248, 0.2338, 0.2365])\n", + "finalReturns: tensor([0.0479, 0.0623, 0.0417])\n", + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 12, 13, 15, 15, 12, 12, 12, 13, 9, 12, 15, 11, 11, 12, 11, 12,\n", + " 13, 12, 11, 11, 11, 9, 0])\n", + "loss= tensor(0.6629, grad_fn=) , base rewards= tensor([0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528,\n", + " 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528, 0.8528,\n", + " 0.8528, 0.8528, 0.8528, 0.8528, 0.6043, 0.3844, 0.1849]) return= 69577.64726088839\n", + "probs of actions: tensor([0.2457, 0.2400, 0.4711, 0.0916, 0.2515, 0.2377, 0.4269, 0.4518, 0.4405,\n", + " 0.0901, 0.0234, 0.4779, 0.2212, 0.1748, 0.1601, 0.4600, 0.1729, 0.4251,\n", + " 0.0977, 0.4363, 0.1895, 0.1269, 0.1451, 0.0535, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3876, 0.3438, 0.3115, 0.2978, 0.2958, 0.2801, 0.2687,\n", + " 0.2577, 0.2628, 0.2436, 0.2335, 0.2500, 0.2444, 0.2379, 0.2397, 0.2344,\n", + " 0.2322, 0.2374, 0.2393, 0.2364, 0.2343, 0.2367, 0.2387])\n", + "finalReturns: tensor([0.0934, 0.1055, 0.0910, 0.0538])\n", + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 11, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0408, grad_fn=) , base rewards= tensor([1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196,\n", + " 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196, 1.1196,\n", + " 1.1196, 1.1196, 1.1196, 0.8382, 0.5954, 0.3795, 0.1828]) return= 72938.84118085599\n", + "probs of actions: tensor([0.9609, 0.9638, 0.9470, 0.0121, 0.0154, 0.9355, 0.9524, 0.9420, 0.9463,\n", + " 0.9441, 0.9459, 0.9427, 0.9293, 0.9476, 0.9522, 0.9450, 0.9424, 0.9520,\n", + " 0.9369, 0.9393, 0.9634, 0.9825, 0.9491, 0.8879, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3576, 0.3178, 0.2927, 0.2839, 0.2774, 0.2726,\n", + " 0.2690, 0.2664, 0.2644, 0.2629, 0.2617, 0.2609, 0.2603, 0.2598, 0.2595,\n", + " 0.2592, 0.2590, 0.2588, 0.2587, 0.2587, 0.2586, 0.2810])\n", + "finalReturns: tensor([0.1963, 0.2188, 0.2029, 0.1601, 0.0982])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0125, grad_fn=) , base rewards= tensor([1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935,\n", + " 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935, 1.2935,\n", + " 1.2935, 1.2935, 1.0118, 0.7687, 0.5526, 0.3558, 0.1729]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9926, 0.9932, 0.9889, 0.9853, 0.9862, 0.9855, 0.9897, 0.9877, 0.9884,\n", + " 0.9879, 0.9882, 0.9876, 0.9833, 0.9891, 0.9900, 0.9879, 0.9871, 0.9900,\n", + " 0.9858, 0.9914, 0.9953, 0.9967, 0.9902, 0.9719, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.2821, 0.3046, 0.2887, 0.2459, 0.1840, 0.1082])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 75370 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0013, grad_fn=) , base rewards= tensor([1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352,\n", + " 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352, 1.4352,\n", + " 1.4352, 1.1611, 0.9233, 0.7110, 0.5169, 0.3359, 0.1645]) return= 73251.7417815017\n", + "probs of actions: tensor([9.9940e-01, 9.9947e-01, 9.9895e-01, 9.9849e-01, 9.9850e-01, 9.9845e-01,\n", + " 9.9896e-01, 9.9875e-01, 9.9878e-01, 9.9872e-01, 9.9879e-01, 9.9881e-01,\n", + " 9.9813e-01, 9.9887e-01, 9.9903e-01, 9.9874e-01, 9.9859e-01, 6.3129e-04,\n", + " 9.9900e-01, 9.9951e-01, 9.9974e-01, 9.9997e-01, 9.9944e-01, 9.9743e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2680,\n", + " 0.2516, 0.2533, 0.2546, 0.2555, 0.2562, 0.2568, 0.2797])\n", + "finalReturns: tensor([0.3725, 0.3950, 0.3795, 0.3372, 0.2758, 0.2005, 0.1152])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0020, grad_fn=) , base rewards= tensor([1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212,\n", + " 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212, 1.6212,\n", + " 1.3388, 1.0953, 0.8789, 0.6819, 0.4988, 0.3258, 0.1602]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9990, 0.9985, 0.9985, 0.9984, 0.9990, 0.9987, 0.9988,\n", + " 0.9987, 0.9988, 0.9988, 0.9981, 0.9989, 0.9990, 0.9987, 0.9986, 0.9990,\n", + " 0.9990, 0.9995, 0.9997, 1.0000, 0.9994, 0.9974, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.4738, 0.4963, 0.4804, 0.4375, 0.3755, 0.2997, 0.2140, 0.1209])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 16 ep 368 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0027, grad_fn=) , base rewards= tensor([1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790,\n", + " 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.7790, 1.4961,\n", + " 1.2522, 1.0356, 0.8384, 0.6552, 0.4821, 0.3164, 0.1562]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9990, 0.9985, 0.9985, 0.9985, 0.9990, 0.9988, 0.9988,\n", + " 0.9987, 0.9988, 0.9988, 0.9982, 0.9989, 0.9991, 0.9988, 0.9990, 0.9993,\n", + " 0.9990, 0.9995, 0.9998, 1.0000, 0.9995, 0.9975, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.5764, 0.5989, 0.5829, 0.5401, 0.4780, 0.4022, 0.3164, 0.2234, 0.1249])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 147 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0035, grad_fn=) , base rewards= tensor([1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344,\n", + " 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.9344, 1.6509, 1.4065,\n", + " 1.1895, 0.9921, 0.8087, 0.6355, 0.4697, 0.3095, 0.1532]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9990, 0.9985, 0.9986, 0.9985, 0.9990, 0.9988, 0.9988,\n", + " 0.9988, 0.9988, 0.9989, 0.9982, 0.9989, 0.9991, 0.9990, 0.9991, 0.9994,\n", + " 0.9990, 0.9995, 0.9998, 1.0000, 0.9995, 0.9976, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.6820, 0.7045, 0.6885, 0.6456, 0.5835, 0.5077, 0.4219, 0.3288, 0.2303,\n", + " 0.1279])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0046, grad_fn=) , base rewards= tensor([2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 2.0884,\n", + " 2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 2.0884, 1.8040, 1.5590, 1.3416,\n", + " 1.1439, 0.9602, 0.7869, 0.6210, 0.4606, 0.3043, 0.1510]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9990, 0.9985, 0.9986, 0.9985, 0.9990, 0.9988, 0.9988,\n", + " 0.9988, 0.9988, 0.9989, 0.9982, 0.9989, 0.9991, 0.9990, 0.9991, 0.9994,\n", + " 0.9990, 0.9995, 0.9998, 1.0000, 0.9995, 0.9976, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.7900, 0.8125, 0.7964, 0.7534, 0.6913, 0.6154, 0.5295, 0.4364, 0.3379,\n", + " 0.2354, 0.1301])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 58 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0058, grad_fn=) , base rewards= tensor([2.2417, 2.2417, 2.2417, 2.2417, 2.2417, 2.2417, 2.2417, 2.2417, 2.2417,\n", + " 2.2417, 2.2417, 2.2417, 2.2417, 2.2417, 1.9561, 1.7103, 1.4924, 1.2942,\n", + " 1.1103, 0.9367, 0.7707, 0.6102, 0.4538, 0.3005, 0.1494]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9994, 0.9995, 0.9990, 0.9985, 0.9985, 0.9985, 0.9990, 0.9988, 0.9988,\n", + " 0.9987, 0.9988, 0.9988, 0.9982, 0.9990, 0.9991, 0.9990, 0.9991, 0.9994,\n", + " 0.9990, 0.9995, 0.9998, 1.0000, 0.9994, 0.9975, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([0.8997, 0.9222, 0.9061, 0.8630, 0.8008, 0.7248, 0.6389, 0.5457, 0.4472,\n", + " 0.3447, 0.2393, 0.1317])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 8390 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([2.3953, 2.3953, 2.3953, 2.3953, 2.3953, 2.3953, 2.3953, 2.3953, 2.3953,\n", + " 2.3953, 2.3953, 2.3953, 2.3953, 2.1081, 1.8612, 1.6425, 1.4438, 1.2595,\n", + " 1.0856, 0.9193, 0.7587, 0.6022, 0.4488, 0.2976, 0.1482]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9990,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.0108, 1.0333, 1.0171, 0.9739, 0.9116, 0.8355, 0.7495, 0.6563, 0.5577,\n", + " 0.4552, 0.3497, 0.2421, 0.1329])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0062, grad_fn=) , base rewards= tensor([2.5497, 2.5497, 2.5497, 2.5497, 2.5497, 2.5497, 2.5497, 2.5497, 2.5497,\n", + " 2.5497, 2.5497, 2.5497, 2.2605, 2.0121, 1.7924, 1.5929, 1.4081, 1.2338,\n", + " 1.0673, 0.9064, 0.7498, 0.5962, 0.4450, 0.2955, 0.1473]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9990,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.1231, 1.1456, 1.1293, 1.0859, 1.0235, 0.9473, 0.8612, 0.7678, 0.6692,\n", + " 0.5666, 0.4611, 0.3535, 0.2443, 0.1338])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([2.7060, 2.7060, 2.7060, 2.7060, 2.7060, 2.7060, 2.7060, 2.7060, 2.7060,\n", + " 2.7060, 2.7060, 2.4139, 2.1636, 1.9425, 1.7421, 1.5565, 1.3817, 1.2148,\n", + " 1.0537, 0.8968, 0.7431, 0.5918, 0.4422, 0.2939, 0.1466]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9990,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.2364, 1.2589, 1.2424, 1.1989, 1.1362, 1.0599, 0.9736, 0.8802, 0.7815,\n", + " 0.6788, 0.5733, 0.4656, 0.3563, 0.2459, 0.1345])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 3 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0095, grad_fn=) , base rewards= tensor([2.8650, 2.8650, 2.8650, 2.8650, 2.8650, 2.8650, 2.8650, 2.8650, 2.8650,\n", + " 2.8650, 2.5692, 2.3163, 2.0933, 1.8916, 1.7051, 1.5296, 1.3622, 1.2007,\n", + " 1.0436, 0.8897, 0.7382, 0.5884, 0.4401, 0.2927, 0.1461]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9991,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.3506, 1.3731, 1.3565, 1.3127, 1.2498, 1.1732, 1.0868, 0.9932, 0.8943,\n", + " 0.7916, 0.6860, 0.5782, 0.4689, 0.3584, 0.2471, 0.1350])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 0 adversary: AdversaryModes.constant_95\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0113, grad_fn=) , base rewards= tensor([3.0282, 3.0282, 3.0282, 3.0282, 3.0282, 3.0282, 3.0282, 3.0282, 3.0282,\n", + " 2.7273, 2.4709, 2.2454, 2.0419, 1.8542, 1.6778, 1.5097, 1.3477, 1.1902,\n", + " 1.0360, 0.8843, 0.7344, 0.5860, 0.4385, 0.2918, 0.1457]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9991,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.4659, 1.4884, 1.4715, 1.4274, 1.3641, 1.2872, 1.2005, 1.1067, 1.0077,\n", + " 0.9048, 0.7991, 0.6913, 0.5820, 0.4714, 0.3600, 0.2480, 0.1354])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0132, grad_fn=) , base rewards= tensor([3.1970, 3.1970, 3.1970, 3.1970, 3.1970, 3.1970, 3.1970, 3.1970, 2.8893,\n", + " 2.6282, 2.3995, 2.1936, 2.0042, 1.8265, 1.6575, 1.4949, 1.3369, 1.1823,\n", + " 1.0304, 0.8803, 0.7317, 0.5841, 0.4373, 0.2911, 0.1454]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9991,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.5822, 1.6047, 1.5874, 1.5429, 1.4792, 1.4019, 1.3149, 1.2208, 1.1215,\n", + " 1.0185, 0.9127, 0.8048, 0.6953, 0.5847, 0.4733, 0.3612, 0.2486, 0.1357])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0150, grad_fn=) , base rewards= tensor([3.3738, 3.3738, 3.3738, 3.3738, 3.3738, 3.3738, 3.3738, 3.0569, 2.7895,\n", + " 2.5563, 2.3473, 2.1555, 1.9762, 1.8060, 1.6425, 1.4838, 1.3288, 1.1765,\n", + " 1.0261, 0.8773, 0.7296, 0.5827, 0.4364, 0.2906, 0.1452]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9992, 0.9988, 0.9989, 0.9988, 0.9992, 0.9990, 0.9991,\n", + " 0.9990, 0.9991, 0.9991, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9999,\n", + " 0.9993, 0.9997, 0.9999, 1.0000, 0.9996, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.6998, 1.7223, 1.7046, 1.6594, 1.5951, 1.5173, 1.4298, 1.3353, 1.2358,\n", + " 1.1326, 1.0266, 0.9185, 0.8090, 0.6983, 0.5868, 0.4747, 0.3621, 0.2491,\n", + " 0.1359])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 18525 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0105, grad_fn=) , base rewards= tensor([3.5615, 3.5615, 3.5615, 3.5615, 3.5615, 3.5615, 3.2322, 2.9561, 2.7169,\n", + " 2.5036, 2.3089, 2.1274, 1.9555, 1.7908, 1.6313, 1.4756, 1.3228, 1.1721,\n", + " 1.0230, 0.8751, 0.7280, 0.5816, 0.4358, 0.2903, 0.1450]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9995, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.8189, 1.8414, 1.8231, 1.7771, 1.7120, 1.6335, 1.5454, 1.4505, 1.3506,\n", + " 1.2470, 1.1408, 1.0326, 0.9229, 0.8122, 0.7006, 0.5884, 0.4757, 0.3627,\n", + " 0.2495, 0.1361])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 15 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0127, grad_fn=) , base rewards= tensor([3.7642, 3.7642, 3.7642, 3.7642, 3.7642, 3.4179, 3.1301, 2.8828, 2.6638,\n", + " 2.4649, 2.2805, 2.1065, 1.9402, 1.7795, 1.6229, 1.4694, 1.3183, 1.1688,\n", + " 1.0206, 0.8734, 0.7269, 0.5809, 0.4353, 0.2900, 0.1449]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9995, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([1.9401, 1.9626, 1.9435, 1.8964, 1.8302, 1.7507, 1.6619, 1.5663, 1.4659,\n", + " 1.3619, 1.2554, 1.1470, 1.0371, 0.9262, 0.8145, 0.7022, 0.5895, 0.4765,\n", + " 0.3632, 0.2498, 0.1362])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 7 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0151, grad_fn=) , base rewards= tensor([3.9877, 3.9877, 3.9877, 3.9877, 3.6180, 3.3143, 3.0560, 2.8292, 2.6248,\n", + " 2.4363, 2.2594, 2.0910, 1.9287, 1.7710, 1.6167, 1.4648, 1.3149, 1.1664,\n", + " 1.0188, 0.8721, 0.7260, 0.5803, 0.4349, 0.2898, 0.1448]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9995, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([2.0639, 2.0864, 2.0661, 2.0176, 1.9500, 1.8693, 1.7793, 1.6829, 1.5818,\n", + " 1.4773, 1.3704, 1.2617, 1.1516, 1.0405, 0.9287, 0.8163, 0.7035, 0.5904,\n", + " 0.4771, 0.3636, 0.2500, 0.1363])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0170, grad_fn=) , base rewards= tensor([4.2401, 4.2401, 4.2401, 3.8380, 3.5125, 3.2391, 3.0017, 2.7898, 2.5959,\n", + " 2.4151, 2.2438, 2.0794, 1.9201, 1.7646, 1.6120, 1.4614, 1.3124, 1.1645,\n", + " 1.0175, 0.8712, 0.7253, 0.5798, 0.4346, 0.2896, 0.1447]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9995, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([2.1910, 2.2135, 2.1918, 2.1414, 2.0719, 1.9895, 1.8981, 1.8006, 1.6986,\n", + " 1.5934, 1.4859, 1.3767, 1.2663, 1.1550, 1.0430, 0.9305, 0.8176, 0.7044,\n", + " 0.5911, 0.4775, 0.3639, 0.2502, 0.1364])\n", + "----------------------------------------\n", + "iter 2 stage 1 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0182, grad_fn=) , base rewards= tensor([4.5331, 4.5331, 4.0859, 3.7300, 3.4358, 3.1839, 2.9618, 2.7606, 2.5745,\n", + " 2.3993, 2.2321, 2.0708, 1.9137, 1.7599, 1.6085, 1.4588, 1.3105, 1.1631,\n", + " 1.0165, 0.8705, 0.7248, 0.5795, 0.4344, 0.2895, 0.1447]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9995, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([2.3227, 2.3452, 2.3216, 2.2686, 2.1965, 2.1118, 2.0186, 1.9195, 1.8163,\n", + " 1.7102, 1.6020, 1.4923, 1.3815, 1.2698, 1.1576, 1.0449, 0.9319, 0.8186,\n", + " 0.7052, 0.5916, 0.4779, 0.3641, 0.2503, 0.1364])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 0 adversary: AdversaryModes.constant_95\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0196, grad_fn=) , base rewards= tensor([4.8841, 4.3729, 3.9744, 3.6513, 3.3795, 3.1433, 2.9322, 2.7389, 2.5586,\n", + " 2.3875, 2.2234, 2.0643, 1.9089, 1.7564, 1.6059, 1.4569, 1.3091, 1.1621,\n", + " 1.0158, 0.8699, 0.7245, 0.5793, 0.4343, 0.2894, 0.1447]) return= 73445.38232037451\n", + "probs of actions: tensor([0.9996, 0.9996, 0.9993, 0.9990, 0.9990, 0.9990, 0.9993, 0.9997, 0.9994,\n", + " 0.9992, 1.0000, 0.9999, 0.9993, 0.9994, 0.9996, 0.9996, 0.9997, 1.0000,\n", + " 0.9995, 1.0000, 1.0000, 1.0000, 0.9997, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4247, 0.3795, 0.3472, 0.3239, 0.3069, 0.2944, 0.2852, 0.2784,\n", + " 0.2733, 0.2696, 0.2667, 0.2646, 0.2631, 0.2619, 0.2610, 0.2604, 0.2599,\n", + " 0.2595, 0.2592, 0.2590, 0.2589, 0.2587, 0.2587, 0.2811])\n", + "finalReturns: tensor([2.4604, 2.4829, 2.4566, 2.4002, 2.3248, 2.2371, 2.1414, 2.0403, 1.9355,\n", + " 1.8281, 1.7189, 1.6085, 1.4971, 1.3850, 1.2725, 1.1595, 1.0463, 0.9329,\n", + " 0.8194, 0.7057, 0.5919, 0.4781, 0.3643, 0.2504, 0.1364])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682682010 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[822902, 'tensor([0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])', 73445.38232037451, 85129.48297577976, 0.01956232078373432, 1e-05, 1, 0, 'tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\\n 15, 15, 15, 15, 15, 15, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682682010', 25, 50, 161287.58344151574, 184572.3091501231, 73445.38232037451, 135544.55463053397, 132647.75466666667, 112524.66365021843, 112524.66365021843, 117051.59338141435, 117051.59338141435, 85375.85726043607, 112524.66365021843, 117051.59338141435]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([ 1, 1, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 1, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204,\n", + " 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204,\n", + " 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204, 0.5204]) return= 130427.71758286069\n", + "probs of actions: tensor([1.2898e-01, 1.4863e-01, 7.8200e-01, 5.0099e-04, 8.0009e-01, 8.2463e-01,\n", + " 7.8552e-01, 7.7865e-01, 8.1916e-01, 7.8481e-01, 7.8624e-01, 7.9122e-01,\n", + " 8.0141e-01, 1.2257e-01, 8.0664e-01, 8.0212e-01, 8.3226e-01, 8.0869e-01,\n", + " 8.1746e-01, 8.0829e-01, 8.0075e-01, 8.0096e-01, 1.2746e-01, 8.1773e-01,\n", + " 9.4606e-01], grad_fn=)\n", + "rewards: tensor([0.5111, 0.5273, 0.5234, 0.4424, 0.6274, 0.4963, 0.5276, 0.5197, 0.5217,\n", + " 0.5212, 0.5213, 0.5213, 0.5213, 0.5212, 0.5249, 0.5204, 0.5215, 0.5212,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5212, 0.5249, 0.5204])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([16, 0, 1, 16, 0, 16, 0, 16, 0, 0, 4, 18, 0, 0, 16, 7, 13, 18,\n", + " 16, 16, 16, 0, 16, 16, 0])\n", + "loss= tensor(0.0165, grad_fn=) , base rewards= tensor([1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899,\n", + " 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899,\n", + " 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 1.0899, 0.5062]) return= 133455.20582218055\n", + "probs of actions: tensor([0.3193, 0.3793, 0.0503, 0.2874, 0.5107, 0.3032, 0.3821, 0.2562, 0.4683,\n", + " 0.3529, 0.0051, 0.1597, 0.2929, 0.4627, 0.3191, 0.0089, 0.0342, 0.1184,\n", + " 0.2100, 0.3366, 0.3129, 0.4630, 0.3278, 0.6132, 0.9927],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5833, 0.5062, 0.5031, 0.5787, 0.4818, 0.5843, 0.4805, 0.5847,\n", + " 0.5060, 0.5235, 0.5024, 0.5847, 0.5060, 0.4995, 0.5747, 0.5155, 0.5340,\n", + " 0.5510, 0.5409, 0.5434, 0.5684, 0.4842, 0.5581, 0.5648])\n", + "finalReturns: tensor([0.0329, 0.0585])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 16, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 16,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0506, grad_fn=) , base rewards= tensor([1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443,\n", + " 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 1.5443,\n", + " 1.5443, 1.5443, 1.5443, 1.5443, 1.5443, 0.9698, 0.4614]) return= 135378.46941865046\n", + "probs of actions: tensor([0.7424, 0.7524, 0.7040, 0.7659, 0.7584, 0.2114, 0.7666, 0.7316, 0.7425,\n", + " 0.7602, 0.7405, 0.7840, 0.7915, 0.7560, 0.7886, 0.7388, 0.7687, 0.1881,\n", + " 0.7565, 0.7638, 0.7718, 0.7267, 0.8800, 0.7854, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5490, 0.5346, 0.5441, 0.5417,\n", + " 0.5423, 0.5421, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5490,\n", + " 0.5346, 0.5441, 0.5417, 0.5423, 0.5421, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.1146, 0.1470, 0.1132])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0087, grad_fn=) , base rewards= tensor([1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719,\n", + " 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719, 1.9719,\n", + " 1.9719, 1.9719, 1.9719, 1.9719, 1.3974, 0.8890, 0.4276]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9761, 0.9773, 0.9695, 0.9786, 0.9814, 0.9793, 0.9797, 0.9766, 0.9777,\n", + " 0.9793, 0.9776, 0.9815, 0.9828, 0.9794, 0.9828, 0.9772, 0.9826, 0.9781,\n", + " 0.9808, 0.9789, 0.9796, 0.9874, 0.9920, 0.9846, 0.9985],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.2291, 0.2615, 0.2277, 0.1469])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751,\n", + " 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751, 2.3751,\n", + " 2.3751, 2.3751, 2.3751, 1.8005, 1.2922, 0.8308, 0.4032]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9824, 0.9830, 0.9781, 0.9842, 0.9869, 0.9853, 0.9850, 0.9833, 0.9834,\n", + " 0.9845, 0.9833, 0.9865, 0.9871, 0.9851, 0.9869, 0.9831, 0.9873, 0.9838,\n", + " 0.9868, 0.9844, 0.9890, 0.9896, 0.9933, 0.9911, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.3681, 0.4005, 0.3667, 0.2859, 0.1714])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604,\n", + " 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604, 2.7604,\n", + " 2.7604, 2.7604, 2.1858, 1.6775, 1.2161, 0.7885, 0.3853]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9953, 0.9953, 0.9940, 0.9958, 0.9968, 0.9965, 0.9960, 0.9958, 0.9957,\n", + " 0.9960, 0.9956, 0.9964, 0.9968, 0.9963, 0.9966, 0.9957, 0.9969, 0.9957,\n", + " 0.9966, 0.9966, 0.9979, 0.9984, 0.9988, 0.9983, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.5250, 0.5574, 0.5236, 0.4428, 0.3283, 0.1893])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 27994 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325,\n", + " 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325, 3.1325,\n", + " 3.1325, 2.5580, 2.0496, 1.5882, 1.1606, 0.7574, 0.3721]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9977, 0.9977, 0.9971, 0.9980, 0.9985, 0.9984, 0.9980, 0.9980, 0.9980,\n", + " 0.9981, 0.9979, 0.9982, 0.9985, 0.9983, 0.9984, 0.9980, 0.9986, 0.9980,\n", + " 0.9990, 0.9989, 0.9989, 0.9993, 0.9996, 0.9995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.6950, 0.7274, 0.6936, 0.6128, 0.4983, 0.3593, 0.2024])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 19492 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0024, grad_fn=) , base rewards= tensor([3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950,\n", + " 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950, 3.4950,\n", + " 2.9204, 2.4120, 1.9507, 1.5230, 1.1199, 0.7346, 0.3624]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9987, 0.9987, 0.9983, 0.9988, 0.9992, 0.9991, 0.9989, 0.9988, 0.9989,\n", + " 0.9989, 0.9988, 0.9990, 0.9992, 0.9990, 0.9991, 0.9988, 0.9992, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9996, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([0.8747, 0.9071, 0.8733, 0.7926, 0.6780, 0.5390, 0.3821, 0.2121])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502,\n", + " 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.8502, 3.2757,\n", + " 2.7673, 2.3059, 1.8783, 1.4751, 1.0898, 0.7177, 0.3552]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9987, 0.9987, 0.9983, 0.9988, 0.9992, 0.9991, 0.9989, 0.9988, 0.9989,\n", + " 0.9989, 0.9988, 0.9990, 0.9992, 0.9990, 0.9991, 0.9989, 0.9992, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9996, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([1.0617, 1.0941, 1.0603, 0.9795, 0.8649, 0.7259, 0.5691, 0.3991, 0.2193])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 15 ep 79 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0051, grad_fn=) , base rewards= tensor([4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001,\n", + " 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 4.2001, 3.6255, 3.1172,\n", + " 2.6558, 2.2282, 1.8250, 1.4397, 1.0676, 0.7051, 0.3499]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9984, 0.9989, 0.9992, 0.9991, 0.9989, 0.9989, 0.9989,\n", + " 0.9990, 0.9988, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([1.2539, 1.2863, 1.2525, 1.1718, 1.0572, 0.9182, 0.7613, 0.5913, 0.4116,\n", + " 0.2247])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0069, grad_fn=) , base rewards= tensor([4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 4.5460,\n", + " 4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 4.5460, 3.9715, 3.4631, 3.0017,\n", + " 2.5741, 2.1709, 1.7856, 1.4135, 1.0510, 0.6958, 0.3459]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9984, 0.9989, 0.9992, 0.9992, 0.9989, 0.9989, 0.9989,\n", + " 0.9990, 0.9988, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([1.4502, 1.4826, 1.4488, 1.3680, 1.2535, 1.1145, 0.9576, 0.7876, 0.6079,\n", + " 0.4209, 0.2287])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0090, grad_fn=) , base rewards= tensor([4.8889, 4.8889, 4.8889, 4.8889, 4.8889, 4.8889, 4.8889, 4.8889, 4.8889,\n", + " 4.8889, 4.8889, 4.8889, 4.8889, 4.8889, 4.3144, 3.8060, 3.3446, 2.9170,\n", + " 2.5138, 2.1285, 1.7564, 1.3940, 1.0387, 0.6888, 0.3429]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9984, 0.9989, 0.9992, 0.9992, 0.9989, 0.9989, 0.9989,\n", + " 0.9990, 0.9988, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([1.6494, 1.6818, 1.6480, 1.5672, 1.4527, 1.3137, 1.1568, 0.9868, 0.8071,\n", + " 0.6202, 0.4279, 0.2316])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0112, grad_fn=) , base rewards= tensor([5.2297, 5.2297, 5.2297, 5.2297, 5.2297, 5.2297, 5.2297, 5.2297, 5.2297,\n", + " 5.2297, 5.2297, 5.2297, 5.2297, 4.6551, 4.1467, 3.6853, 3.2577, 2.8545,\n", + " 2.4693, 2.0971, 1.7347, 1.3794, 1.0295, 0.6836, 0.3407]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9984, 0.9989, 0.9992, 0.9992, 0.9989, 0.9989, 0.9989,\n", + " 0.9990, 0.9988, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([1.8509, 1.8833, 1.8495, 1.7687, 1.6542, 1.5152, 1.3583, 1.1883, 1.0085,\n", + " 0.8216, 0.6293, 0.4331, 0.2339])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0138, grad_fn=) , base rewards= tensor([5.5687, 5.5687, 5.5687, 5.5687, 5.5687, 5.5687, 5.5687, 5.5687, 5.5687,\n", + " 5.5687, 5.5687, 5.5687, 4.9941, 4.4858, 4.0244, 3.5968, 3.1936, 2.8083,\n", + " 2.4362, 2.0737, 1.7185, 1.3686, 1.0227, 0.6798, 0.3390]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9984, 0.9989, 0.9992, 0.9992, 0.9989, 0.9989, 0.9989,\n", + " 0.9990, 0.9988, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([2.0540, 2.0864, 2.0526, 1.9718, 1.8573, 1.7183, 1.5614, 1.3914, 1.2117,\n", + " 1.0247, 0.8325, 0.6362, 0.4370, 0.2355])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 52 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0151, grad_fn=) , base rewards= tensor([5.9065, 5.9065, 5.9065, 5.9065, 5.9065, 5.9065, 5.9065, 5.9065, 5.9065,\n", + " 5.9065, 5.9065, 5.3319, 4.8236, 4.3622, 3.9346, 3.5314, 3.1461, 2.7740,\n", + " 2.4115, 2.0563, 1.7064, 1.3605, 1.0176, 0.6768, 0.3378]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9988, 0.9985, 0.9989, 0.9992, 0.9992, 0.9990, 0.9990, 0.9990,\n", + " 0.9990, 0.9990, 0.9992, 0.9993, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([2.2584, 2.2908, 2.2570, 2.1762, 2.0617, 1.9227, 1.7658, 1.5958, 1.4160,\n", + " 1.2291, 1.0368, 0.8406, 0.6413, 0.4399, 0.2368])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0182, grad_fn=) , base rewards= tensor([6.2434, 6.2434, 6.2434, 6.2434, 6.2434, 6.2434, 6.2434, 6.2434, 6.2434,\n", + " 6.2434, 5.6688, 5.1604, 4.6991, 4.2714, 3.8683, 3.4830, 3.1108, 2.7484,\n", + " 2.3932, 2.0433, 1.6974, 1.3544, 1.0137, 0.6747, 0.3369]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9988, 0.9985, 0.9989, 0.9992, 0.9992, 0.9990, 0.9990, 0.9990,\n", + " 0.9990, 0.9990, 0.9992, 0.9993, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([2.4637, 2.4961, 2.4623, 2.3815, 2.2669, 2.1279, 1.9711, 1.8010, 1.6213,\n", + " 1.4344, 1.2421, 1.0459, 0.8466, 0.6452, 0.4421, 0.2377])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 6 adversary: AdversaryModes.imitation_132\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0212, grad_fn=) , base rewards= tensor([6.5795, 6.5795, 6.5795, 6.5795, 6.5795, 6.5795, 6.5795, 6.5795, 6.5795,\n", + " 6.0050, 5.4966, 5.0352, 4.6076, 4.2044, 3.8191, 3.4470, 3.0846, 2.7293,\n", + " 2.3794, 2.0335, 1.6906, 1.3499, 1.0108, 0.6730, 0.3362]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9988, 0.9988, 0.9985, 0.9990, 0.9993, 0.9992, 0.9990, 0.9990, 0.9990,\n", + " 0.9991, 0.9990, 0.9992, 0.9993, 0.9992, 0.9993, 0.9991, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([2.6696, 2.7020, 2.6682, 2.5875, 2.4729, 2.3339, 2.1771, 2.0070, 1.8273,\n", + " 1.6404, 1.4481, 1.2519, 1.0526, 0.8512, 0.6480, 0.4437, 0.2384])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 11 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0241, grad_fn=) , base rewards= tensor([6.9152, 6.9152, 6.9152, 6.9152, 6.9152, 6.9152, 6.9152, 6.9152, 6.3406,\n", + " 5.8323, 5.3709, 4.9432, 4.5401, 4.1548, 3.7826, 3.4202, 3.0650, 2.7151,\n", + " 2.3692, 2.0262, 1.6855, 1.3465, 1.0087, 0.6718, 0.3356]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9989, 0.9988, 0.9986, 0.9990, 0.9993, 0.9992, 0.9990, 0.9990, 0.9990,\n", + " 0.9991, 0.9991, 0.9992, 0.9993, 0.9992, 0.9993, 0.9992, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([2.8762, 2.9086, 2.8748, 2.7940, 2.6794, 2.5405, 2.3836, 2.2136, 2.0338,\n", + " 1.8469, 1.6546, 1.4584, 1.2591, 1.0577, 0.8546, 0.6502, 0.4449, 0.2389])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0279, grad_fn=) , base rewards= tensor([7.2504, 7.2504, 7.2504, 7.2504, 7.2504, 7.2504, 7.2504, 6.6759, 6.1675,\n", + " 5.7061, 5.2785, 4.8753, 4.4901, 4.1179, 3.7555, 3.4002, 3.0503, 2.7044,\n", + " 2.3615, 2.0208, 1.6818, 1.3440, 1.0071, 0.6709, 0.3353]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9989, 0.9988, 0.9986, 0.9990, 0.9993, 0.9992, 0.9990, 0.9990, 0.9990,\n", + " 0.9991, 0.9991, 0.9992, 0.9993, 0.9992, 0.9993, 0.9992, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([3.0831, 3.1155, 3.0817, 3.0009, 2.8864, 2.7474, 2.5905, 2.4205, 2.2407,\n", + " 2.0538, 1.8615, 1.6653, 1.4660, 1.2646, 1.0615, 0.8571, 0.6518, 0.4458,\n", + " 0.2393])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0311, grad_fn=) , base rewards= tensor([7.5855, 7.5855, 7.5855, 7.5855, 7.5855, 7.5855, 7.0108, 6.5025, 6.0411,\n", + " 5.6135, 5.2103, 4.8250, 4.4529, 4.0904, 3.7352, 3.3853, 3.0394, 2.6965,\n", + " 2.3558, 2.0167, 1.6789, 1.3420, 1.0059, 0.6702, 0.3350]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9989, 0.9988, 0.9986, 0.9990, 0.9993, 0.9992, 0.9990, 0.9990, 0.9991,\n", + " 0.9991, 0.9991, 0.9992, 0.9993, 0.9992, 0.9993, 0.9992, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([3.2903, 3.3227, 3.2889, 3.2081, 3.0936, 2.9546, 2.7977, 2.6277, 2.4479,\n", + " 2.2610, 2.0687, 1.8725, 1.6732, 1.4718, 1.2687, 1.0643, 0.8590, 0.6530,\n", + " 0.4465, 0.2396])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0343, grad_fn=) , base rewards= tensor([7.9200, 7.9200, 7.9200, 7.9200, 7.9200, 7.3456, 6.8372, 6.3759, 5.9482,\n", + " 5.5450, 5.1598, 4.7876, 4.4252, 4.0699, 3.7200, 3.3741, 3.0312, 2.6905,\n", + " 2.3515, 2.0137, 1.6768, 1.3406, 1.0050, 0.6697, 0.3347]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9989, 0.9988, 0.9986, 0.9990, 0.9993, 0.9992, 0.9990, 0.9990, 0.9991,\n", + " 0.9991, 0.9991, 0.9992, 0.9993, 0.9992, 0.9993, 0.9992, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([3.4977, 3.5301, 3.4963, 3.4155, 3.3010, 3.1620, 3.0051, 2.8351, 2.6554,\n", + " 2.4684, 2.2762, 2.0799, 1.8807, 1.6792, 1.4761, 1.2717, 1.0664, 0.8604,\n", + " 0.6539, 0.4470, 0.2398])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 5 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0380, grad_fn=) , base rewards= tensor([8.2556, 8.2556, 8.2556, 8.2556, 7.6800, 7.1719, 6.7104, 6.2828, 5.8796,\n", + " 5.4943, 5.1222, 4.7598, 4.4045, 4.0546, 3.7087, 3.3658, 3.0251, 2.6860,\n", + " 2.3482, 2.0114, 1.6752, 1.3395, 1.0043, 0.6693, 0.3346]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9989, 0.9989, 0.9986, 0.9990, 0.9993, 0.9993, 0.9990, 0.9990, 0.9991,\n", + " 0.9991, 0.9991, 0.9992, 0.9994, 0.9993, 0.9993, 0.9992, 0.9994, 0.9991,\n", + " 0.9997, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([3.7053, 3.7377, 3.7039, 3.6231, 3.5086, 3.3696, 3.2127, 3.0427, 2.8629,\n", + " 2.6760, 2.4837, 2.2875, 2.0882, 1.8868, 1.6837, 1.4793, 1.2740, 1.0680,\n", + " 0.8615, 0.6546, 0.4474, 0.2400])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 223 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0335, grad_fn=) , base rewards= tensor([8.5859, 8.5859, 8.5859, 8.0154, 7.5061, 7.0449, 6.6172, 6.2141, 5.8288,\n", + " 5.4567, 5.0942, 4.7390, 4.3891, 4.0432, 3.7002, 3.3595, 3.0205, 2.6827,\n", + " 2.3458, 2.0097, 1.6740, 1.3387, 1.0038, 0.6690, 0.3345]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9993, 0.9995, 0.9995, 0.9992, 0.9992, 0.9993,\n", + " 0.9994, 0.9993, 0.9994, 0.9995, 0.9994, 0.9994, 0.9994, 0.9996, 0.9993,\n", + " 0.9998, 0.9996, 0.9997, 0.9997, 0.9999, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([3.9130, 3.9454, 3.9116, 3.8308, 3.7163, 3.5773, 3.4204, 3.2504, 3.0706,\n", + " 2.8837, 2.6914, 2.4952, 2.2960, 2.0945, 1.8914, 1.6870, 1.4817, 1.2757,\n", + " 1.0692, 0.8623, 0.6551, 0.4477, 0.2401])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0382, grad_fn=) , base rewards= tensor([8.9369, 8.9369, 8.3459, 7.8414, 7.3791, 6.9517, 6.5484, 6.1632, 5.7910,\n", + " 5.4286, 5.0733, 4.7234, 4.3775, 4.0346, 3.6939, 3.3549, 3.0171, 2.6802,\n", + " 2.3440, 2.0084, 1.6731, 1.3381, 1.0034, 0.6688, 0.3344]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9993, 0.9995, 0.9995, 0.9992, 0.9992, 0.9993,\n", + " 0.9994, 0.9993, 0.9994, 0.9995, 0.9994, 0.9994, 0.9994, 0.9996, 0.9993,\n", + " 0.9998, 0.9996, 0.9997, 0.9997, 0.9999, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([4.1206, 4.1530, 4.1195, 4.0386, 3.9241, 3.7851, 3.6282, 3.4582, 3.2784,\n", + " 3.0915, 2.8992, 2.7030, 2.5038, 2.3023, 2.0992, 1.8948, 1.6895, 1.4835,\n", + " 1.2770, 1.0701, 0.8629, 0.6555, 0.4479, 0.2402])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0431, grad_fn=) , base rewards= tensor([9.2070, 8.6958, 8.1720, 7.7142, 7.2857, 6.8828, 6.4974, 6.1253, 5.7629,\n", + " 5.4076, 5.0577, 4.7118, 4.3689, 4.0282, 3.6892, 3.3513, 3.0145, 2.6783,\n", + " 2.3427, 2.0074, 1.6724, 1.3377, 1.0031, 0.6687, 0.3343]) return= 135363.21866666665\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9993, 0.9995, 0.9995, 0.9992, 0.9992, 0.9993,\n", + " 0.9994, 0.9993, 0.9994, 0.9995, 0.9994, 0.9994, 0.9994, 0.9996, 0.9993,\n", + " 0.9998, 0.9996, 0.9997, 0.9997, 0.9999, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422,\n", + " 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5422, 0.5746])\n", + "finalReturns: tensor([4.3293, 4.3617, 4.3269, 4.2466, 4.1319, 3.9929, 3.8361, 3.6660, 3.4863,\n", + " 3.2994, 3.1071, 2.9109, 2.7116, 2.5102, 2.3071, 2.1027, 1.8974, 1.6914,\n", + " 1.4849, 1.2780, 1.0708, 0.8634, 0.6558, 0.4481, 0.2403])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682701103 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[767881, 'tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.])', 135363.21866666665, 84740.85066666668, 0.043078526854515076, 1e-05, 1, 0, 'tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\\n 18, 18, 18, 18, 18, 18, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682701103', 25, 50, 164632.33345850307, 193521.60851536895, 78111.91688437786, 135363.21866666665, 132442.06666666665, 102604.52812037412, 102604.52812037412, 120699.79187222247, 120677.7693195532, 90621.14382460734, 102604.52812037412, 120699.79187222247]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213]) return= 130240.65866666666\n", + "probs of actions: tensor([0.9077, 0.8732, 0.8904, 0.8995, 0.8972, 0.8745, 0.8788, 0.9012, 0.8913,\n", + " 0.8767, 0.8811, 0.8843, 0.8777, 0.8816, 0.8965, 0.8712, 0.8952, 0.9004,\n", + " 0.8862, 0.9074, 0.8904, 0.8827, 0.8910, 0.8883, 0.9826],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5207, 0.5214, 0.5212, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([ 0, 0, 13, 0, 13, 0, 13, 0, 20, 3, 18, 3, 0, 18, 0, 15, 20, 0,\n", + " 0, 11, 0, 0, 17, 8, 0])\n", + "loss= tensor(0.1189, grad_fn=) , base rewards= tensor([1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900,\n", + " 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900,\n", + " 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 1.0900, 0.5062]) return= 132730.16473578967\n", + "probs of actions: tensor([0.5746, 0.4005, 0.0869, 0.5135, 0.0746, 0.3050, 0.0707, 0.4547, 0.0140,\n", + " 0.0303, 0.0911, 0.0262, 0.3726, 0.1150, 0.3055, 0.0646, 0.0140, 0.4273,\n", + " 0.4826, 0.0104, 0.4164, 0.3292, 0.0586, 0.0051, 0.9925],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5038, 0.5694, 0.4927, 0.5723, 0.4920, 0.5725, 0.4688,\n", + " 0.5984, 0.4809, 0.5895, 0.5154, 0.4904, 0.5879, 0.4828, 0.5411, 0.5805,\n", + " 0.5070, 0.5128, 0.5608, 0.5116, 0.4948, 0.5774, 0.5351])\n", + "finalReturns: tensor([0.0225, 0.0289])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 17, 18, 17, 17, 18, 18, 18, 23, 18, 17, 18,\n", + " 18, 18, 10, 17, 18, 18, 0])\n", + "loss= tensor(0.1164, grad_fn=) , base rewards= tensor([1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474,\n", + " 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 1.5474,\n", + " 1.5474, 1.5474, 1.5474, 1.5474, 1.5474, 0.9691, 0.4616]) return= 135321.06489242485\n", + "probs of actions: tensor([0.6817, 0.6622, 0.7054, 0.6411, 0.6841, 0.6765, 0.6575, 0.1339, 0.6236,\n", + " 0.1263, 0.1174, 0.6488, 0.6663, 0.7073, 0.0190, 0.6308, 0.1307, 0.6938,\n", + " 0.6575, 0.6494, 0.0023, 0.1165, 0.6519, 0.6349, 0.9946],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5381, 0.5432, 0.5419, 0.5422, 0.5421, 0.5457, 0.5384,\n", + " 0.5466, 0.5416, 0.5394, 0.5429, 0.5420, 0.5217, 0.5613, 0.5409, 0.5396,\n", + " 0.5428, 0.5420, 0.5646, 0.5157, 0.5460, 0.5412, 0.5748])\n", + "finalReturns: tensor([0.1145, 0.1469, 0.1132])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([17, 23, 15, 18, 20, 23, 18, 20, 18, 20, 17, 20, 18, 18, 20, 19, 25, 18,\n", + " 23, 18, 20, 18, 20, 20, 0])\n", + "loss= tensor(0.6976, grad_fn=) , base rewards= tensor([1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726,\n", + " 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726, 1.9726,\n", + " 1.9726, 1.9726, 1.9726, 1.9726, 1.3892, 0.8829, 0.4210]) return= 135023.68474879788\n", + "probs of actions: tensor([0.0946, 0.0818, 0.0169, 0.4284, 0.2996, 0.0770, 0.3800, 0.2651, 0.3633,\n", + " 0.2819, 0.1024, 0.2574, 0.4822, 0.4497, 0.3131, 0.0237, 0.0440, 0.4993,\n", + " 0.0806, 0.4510, 0.2391, 0.3161, 0.4021, 0.4613, 0.9969],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.5342, 0.5680, 0.5269, 0.5384, 0.5283, 0.5596, 0.5302, 0.5509,\n", + " 0.5324, 0.5538, 0.5288, 0.5512, 0.5399, 0.5351, 0.5459, 0.5140, 0.5685,\n", + " 0.5152, 0.5629, 0.5294, 0.5511, 0.5323, 0.5427, 0.5801])\n", + "finalReturns: tensor([0.2336, 0.2660, 0.2400, 0.1591])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 23, 20, 23, 25, 18, 23, 18, 23, 18, 23, 23, 24, 17, 18, 23, 25,\n", + " 25, 23, 19, 25, 25, 20, 0])\n", + "loss= tensor(3.1660, grad_fn=) , base rewards= tensor([2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248,\n", + " 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248, 2.3248,\n", + " 2.3248, 2.3248, 2.3248, 1.7364, 1.2313, 0.7725, 0.3692]) return= 134249.1143811909\n", + "probs of actions: tensor([0.1810, 0.2000, 0.2224, 0.3108, 0.2469, 0.2092, 0.1259, 0.2311, 0.1225,\n", + " 0.2222, 0.2016, 0.2075, 0.2114, 0.0136, 0.0336, 0.1335, 0.2390, 0.2126,\n", + " 0.2172, 0.2367, 0.0198, 0.2455, 0.2390, 0.4338, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5376, 0.5497, 0.5255, 0.5302, 0.5644, 0.5162, 0.5627,\n", + " 0.5166, 0.5626, 0.5166, 0.5421, 0.5309, 0.5651, 0.5336, 0.5238, 0.5306,\n", + " 0.5342, 0.5429, 0.5522, 0.5124, 0.5388, 0.5547, 0.5772])\n", + "finalReturns: tensor([0.4105, 0.4466, 0.4394, 0.3593, 0.2079])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 18, 25, 25, 25, 25, 25, 23, 25, 25, 25, 25, 26, 25, 25, 20, 25, 25,\n", + " 25, 25, 25, 25, 25, 20, 0])\n", + "loss= tensor(1.5108, grad_fn=) , base rewards= tensor([2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317,\n", + " 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317, 2.6317,\n", + " 2.6317, 2.6317, 2.0354, 1.5321, 1.0930, 0.6993, 0.3379]) return= 133536.32186988593\n", + "probs of actions: tensor([0.7044, 0.0200, 0.7188, 0.7269, 0.7118, 0.7290, 0.7193, 0.1459, 0.7147,\n", + " 0.7104, 0.7352, 0.7272, 0.0040, 0.7251, 0.7320, 0.0698, 0.7153, 0.7446,\n", + " 0.7193, 0.7999, 0.8080, 0.7683, 0.7679, 0.1276, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5858, 0.5014, 0.5416, 0.5315, 0.5340, 0.5334, 0.5431, 0.5258,\n", + " 0.5354, 0.5330, 0.5336, 0.5284, 0.5374, 0.5325, 0.5562, 0.5143, 0.5383,\n", + " 0.5323, 0.5338, 0.5334, 0.5335, 0.5335, 0.5560, 0.5768])\n", + "finalReturns: tensor([0.6353, 0.6978, 0.6677, 0.5733, 0.4336, 0.2389])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 23, 25, 25, 23, 25, 25, 25, 25, 25, 25, 25, 25, 25, 23, 23, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.3647, grad_fn=) , base rewards= tensor([2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535,\n", + " 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535, 2.9535,\n", + " 2.9535, 2.3561, 1.8530, 1.4139, 1.0202, 0.6589, 0.3209]) return= 133464.3841915384\n", + "probs of actions: tensor([0.8935, 0.8888, 0.0682, 0.9030, 0.8959, 0.0677, 0.8989, 0.9129, 0.8946,\n", + " 0.8929, 0.9044, 0.9014, 0.9122, 0.9016, 0.9045, 0.0701, 0.0710, 0.9099,\n", + " 0.9199, 0.9389, 0.9494, 0.9240, 0.9188, 0.8524, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5376, 0.5272, 0.5351, 0.5427, 0.5259, 0.5354, 0.5330,\n", + " 0.5336, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5431, 0.5354, 0.5277,\n", + " 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([0.8445, 0.9070, 0.8770, 0.7825, 0.6428, 0.4706, 0.2751])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 17 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.1831, grad_fn=) , base rewards= tensor([3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608,\n", + " 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608, 3.2608,\n", + " 2.6648, 2.1614, 1.7223, 1.3286, 0.9673, 0.6294, 0.3084]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9582, 0.9553, 0.9595, 0.9618, 0.9593, 0.9611, 0.9598, 0.9668, 0.9578,\n", + " 0.9583, 0.9635, 0.9620, 0.9660, 0.9618, 0.9629, 0.9578, 0.9580, 0.9654,\n", + " 0.9735, 0.9787, 0.9825, 0.9718, 0.9683, 0.9487, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([1.0696, 1.1321, 1.1020, 1.0076, 0.8678, 0.6957, 0.5001, 0.2875])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 23, 23, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(4.6647, grad_fn=) , base rewards= tensor([3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711,\n", + " 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 3.5711, 2.9828,\n", + " 2.4776, 2.0323, 1.6354, 1.2714, 0.9317, 0.6094, 0.3000]) return= 133395.47270678813\n", + "probs of actions: tensor([0.9645, 0.9623, 0.9662, 0.9679, 0.9659, 0.9673, 0.9660, 0.9719, 0.9648,\n", + " 0.9654, 0.9701, 0.9689, 0.9721, 0.9677, 0.9688, 0.0327, 0.0306, 0.9745,\n", + " 0.9786, 0.9827, 0.9879, 0.9764, 0.9713, 0.9507, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5431, 0.5354, 0.5277,\n", + " 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([1.2901, 1.3430, 1.3204, 1.2308, 1.0946, 0.9250, 0.7313, 0.5201, 0.2960])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.2434, grad_fn=) , base rewards= tensor([3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525,\n", + " 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.8525, 3.2565, 2.7531,\n", + " 2.3140, 1.9203, 1.5590, 1.2210, 0.9001, 0.5917, 0.2924]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9686, 0.9667, 0.9713, 0.9722, 0.9703, 0.9719, 0.9702, 0.9756, 0.9696,\n", + " 0.9702, 0.9744, 0.9733, 0.9758, 0.9720, 0.9730, 0.9731, 0.9757, 0.9777,\n", + " 0.9782, 0.9864, 0.9914, 0.9763, 0.9761, 0.9581, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([1.5449, 1.6074, 1.5773, 1.4829, 1.3431, 1.1710, 0.9754, 0.7628, 0.5378,\n", + " 0.3036])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([23, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.1918, grad_fn=) , base rewards= tensor([4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 4.1398,\n", + " 4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 4.1398, 3.5438, 3.0405, 2.6014,\n", + " 2.2077, 1.8463, 1.5084, 1.1875, 0.8791, 0.5798, 0.2874]) return= 133359.57866666667\n", + "probs of actions: tensor([0.0204, 0.9779, 0.9806, 0.9816, 0.9804, 0.9811, 0.9801, 0.9839, 0.9800,\n", + " 0.9800, 0.9831, 0.9827, 0.9841, 0.9813, 0.9832, 0.9834, 0.9820, 0.9878,\n", + " 0.9881, 0.9937, 0.9951, 0.9868, 0.9850, 0.9698, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5479, 0.5299, 0.5344, 0.5333, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([1.7910, 1.8535, 1.8234, 1.7290, 1.5892, 1.4171, 1.2215, 1.0089, 0.7839,\n", + " 0.5497, 0.3086])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.1643, grad_fn=) , base rewards= tensor([4.4235, 4.4235, 4.4235, 4.4235, 4.4235, 4.4235, 4.4235, 4.4235, 4.4235,\n", + " 4.4235, 4.4235, 4.4235, 4.4235, 4.4235, 3.8275, 3.3241, 2.8850, 2.4913,\n", + " 2.1300, 1.7920, 1.4711, 1.1627, 0.8634, 0.5710, 0.2836]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9850, 0.9838, 0.9855, 0.9863, 0.9856, 0.9861, 0.9855, 0.9883, 0.9852,\n", + " 0.9854, 0.9877, 0.9874, 0.9883, 0.9897, 0.9887, 0.9869, 0.9845, 0.9928,\n", + " 0.9936, 0.9961, 0.9976, 0.9919, 0.9882, 0.9812, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([2.0409, 2.1034, 2.0733, 1.9789, 1.8391, 1.6669, 1.4714, 1.2588, 1.0338,\n", + " 0.7995, 0.5585, 0.3124])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 96178 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0253, grad_fn=) , base rewards= tensor([4.7043, 4.7043, 4.7043, 4.7043, 4.7043, 4.7043, 4.7043, 4.7043, 4.7043,\n", + " 4.7043, 4.7043, 4.7043, 4.7043, 4.1083, 3.6049, 3.1658, 2.7721, 2.4108,\n", + " 2.0728, 1.7519, 1.4435, 1.1442, 0.8518, 0.5644, 0.2808]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9974, 0.9971, 0.9973, 0.9975, 0.9975, 0.9975, 0.9974, 0.9980, 0.9973,\n", + " 0.9974, 0.9978, 0.9977, 0.9990, 0.9988, 0.9986, 0.9978, 0.9972, 0.9993,\n", + " 0.9994, 0.9997, 1.0000, 0.9991, 0.9988, 0.9974, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([2.2935, 2.3560, 2.3259, 2.2315, 2.0918, 1.9196, 1.7240, 1.5115, 1.2864,\n", + " 1.0522, 0.8111, 0.5650, 0.3152])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 85709 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0115, grad_fn=) , base rewards= tensor([4.9830, 4.9830, 4.9830, 4.9830, 4.9830, 4.9830, 4.9830, 4.9830, 4.9830,\n", + " 4.9830, 4.9830, 4.9830, 4.3870, 3.8836, 3.4445, 3.0508, 2.6895, 2.3516,\n", + " 2.0306, 1.7222, 1.4230, 1.1305, 0.8432, 0.5595, 0.2787]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9985, 0.9983, 0.9985, 0.9986, 0.9986, 0.9986, 0.9986, 0.9989, 0.9985,\n", + " 0.9985, 0.9988, 0.9990, 0.9996, 0.9997, 0.9994, 0.9992, 0.9990, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 0.9997, 0.9998, 0.9988, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([2.5483, 2.6108, 2.5807, 2.4863, 2.3465, 2.1744, 1.9788, 1.7662, 1.5412,\n", + " 1.3070, 1.0659, 0.8198, 0.5699, 0.3173])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 10 ep 132 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([5.2601, 5.2601, 5.2601, 5.2601, 5.2601, 5.2601, 5.2601, 5.2601, 5.2601,\n", + " 5.2601, 5.2601, 4.6642, 4.1608, 3.7217, 3.3280, 2.9667, 2.6287, 2.3078,\n", + " 1.9994, 1.7001, 1.4077, 1.1203, 0.8367, 0.5559, 0.2772]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9986, 0.9984, 0.9986, 0.9987, 0.9987, 0.9987, 0.9986, 0.9989, 0.9985,\n", + " 0.9986, 0.9990, 0.9990, 0.9996, 0.9997, 0.9995, 0.9992, 0.9990, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 0.9998, 0.9998, 0.9988, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([2.8046, 2.8671, 2.8370, 2.7426, 2.6028, 2.4307, 2.2351, 2.0226, 1.7975,\n", + " 1.5633, 1.3222, 1.0761, 0.8263, 0.5736, 0.3188])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 2917 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0123, grad_fn=) , base rewards= tensor([5.5361, 5.5361, 5.5361, 5.5361, 5.5361, 5.5361, 5.5361, 5.5361, 5.5361,\n", + " 5.5361, 4.9401, 4.4367, 3.9977, 3.6040, 3.2426, 2.9047, 2.5838, 2.2753,\n", + " 1.9761, 1.6837, 1.3963, 1.1127, 0.8319, 0.5531, 0.2760]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9990, 0.9990, 0.9990, 0.9990, 0.9990, 0.9992, 0.9989,\n", + " 0.9990, 0.9997, 0.9994, 0.9997, 0.9998, 0.9996, 0.9995, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9998, 0.9999, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([3.0621, 3.1246, 3.0945, 3.0001, 2.8603, 2.6882, 2.4926, 2.2801, 2.0550,\n", + " 1.8208, 1.5797, 1.3336, 1.0838, 0.8311, 0.5763, 0.3200])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 76 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0164, grad_fn=) , base rewards= tensor([5.8112, 5.8112, 5.8112, 5.8112, 5.8112, 5.8112, 5.8112, 5.8112, 5.8112,\n", + " 5.2152, 4.7119, 4.2728, 3.8791, 3.5177, 3.1798, 2.8589, 2.5504, 2.2512,\n", + " 1.9588, 1.6714, 1.3878, 1.1070, 0.8282, 0.5511, 0.2751]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9989, 0.9990, 0.9990, 0.9990, 0.9990, 0.9992, 0.9990,\n", + " 0.9990, 0.9997, 0.9994, 0.9997, 0.9998, 0.9996, 0.9995, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9998, 0.9999, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([3.3205, 3.3830, 3.3529, 3.2585, 3.1187, 2.9466, 2.7510, 2.5385, 2.3134,\n", + " 2.0792, 1.8381, 1.5920, 1.3421, 1.0895, 0.8347, 0.5784, 0.3209])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0199, grad_fn=) , base rewards= tensor([6.0857, 6.0857, 6.0857, 6.0857, 6.0857, 6.0857, 6.0857, 6.0857, 5.4897,\n", + " 4.9863, 4.5472, 4.1535, 3.7922, 3.4543, 3.1333, 2.8249, 2.5257, 2.2332,\n", + " 1.9458, 1.6622, 1.3814, 1.1027, 0.8255, 0.5496, 0.2744]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9989, 0.9990, 0.9990, 0.9990, 0.9990, 0.9992, 0.9990,\n", + " 0.9990, 0.9997, 0.9994, 0.9997, 0.9998, 0.9996, 0.9995, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9998, 0.9999, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([3.5795, 3.6420, 3.6119, 3.5175, 3.3778, 3.2056, 3.0101, 2.7975, 2.5724,\n", + " 2.3382, 2.0971, 1.8510, 1.6012, 1.3485, 1.0937, 0.8374, 0.5799, 0.3215])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 13 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0244, grad_fn=) , base rewards= tensor([6.3596, 6.3596, 6.3596, 6.3596, 6.3596, 6.3596, 6.3596, 5.7637, 5.2603,\n", + " 4.8212, 4.4275, 4.0662, 3.7282, 3.4073, 3.0989, 2.7996, 2.5072, 2.2198,\n", + " 1.9362, 1.6554, 1.3767, 1.0995, 0.8235, 0.5484, 0.2740]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9989, 0.9990, 0.9990, 0.9990, 0.9990, 0.9992, 0.9990,\n", + " 0.9990, 0.9997, 0.9994, 0.9997, 0.9998, 0.9996, 0.9995, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9998, 0.9999, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([3.8391, 3.9016, 3.8715, 3.7771, 3.6373, 3.4651, 3.2696, 3.0570, 2.8320,\n", + " 2.5977, 2.3567, 2.1106, 1.8607, 1.6080, 1.3533, 1.0969, 0.8394, 0.5811,\n", + " 0.3220])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 7131 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0227, grad_fn=) , base rewards= tensor([6.6333, 6.6333, 6.6333, 6.6333, 6.6333, 6.6333, 6.0372, 5.5339, 5.0948,\n", + " 4.7011, 4.3397, 4.0018, 3.6809, 3.3724, 3.0732, 2.7808, 2.4934, 2.2098,\n", + " 1.9290, 1.6502, 1.3731, 1.0971, 0.8220, 0.5475, 0.2736]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9989, 0.9990, 0.9990, 0.9991, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([4.0990, 4.1615, 4.1314, 4.0369, 3.8972, 3.7250, 3.5295, 3.3169, 3.0919,\n", + " 2.8576, 2.6166, 2.3705, 2.1206, 1.8679, 1.6132, 1.3568, 1.0993, 0.8410,\n", + " 0.5819, 0.3224])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0274, grad_fn=) , base rewards= tensor([6.9063, 6.9063, 6.9063, 6.9063, 6.9063, 6.3106, 5.8071, 5.3681, 4.9744,\n", + " 4.6131, 4.2751, 3.9542, 3.6458, 3.3465, 3.0541, 2.7667, 2.4831, 2.2023,\n", + " 1.9236, 1.6464, 1.3704, 1.0953, 0.8209, 0.5469, 0.2733]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9989, 0.9990, 0.9990, 0.9991, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([4.3591, 4.4216, 4.3915, 4.2971, 4.1574, 3.9852, 3.7896, 3.5771, 3.3520,\n", + " 3.1178, 2.8767, 2.6306, 2.3808, 2.1281, 1.8733, 1.6170, 1.3595, 1.1011,\n", + " 0.8421, 0.5826, 0.3227])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0327, grad_fn=) , base rewards= tensor([7.1808, 7.1808, 7.1808, 7.1808, 6.5834, 6.0803, 5.6412, 5.2475, 4.8862,\n", + " 4.5482, 4.2273, 3.9189, 3.6196, 3.3272, 3.0398, 2.7562, 2.4754, 2.1967,\n", + " 1.9195, 1.6435, 1.3684, 1.0940, 0.8200, 0.5464, 0.2731]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9989, 0.9990, 0.9990, 0.9991, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([4.6195, 4.6820, 4.6519, 4.5575, 4.4177, 4.2456, 4.0500, 3.8375, 3.6124,\n", + " 3.3782, 3.1371, 2.8910, 2.6411, 2.3885, 2.1337, 1.8774, 1.6199, 1.3615,\n", + " 1.1025, 0.8429, 0.5831, 0.3229])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 2 ep 9 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0382, grad_fn=) , base rewards= tensor([7.4481, 7.4481, 7.4481, 6.8576, 6.3530, 5.9142, 5.5204, 5.1591, 4.8212,\n", + " 4.5002, 4.1918, 3.8926, 3.6001, 3.3128, 3.0291, 2.7483, 2.4696, 2.1925,\n", + " 1.9165, 1.6414, 1.3669, 1.0930, 0.8194, 0.5461, 0.2729]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9989, 0.9990, 0.9991, 0.9991, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([4.8801, 4.9426, 4.9124, 4.8180, 4.6783, 4.5061, 4.3106, 4.0980, 3.8729,\n", + " 3.6387, 3.3977, 3.1515, 2.9017, 2.6490, 2.3942, 2.1379, 1.8804, 1.6220,\n", + " 1.3630, 1.1035, 0.8436, 0.5834, 0.3230])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 70 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0420, grad_fn=) , base rewards= tensor([7.7435, 7.7435, 7.1254, 6.6270, 6.1868, 5.7933, 5.4319, 5.0940, 4.7731,\n", + " 4.4646, 4.1654, 3.8730, 3.5856, 3.3020, 3.0212, 2.7424, 2.4653, 2.1893,\n", + " 1.9142, 1.6397, 1.3658, 1.0922, 0.8189, 0.5458, 0.2728]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9991, 0.9992, 0.9992, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([5.1404, 5.2029, 5.1732, 5.0786, 4.9389, 4.7668, 4.5712, 4.3586, 4.1336,\n", + " 3.8994, 3.6583, 3.4122, 3.1623, 2.9097, 2.6549, 2.3986, 2.1411, 1.8827,\n", + " 1.6237, 1.3641, 1.1042, 0.8441, 0.5837, 0.3232])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(0.0482, grad_fn=) , base rewards= tensor([7.9300, 7.4188, 6.8950, 6.4606, 6.0658, 5.7047, 5.3667, 5.0458, 4.7374,\n", + " 4.4382, 4.1457, 3.8583, 3.5747, 3.2939, 3.0152, 2.7380, 2.4620, 2.1869,\n", + " 1.9125, 1.6385, 1.3649, 1.0916, 0.8185, 0.5456, 0.2727]) return= 133326.59199999998\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9991, 0.9992, 0.9992, 0.9990, 0.9997, 0.9994, 0.9993,\n", + " 0.9991, 0.9998, 0.9994, 0.9998, 0.9999, 0.9996, 0.9997, 0.9993, 1.0000,\n", + " 0.9999, 1.0000, 1.0000, 0.9999, 1.0000, 0.9993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5557, 0.5280, 0.5349, 0.5331, 0.5336, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335,\n", + " 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5335, 0.5960])\n", + "finalReturns: tensor([5.4026, 5.4651, 5.4333, 5.3396, 5.1996, 5.0275, 4.8319, 4.6194, 4.3943,\n", + " 4.1601, 3.9190, 3.6729, 3.4231, 3.1704, 2.9156, 2.6593, 2.4018, 2.1434,\n", + " 1.8844, 1.6249, 1.3650, 1.1048, 0.8444, 0.5839, 0.3232])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682740769 saved\n", + "[1632248, 'tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.])', 133326.59199999998, 77073.984, 0.0481695681810379, 1e-05, 1, 0, 'tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\\n 25, 25, 25, 25, 25, 25, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682740769', 25, 50, 171147.58350022632, 214073.728368001, 88670.91886744411, 133326.59199999998, 130350.63466666665, 79008.24733959991, 78991.42784922772, 95380.52812037412, 95380.52812037412, 102530.56714139864, 79008.24733959991, 95380.52812037412]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213,\n", + " 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213, 0.5213]) return= 130508.83063279034\n", + "probs of actions: tensor([0.8197, 0.8212, 0.8176, 0.8134, 0.8230, 0.8173, 0.8226, 0.1095, 0.8180,\n", + " 0.1128, 0.8094, 0.1104, 0.8382, 0.8347, 0.8563, 0.8227, 0.0014, 0.8433,\n", + " 0.7915, 0.8165, 0.8150, 0.8321, 0.8387, 0.7760, 0.9487],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5207, 0.5214, 0.5212, 0.5213, 0.5213, 0.5212, 0.5249,\n", + " 0.5203, 0.5251, 0.5202, 0.5251, 0.5203, 0.5215, 0.5212, 0.5132, 0.5543,\n", + " 0.5132, 0.5233, 0.5208, 0.5214, 0.5213, 0.5213, 0.5213])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([ 0, 0, 17, 0, 0, 2, 0, 0, 0, 0, 12, 17, 16, 3, 0, 0, 16, 0,\n", + " 17, 17, 0, 17, 17, 17, 0])\n", + "loss= tensor(0.0142, grad_fn=) , base rewards= tensor([1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776,\n", + " 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776,\n", + " 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 1.0776, 0.5100]) return= 132640.40457803075\n", + "probs of actions: tensor([4.3731e-01, 4.2664e-01, 3.0690e-01, 4.7486e-01, 6.2047e-01, 1.8283e-02,\n", + " 5.1649e-01, 4.6048e-01, 5.6530e-01, 5.5434e-01, 4.1340e-03, 2.0115e-01,\n", + " 1.6684e-02, 3.7736e-04, 4.3648e-01, 4.8998e-01, 1.9829e-02, 5.7272e-01,\n", + " 4.0393e-01, 3.1937e-01, 4.3911e-01, 3.3119e-01, 3.0537e-01, 6.6976e-01,\n", + " 9.8906e-01], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.4918, 0.5846, 0.5060, 0.5247, 0.5276, 0.5197, 0.5217,\n", + " 0.5212, 0.5069, 0.5366, 0.5475, 0.5665, 0.5208, 0.5214, 0.4957, 0.5807,\n", + " 0.4780, 0.5594, 0.5674, 0.4812, 0.5586, 0.5387, 0.5725])\n", + "finalReturns: tensor([0.0336, 0.0625])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([17, 17, 17, 17, 17, 17, 17, 17, 17, 26, 17, 17, 17, 17, 17, 17, 17, 17,\n", + " 17, 17, 17, 17, 17, 17, 0])\n", + "loss= tensor(0.0192, grad_fn=) , base rewards= tensor([1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452,\n", + " 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 1.5452,\n", + " 1.5452, 1.5452, 1.5452, 1.5452, 1.5452, 0.9737, 0.4646]) return= 135360.55464815182\n", + "probs of actions: tensor([0.9285, 0.9338, 0.9111, 0.9164, 0.8840, 0.9259, 0.8917, 0.9240, 0.9054,\n", + " 0.0012, 0.9157, 0.9091, 0.9244, 0.9328, 0.9384, 0.9183, 0.9283, 0.9249,\n", + " 0.9404, 0.9240, 0.9221, 0.9283, 0.9593, 0.9090, 0.9896],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.5582, 0.5388, 0.5436, 0.5424, 0.5427, 0.5426, 0.5426, 0.5426,\n", + " 0.5039, 0.5772, 0.5342, 0.5448, 0.5421, 0.5428, 0.5426, 0.5426, 0.5426,\n", + " 0.5426, 0.5426, 0.5426, 0.5426, 0.5426, 0.5426, 0.5715])\n", + "finalReturns: tensor([0.1116, 0.1405, 0.1069])\n", + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([17, 24, 17, 17, 17, 17, 17, 22, 17, 17, 17, 17, 17, 17, 17, 17, 17, 22,\n", + " 17, 17, 22, 17, 17, 17, 0])\n", + "loss= tensor(0.1288, grad_fn=) , base rewards= tensor([1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930,\n", + " 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930, 1.9930,\n", + " 1.9930, 1.9930, 1.9930, 1.9930, 1.4027, 0.8980, 0.4323]) return= 135269.9521378386\n", + "probs of actions: tensor([0.8732, 0.0179, 0.8410, 0.8647, 0.8634, 0.8757, 0.8419, 0.0913, 0.8787,\n", + " 0.9062, 0.8654, 0.8757, 0.8808, 0.9079, 0.8892, 0.8849, 0.8757, 0.0644,\n", + " 0.8793, 0.8759, 0.0651, 0.8430, 0.8864, 0.7571, 0.9970],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.5295, 0.5654, 0.5370, 0.5440, 0.5423, 0.5427, 0.5231, 0.5617,\n", + " 0.5379, 0.5438, 0.5423, 0.5427, 0.5426, 0.5426, 0.5426, 0.5426, 0.5231,\n", + " 0.5617, 0.5379, 0.5243, 0.5614, 0.5380, 0.5438, 0.5712])\n", + "finalReturns: tensor([0.2214, 0.2503, 0.2170, 0.1389])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([18, 22, 22, 22, 16, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 17, 24, 0])\n", + "loss= tensor(2.2023, grad_fn=) , base rewards= tensor([2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434,\n", + " 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434, 2.3434,\n", + " 2.3434, 2.3434, 2.3434, 1.7567, 1.2512, 0.8026, 0.3945]) return= 134596.2288854169\n", + "probs of actions: tensor([0.0027, 0.8000, 0.8295, 0.7982, 0.0137, 0.7866, 0.8077, 0.8311, 0.7757,\n", + " 0.7676, 0.8022, 0.8268, 0.8164, 0.7579, 0.8175, 0.7962, 0.8125, 0.8182,\n", + " 0.8061, 0.8040, 0.8673, 0.8985, 0.0647, 0.0441, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5426, 0.5373, 0.5386, 0.5611, 0.5156, 0.5441, 0.5369, 0.5387,\n", + " 0.5383, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5579, 0.5102, 0.5993])\n", + "finalReturns: tensor([0.4006, 0.4490, 0.4161, 0.3068, 0.2047])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 22, 22, 17, 22, 22, 22, 22, 22, 24, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.1875, grad_fn=) , base rewards= tensor([2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857,\n", + " 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857, 2.6857,\n", + " 2.6857, 2.6857, 2.0990, 1.5935, 1.1449, 0.7368, 0.3579]) return= 134488.70432871333\n", + "probs of actions: tensor([0.9050, 0.9012, 0.9150, 0.8960, 0.8927, 0.0392, 0.9032, 0.9113, 0.8899,\n", + " 0.8879, 0.9010, 0.0538, 0.9051, 0.8822, 0.9117, 0.8996, 0.9057, 0.9102,\n", + " 0.9060, 0.9025, 0.9461, 0.9436, 0.9424, 0.9373, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5396, 0.5381, 0.5579, 0.5193, 0.5432, 0.5372,\n", + " 0.5387, 0.5383, 0.5292, 0.5460, 0.5364, 0.5388, 0.5382, 0.5384, 0.5383,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([0.5928, 0.6412, 0.6084, 0.5186, 0.3883, 0.2289])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 17, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.2667, grad_fn=) , base rewards= tensor([3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284,\n", + " 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284, 3.0284,\n", + " 3.0284, 2.4413, 1.9359, 1.4873, 1.0792, 0.7003, 0.3424]) return= 134519.1548127569\n", + "probs of actions: tensor([0.9210, 0.9158, 0.9274, 0.9103, 0.9067, 0.9078, 0.9168, 0.9221, 0.9075,\n", + " 0.9069, 0.9156, 0.9256, 0.9163, 0.9014, 0.0181, 0.9141, 0.9187, 0.9227,\n", + " 0.9245, 0.9104, 0.9560, 0.9496, 0.9478, 0.9500, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5396, 0.5381, 0.5384, 0.5383, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5579, 0.5194, 0.5432, 0.5372,\n", + " 0.5387, 0.5383, 0.5384, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([0.7887, 0.8371, 0.8043, 0.7145, 0.5842, 0.4249, 0.2443])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 24, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.2357, grad_fn=) , base rewards= tensor([3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592,\n", + " 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592, 3.3592,\n", + " 2.7724, 2.2669, 1.8184, 1.4103, 1.0313, 0.6735, 0.3310]) return= 134444.89466666666\n", + "probs of actions: tensor([0.9528, 0.0494, 0.9549, 0.9443, 0.9409, 0.9427, 0.9482, 0.9500, 0.9457,\n", + " 0.9458, 0.9480, 0.9526, 0.9470, 0.9422, 0.9535, 0.9476, 0.9500, 0.9530,\n", + " 0.9664, 0.9401, 0.9671, 0.9680, 0.9685, 0.9721, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5489, 0.5411, 0.5377, 0.5385, 0.5383, 0.5384, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([0.9960, 1.0444, 1.0116, 0.9218, 0.7915, 0.6322, 0.4517, 0.2557])\n", + "----------------------------------------\n", + "iter 2 stage 16 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 24, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.2379, grad_fn=) , base rewards= tensor([3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803,\n", + " 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.6803, 3.0955,\n", + " 2.5895, 2.1410, 1.7329, 1.3540, 0.9961, 0.6537, 0.3227]) return= 134445.23460823056\n", + "probs of actions: tensor([0.9648, 0.9603, 0.9664, 0.9577, 0.9548, 0.9563, 0.9609, 0.9619, 0.9596,\n", + " 0.9595, 0.9610, 0.9640, 0.9599, 0.9569, 0.0341, 0.9608, 0.9626, 0.9690,\n", + " 0.9761, 0.9543, 0.9755, 0.9771, 0.9764, 0.9821, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5396, 0.5381, 0.5384, 0.5383, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5292, 0.5460, 0.5364, 0.5388,\n", + " 0.5382, 0.5384, 0.5383, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([1.2118, 1.2602, 1.2273, 1.1375, 1.0072, 0.8479, 0.6674, 0.4714, 0.2641])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.2841, grad_fn=) , base rewards= tensor([3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983,\n", + " 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.9983, 3.4115, 2.9060,\n", + " 2.4574, 2.0494, 1.6704, 1.3125, 0.9701, 0.6391, 0.3164]) return= 134475.688\n", + "probs of actions: tensor([0.9686, 0.9641, 0.9696, 0.9614, 0.9594, 0.9605, 0.9648, 0.9655, 0.9639,\n", + " 0.9637, 0.9650, 0.9671, 0.9636, 0.9615, 0.9688, 0.9677, 0.9654, 0.9739,\n", + " 0.9781, 0.9543, 0.9812, 0.9795, 0.9813, 0.9855, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5396, 0.5381, 0.5384, 0.5383, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([1.4337, 1.4821, 1.4492, 1.3595, 1.2292, 1.0698, 0.8893, 0.6933, 0.4860,\n", + " 0.2703])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 24, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 0])\n", + "loss= tensor(0.3424, grad_fn=) , base rewards= tensor([4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 4.3101,\n", + " 4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 4.3101, 3.7233, 3.2178, 2.7692,\n", + " 2.3612, 1.9822, 1.6243, 1.2819, 0.9509, 0.6282, 0.3118]) return= 134445.21341666667\n", + "probs of actions: tensor([0.9685, 0.9639, 0.9698, 0.0383, 0.9595, 0.9606, 0.9645, 0.9653, 0.9641,\n", + " 0.9640, 0.9651, 0.9672, 0.9636, 0.9619, 0.9746, 0.9696, 0.9669, 0.9763,\n", + " 0.9773, 0.9544, 0.9801, 0.9832, 0.9823, 0.9843, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5304, 0.5457, 0.5365, 0.5388, 0.5382, 0.5384,\n", + " 0.5383, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384,\n", + " 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5384, 0.5868])\n", + "finalReturns: tensor([1.6602, 1.7086, 1.6758, 1.5860, 1.4557, 1.2964, 1.1158, 0.9199, 0.7126,\n", + " 0.4969, 0.2750])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 22, 22, 22, 22, 24, 22, 24, 24, 22, 22, 22, 24, 22, 22, 22, 22, 22,\n", + " 24, 22, 24, 22, 22, 22, 0])\n", + "loss= tensor(8.3404, grad_fn=) , base rewards= tensor([4.5998, 4.5998, 4.5998, 4.5998, 4.5998, 4.5998, 4.5998, 4.5998, 4.5998,\n", + " 4.5998, 4.5998, 4.5998, 4.5998, 4.5998, 4.0054, 3.5016, 3.0526, 2.6447,\n", + " 2.2657, 1.9078, 1.5654, 1.2401, 0.9203, 0.6119, 0.3046]) return= 134292.63893419717\n", + "probs of actions: tensor([0.9018, 0.8871, 0.9064, 0.8867, 0.8751, 0.1197, 0.8925, 0.1104, 0.1097,\n", + " 0.8910, 0.8925, 0.8960, 0.1160, 0.8909, 0.9092, 0.9009, 0.8661, 0.9170,\n", + " 0.0809, 0.8616, 0.0710, 0.9437, 0.9367, 0.9406, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5581, 0.5335, 0.5396, 0.5381, 0.5292, 0.5460, 0.5272, 0.5373,\n", + " 0.5440, 0.5370, 0.5387, 0.5291, 0.5461, 0.5364, 0.5388, 0.5382, 0.5384,\n", + " 0.5291, 0.5460, 0.5272, 0.5465, 0.5363, 0.5389, 0.5866])\n", + "finalReturns: tensor([1.9089, 1.9573, 1.9246, 1.8347, 1.7045, 1.5451, 1.3738, 1.1702, 0.9682,\n", + " 0.7415, 0.5136, 0.2820])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 12 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([22, 24, 24, 22, 22, 22, 24, 22, 22, 22, 22, 24, 24, 22, 22, 22, 22, 22,\n", + " 22, 22, 24, 24, 22, 24, 0])\n", + "loss= tensor(12.3434, grad_fn=) , base rewards= tensor([4.8923, 4.8923, 4.8923, 4.8923, 4.8923, 4.8923, 4.8923, 4.8923, 4.8923,\n", + " 4.8923, 4.8923, 4.8923, 4.8923, 4.2979, 3.7942, 3.3519, 2.9471, 2.5707,\n", + " 2.2148, 1.8738, 1.5437, 1.2218, 0.9060, 0.6001, 0.3004]) return= 134247.45269681388\n", + "probs of actions: tensor([0.6391, 0.4036, 0.3466, 0.6153, 0.5722, 0.5878, 0.3735, 0.5996, 0.6154,\n", + " 0.6103, 0.6166, 0.3860, 0.4416, 0.5771, 0.5627, 0.6402, 0.5170, 0.6724,\n", + " 0.6441, 0.5184, 0.3052, 0.2713, 0.6895, 0.3034, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5489, 0.5319, 0.5453, 0.5366, 0.5388, 0.5290, 0.5461, 0.5364,\n", + " 0.5388, 0.5382, 0.5292, 0.5368, 0.5441, 0.5369, 0.5387, 0.5383, 0.5384,\n", + " 0.5384, 0.5384, 0.5292, 0.5368, 0.5441, 0.5277, 0.5948])\n", + "finalReturns: tensor([2.1502, 2.2078, 2.1675, 2.0728, 1.9389, 1.7770, 1.5946, 1.3972, 1.1889,\n", + " 0.9816, 0.7607, 0.5224, 0.2944])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 22, 24, 22, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 22, 24, 24, 24, 0])\n", + "loss= tensor(5.1378, grad_fn=) , base rewards= tensor([5.0743, 5.0743, 5.0743, 5.0743, 5.0743, 5.0743, 5.0743, 5.0743, 5.0743,\n", + " 5.0743, 5.0743, 5.0743, 4.4812, 3.9772, 3.5349, 3.1365, 2.7693, 2.4248,\n", + " 2.0968, 1.7809, 1.4739, 1.1736, 0.8782, 0.5810, 0.2893]) return= 133847.94214272863\n", + "probs of actions: tensor([0.8439, 0.8704, 0.8356, 0.8477, 0.8817, 0.1337, 0.8461, 0.1280, 0.8540,\n", + " 0.8596, 0.8526, 0.8777, 0.9175, 0.8723, 0.9118, 0.8651, 0.9045, 0.8369,\n", + " 0.8812, 0.9076, 0.1471, 0.8375, 0.8724, 0.8691, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5446, 0.5276, 0.5464, 0.5271,\n", + " 0.5373, 0.5348, 0.5354, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5445, 0.5276, 0.5372, 0.5348, 0.5930])\n", + "finalReturns: tensor([2.4807, 2.5383, 2.5071, 2.4141, 2.2772, 2.1091, 1.9183, 1.7110, 1.4916,\n", + " 1.2632, 1.0191, 0.7869, 0.5468, 0.3037])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 22, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.4986, grad_fn=) , base rewards= tensor([5.3491, 5.3491, 5.3491, 5.3491, 5.3491, 5.3491, 5.3491, 5.3491, 5.3491,\n", + " 5.3491, 5.3491, 4.7562, 4.2521, 3.8099, 3.4114, 3.0443, 2.6998, 2.3718,\n", + " 2.0559, 1.7489, 1.4486, 1.1532, 0.8614, 0.5724, 0.2855]) return= 133786.32760416673\n", + "probs of actions: tensor([0.9711, 0.9771, 0.9691, 0.9704, 0.0206, 0.9748, 0.9702, 0.9777, 0.9723,\n", + " 0.9741, 0.9751, 0.9822, 0.9866, 0.9817, 0.9886, 0.9788, 0.9858, 0.9735,\n", + " 0.9832, 0.9838, 0.9789, 0.9763, 0.9846, 0.9826, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5442, 0.5277, 0.5372, 0.5348, 0.5354,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([2.7380, 2.7956, 2.7644, 2.6713, 2.5345, 2.3663, 2.1755, 1.9682, 1.7488,\n", + " 1.5205, 1.2855, 1.0456, 0.8021, 0.5558, 0.3074])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.2965, grad_fn=) , base rewards= tensor([5.6334, 5.6334, 5.6334, 5.6334, 5.6334, 5.6334, 5.6334, 5.6334, 5.6334,\n", + " 5.6334, 5.0405, 4.5364, 4.0942, 3.6957, 3.3286, 2.9841, 2.6561, 2.3402,\n", + " 2.0332, 1.7329, 1.4375, 1.1458, 0.8567, 0.5698, 0.2843]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9837, 0.9872, 0.9825, 0.9829, 0.9885, 0.9855, 0.9831, 0.9875, 0.9842,\n", + " 0.9881, 0.9885, 0.9909, 0.9935, 0.9897, 0.9942, 0.9897, 0.9917, 0.9867,\n", + " 0.9917, 0.9918, 0.9900, 0.9879, 0.9922, 0.9919, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([2.9890, 3.0466, 3.0154, 2.9223, 2.7855, 2.6173, 2.4265, 2.2192, 1.9998,\n", + " 1.7715, 1.5365, 1.2966, 1.0530, 0.8068, 0.5584, 0.3086])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 99999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0961, grad_fn=) , base rewards= tensor([5.9169, 5.9169, 5.9169, 5.9169, 5.9169, 5.9169, 5.9169, 5.9169, 5.9169,\n", + " 5.3240, 4.8199, 4.3777, 3.9792, 3.6120, 3.2675, 2.9395, 2.6236, 2.3167,\n", + " 2.0164, 1.7210, 1.4292, 1.1402, 0.8532, 0.5678, 0.2835]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9944, 0.9956, 0.9939, 0.9940, 0.9961, 0.9949, 0.9941, 0.9957, 0.9959,\n", + " 0.9963, 0.9971, 0.9972, 0.9983, 0.9974, 0.9986, 0.9978, 0.9971, 0.9966,\n", + " 0.9973, 0.9980, 0.9976, 0.9971, 0.9983, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([3.2408, 3.2984, 3.2672, 3.1741, 3.0373, 2.8692, 2.6784, 2.4711, 2.2517,\n", + " 2.0233, 1.7883, 1.5484, 1.3049, 1.0586, 0.8103, 0.5604, 0.3094])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 73532 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0306, grad_fn=) , base rewards= tensor([6.1997, 6.1997, 6.1997, 6.1997, 6.1997, 6.1997, 6.1997, 6.1997, 5.6068,\n", + " 5.1027, 4.6605, 4.2620, 3.8949, 3.5503, 3.2223, 2.9065, 2.5995, 2.2992,\n", + " 2.0038, 1.7120, 1.4230, 1.1360, 0.8506, 0.5663, 0.2828]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9977, 0.9982, 0.9975, 0.9975, 0.9984, 0.9978, 0.9975, 0.9990, 0.9988,\n", + " 0.9988, 0.9991, 0.9994, 0.9995, 0.9995, 0.9999, 0.9995, 0.9991, 0.9989,\n", + " 0.9993, 0.9994, 0.9993, 0.9992, 0.9997, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([3.4933, 3.5509, 3.5197, 3.4266, 3.2898, 3.1216, 2.9309, 2.7236, 2.5041,\n", + " 2.2758, 2.0408, 1.8009, 1.5574, 1.3111, 1.0628, 0.8129, 0.5619, 0.3101])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 44880 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0163, grad_fn=) , base rewards= tensor([6.4820, 6.4820, 6.4820, 6.4820, 6.4820, 6.4820, 6.4820, 5.8892, 5.3851,\n", + " 4.9428, 4.5444, 4.1772, 3.8327, 3.5047, 3.1888, 2.8818, 2.5815, 2.2861,\n", + " 1.9944, 1.7053, 1.4184, 1.1329, 0.8486, 0.5652, 0.2823]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9986, 0.9989, 0.9985, 0.9985, 0.9991, 0.9987, 0.9990, 0.9997, 0.9994,\n", + " 0.9994, 0.9995, 0.9997, 1.0000, 0.9998, 1.0000, 0.9999, 0.9996, 0.9995,\n", + " 0.9997, 0.9998, 0.9997, 0.9997, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([3.7462, 3.8038, 3.7726, 3.6796, 3.5428, 3.3746, 3.1838, 2.9765, 2.7571,\n", + " 2.5288, 2.2938, 2.0539, 1.8103, 1.5641, 1.3157, 1.0659, 0.8149, 0.5630,\n", + " 0.3106])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 5 ep 5209 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0176, grad_fn=) , base rewards= tensor([6.7641, 6.7641, 6.7641, 6.7641, 6.7641, 6.7641, 6.1711, 5.6670, 5.2248,\n", + " 4.8263, 4.4592, 4.1147, 3.7867, 3.4708, 3.1638, 2.8635, 2.5681, 2.2763,\n", + " 1.9873, 1.7003, 1.4149, 1.1306, 0.8471, 0.5643, 0.2820]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9988, 0.9991, 0.9987, 0.9987, 0.9992, 0.9990, 0.9991, 0.9998, 0.9995,\n", + " 0.9995, 0.9996, 0.9998, 1.0000, 0.9999, 1.0000, 0.9999, 0.9997, 0.9995,\n", + " 0.9998, 0.9998, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([3.9996, 4.0572, 4.0260, 3.9329, 3.7961, 3.6279, 3.4371, 3.2299, 3.0104,\n", + " 2.7821, 2.5471, 2.3072, 2.0637, 1.8174, 1.5691, 1.3192, 1.0682, 0.8164,\n", + " 0.5639, 0.3109])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0217, grad_fn=) , base rewards= tensor([7.0455, 7.0455, 7.0455, 7.0455, 7.0455, 6.4529, 5.9487, 5.5065, 5.1080,\n", + " 4.7409, 4.3964, 4.0684, 3.7525, 3.4455, 3.1452, 2.8498, 2.5580, 2.2690,\n", + " 1.9821, 1.6966, 1.4123, 1.1288, 0.8460, 0.5637, 0.2817]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9988, 0.9991, 0.9987, 0.9987, 0.9992, 0.9990, 0.9991, 0.9998, 0.9995,\n", + " 0.9995, 0.9996, 0.9998, 1.0000, 0.9999, 1.0000, 0.9999, 0.9997, 0.9995,\n", + " 0.9998, 0.9998, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([4.2532, 4.3108, 4.2796, 4.1865, 4.0497, 3.8815, 3.6907, 3.4834, 3.2640,\n", + " 3.0357, 2.8007, 2.5608, 2.3173, 2.0710, 1.8226, 1.5728, 1.3218, 1.0700,\n", + " 0.8175, 0.5645, 0.3112])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 357 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0256, grad_fn=) , base rewards= tensor([7.3283, 7.3283, 7.3283, 7.3283, 6.7341, 6.2303, 5.7880, 5.3895, 5.0224,\n", + " 4.6779, 4.3499, 4.0340, 3.7270, 3.4267, 3.1313, 2.8396, 2.5505, 2.2636,\n", + " 1.9781, 1.6938, 1.4103, 1.1275, 0.8452, 0.5632, 0.2815]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9988, 0.9991, 0.9987, 0.9990, 0.9994, 0.9990, 0.9991, 0.9998, 0.9995,\n", + " 0.9995, 0.9996, 0.9998, 1.0000, 0.9999, 1.0000, 0.9999, 0.9997, 0.9996,\n", + " 0.9998, 0.9999, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([4.5069, 4.5645, 4.5334, 4.4403, 4.3035, 4.1353, 3.9445, 3.7372, 3.5178,\n", + " 3.2895, 3.0545, 2.8146, 2.5711, 2.3248, 2.0764, 1.8266, 1.5756, 1.3238,\n", + " 1.0713, 0.8183, 0.5650, 0.3114])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 216 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0289, grad_fn=) , base rewards= tensor([7.6043, 7.6043, 7.6043, 7.0167, 6.5114, 6.0694, 5.6709, 5.3037, 4.9592,\n", + " 4.6312, 4.3153, 4.0084, 3.7081, 3.4127, 3.1209, 2.8319, 2.5449, 2.2595,\n", + " 1.9752, 1.6917, 1.4089, 1.1265, 0.8446, 0.5629, 0.2814]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9989, 0.9991, 0.9990, 0.9991, 0.9995, 0.9991, 0.9992, 0.9998, 0.9995,\n", + " 0.9996, 0.9997, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000, 0.9997, 0.9996,\n", + " 0.9998, 0.9999, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([4.7610, 4.8186, 4.7873, 4.6942, 4.5574, 4.3893, 4.1985, 3.9912, 3.7718,\n", + " 3.5434, 3.3084, 3.0685, 2.8250, 2.5787, 2.3304, 2.0805, 1.8295, 1.5777,\n", + " 1.3252, 1.0723, 0.8189, 0.5653, 0.3115])\n", + "----------------------------------------\n", + "iter 2 stage 1 ep 0 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0342, grad_fn=) , base rewards= tensor([7.9073, 7.9073, 7.2930, 6.7938, 6.3504, 5.9522, 5.5850, 5.2405, 4.9125,\n", + " 4.5966, 4.2896, 3.9893, 3.6939, 3.4021, 3.1131, 2.8262, 2.5407, 2.2564,\n", + " 1.9729, 1.6901, 1.4078, 1.1258, 0.8441, 0.5626, 0.2812]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9989, 0.9991, 0.9990, 0.9991, 0.9995, 0.9991, 0.9992, 0.9998, 0.9995,\n", + " 0.9996, 0.9997, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000, 0.9997, 0.9996,\n", + " 0.9998, 0.9999, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([5.0147, 5.0723, 5.0415, 4.9482, 4.8115, 4.6433, 4.4525, 4.2452, 4.0258,\n", + " 3.7975, 3.5625, 3.3226, 3.0791, 2.8328, 2.5844, 2.3346, 2.0836, 1.8318,\n", + " 1.5793, 1.3263, 1.0730, 0.8194, 0.5656, 0.3117])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 64 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 0])\n", + "loss= tensor(0.0387, grad_fn=) , base rewards= tensor([8.1053, 7.5941, 7.0703, 6.6326, 6.2331, 5.8662, 5.5216, 5.1936, 4.8777,\n", + " 4.5708, 4.2705, 3.9750, 3.6833, 3.3943, 3.1073, 2.8219, 2.5375, 2.2541,\n", + " 1.9713, 1.6889, 1.4070, 1.1253, 0.8437, 0.5624, 0.2812]) return= 133755.66666666666\n", + "probs of actions: tensor([0.9990, 0.9992, 0.9991, 0.9992, 0.9995, 0.9991, 0.9992, 0.9998, 0.9996,\n", + " 0.9996, 0.9997, 0.9999, 1.0000, 0.9999, 1.0000, 1.0000, 0.9997, 0.9996,\n", + " 0.9998, 0.9999, 0.9998, 0.9998, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4536, 0.5567, 0.5300, 0.5366, 0.5350, 0.5354, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353,\n", + " 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5353, 0.5929])\n", + "finalReturns: tensor([5.2702, 5.3278, 5.2950, 5.2026, 5.0656, 4.8975, 4.7067, 4.4994, 4.2800,\n", + " 4.0516, 3.8166, 3.5768, 3.3332, 3.0869, 2.8386, 2.5887, 2.3378, 2.0859,\n", + " 1.8334, 1.5805, 1.3271, 1.0735, 0.8198, 0.5658, 0.3117])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682794213 saved\n", + "[2164266, 'tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.])', 133755.66666666666, 78214.06666666668, 0.038705166429281235, 1e-05, 1, 0, 'tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\\n 24, 24, 24, 24, 24, 24, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682794213', 25, 50, 170327.33349408704, 211165.96084616287, 87190.73961268678, 133755.6666666667, 130787.53866666667, 82417.65584066519, 82417.65584066519, 99036.07704587854, 99036.07704587854, 100843.49835063974, 82417.65584066519, 99036.07704587854]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([0, 0, 0, 0, 0, 7, 0, 0, 0, 5, 0, 4, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 1,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134,\n", + " 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134,\n", + " 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134, 0.5134]) return= 127976.82117179644\n", + "probs of actions: tensor([0.8485, 0.8295, 0.8628, 0.8631, 0.7988, 0.0024, 0.8453, 0.8518, 0.8468,\n", + " 0.0049, 0.8436, 0.0070, 0.0926, 0.8624, 0.8310, 0.0958, 0.8208, 0.8386,\n", + " 0.0177, 0.8306, 0.8285, 0.8579, 0.8012, 0.0884, 0.9670],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5094, 0.5099, 0.5098, 0.5098, 0.5049, 0.5351, 0.5036, 0.5114,\n", + " 0.5069, 0.5279, 0.5037, 0.5252, 0.5095, 0.5099, 0.5097, 0.5134, 0.5089,\n", + " 0.5096, 0.5169, 0.5080, 0.5102, 0.5097, 0.5097, 0.5134])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([16, 0, 16, 15, 14, 15, 11, 3, 0, 0, 20, 15, 15, 1, 11, 8, 8, 16,\n", + " 1, 1, 15, 16, 0, 15, 0])\n", + "loss= tensor(0.0781, grad_fn=) , base rewards= tensor([1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114,\n", + " 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114,\n", + " 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 1.0114, 0.5126]) return= 131016.7267856707\n", + "probs of actions: tensor([0.0725, 0.2308, 0.0930, 0.1020, 0.0359, 0.0781, 0.0610, 0.0218, 0.3880,\n", + " 0.3613, 0.0086, 0.1072, 0.0867, 0.0801, 0.0709, 0.0041, 0.0056, 0.0781,\n", + " 0.0742, 0.0698, 0.0922, 0.0806, 0.1969, 0.0934, 0.9848],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5681, 0.4701, 0.5498, 0.5293, 0.5285, 0.5421, 0.5377, 0.5134,\n", + " 0.5089, 0.4700, 0.5611, 0.5236, 0.5553, 0.4901, 0.5454, 0.5218, 0.5085,\n", + " 0.5621, 0.5005, 0.4932, 0.5376, 0.5548, 0.4763, 0.5677])\n", + "finalReturns: tensor([0.0326, 0.0551])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([22, 22, 18, 15, 20, 18, 12, 12, 27, 19, 15, 18, 15, 12, 1, 22, 0, 18,\n", + " 15, 14, 18, 18, 21, 22, 0])\n", + "loss= tensor(0.8808, grad_fn=) , base rewards= tensor([1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995,\n", + " 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 1.4995,\n", + " 1.4995, 1.4995, 1.4995, 1.4995, 1.4995, 0.9377, 0.4405]) return= 131827.89335068475\n", + "probs of actions: tensor([0.0964, 0.0982, 0.3525, 0.0528, 0.0570, 0.3105, 0.1858, 0.0708, 0.0098,\n", + " 0.0618, 0.0573, 0.3612, 0.0493, 0.1349, 0.0565, 0.1031, 0.0742, 0.2706,\n", + " 0.0473, 0.0258, 0.3585, 0.2952, 0.0171, 0.0871, 0.9850],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5426, 0.5381, 0.5380, 0.5118, 0.5403, 0.5456, 0.5264, 0.4727,\n", + " 0.5651, 0.5343, 0.5203, 0.5425, 0.5363, 0.5430, 0.4568, 0.5926, 0.4577,\n", + " 0.5589, 0.5271, 0.5191, 0.5329, 0.5177, 0.5256, 0.5747])\n", + "finalReturns: tensor([0.1185, 0.1626, 0.1342])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([22, 22, 22, 0, 22, 22, 18, 22, 18, 22, 23, 22, 17, 22, 14, 22, 23, 22,\n", + " 22, 16, 22, 22, 16, 22, 0])\n", + "loss= tensor(1.5077, grad_fn=) , base rewards= tensor([1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284,\n", + " 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284, 1.9284,\n", + " 1.9284, 1.9284, 1.9284, 1.9284, 1.3481, 0.8552, 0.4170]) return= 131625.96944387257\n", + "probs of actions: tensor([0.5168, 0.4888, 0.5555, 0.0028, 0.5101, 0.5398, 0.1094, 0.5222, 0.1204,\n", + " 0.5231, 0.1283, 0.5068, 0.0124, 0.5243, 0.0104, 0.5004, 0.1249, 0.4907,\n", + " 0.5293, 0.0305, 0.5330, 0.6392, 0.0121, 0.5230, 0.9884],\n", + " grad_fn=)\n", + "rewards: tensor([0.4628, 0.5426, 0.5221, 0.5756, 0.4456, 0.5473, 0.5369, 0.5124, 0.5456,\n", + " 0.5102, 0.5257, 0.5290, 0.5450, 0.5075, 0.5597, 0.4951, 0.5296, 0.5280,\n", + " 0.5257, 0.5491, 0.5036, 0.5319, 0.5475, 0.5040, 0.5802])\n", + "finalReturns: tensor([0.2352, 0.2836, 0.2289, 0.1632])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 22, 22, 22, 22, 22, 22, 23, 19, 22, 27, 22, 22, 22, 23, 23, 23, 18,\n", + " 22, 22, 22, 23, 20, 22, 0])\n", + "loss= tensor(2.8372, grad_fn=) , base rewards= tensor([2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744,\n", + " 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744, 2.2744,\n", + " 2.2744, 2.2744, 2.2744, 1.7008, 1.2064, 0.7685, 0.3738]) return= 131444.76673770836\n", + "probs of actions: tensor([0.1846, 0.6751, 0.7233, 0.6721, 0.6664, 0.6970, 0.6251, 0.1851, 0.0142,\n", + " 0.6894, 0.0127, 0.6822, 0.6845, 0.6798, 0.1922, 0.1971, 0.1872, 0.0422,\n", + " 0.6683, 0.6213, 0.7433, 0.1346, 0.0178, 0.7598, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5464, 0.5212, 0.5274, 0.5259, 0.5262, 0.5261, 0.5217, 0.5423,\n", + " 0.5139, 0.5047, 0.5445, 0.5216, 0.5273, 0.5214, 0.5255, 0.5245, 0.5453,\n", + " 0.5103, 0.5302, 0.5252, 0.5219, 0.5383, 0.5177, 0.5767])\n", + "finalReturns: tensor([0.4053, 0.4537, 0.4263, 0.3258, 0.2029])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 22, 23, 22, 23, 22, 23, 22, 22, 22, 23, 18, 23, 23, 22, 22, 23, 23,\n", + " 22, 22, 22, 22, 22, 19, 0])\n", + "loss= tensor(2.8711, grad_fn=) , base rewards= tensor([2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216,\n", + " 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216, 2.6216,\n", + " 2.6216, 2.6216, 2.0477, 1.5533, 1.1155, 0.7175, 0.3483]) return= 131442.16007456576\n", + "probs of actions: tensor([0.2345, 0.7010, 0.2029, 0.6672, 0.2341, 0.7003, 0.2802, 0.7011, 0.6640,\n", + " 0.7034, 0.2696, 0.0222, 0.2170, 0.2349, 0.6298, 0.6698, 0.2356, 0.2339,\n", + " 0.6703, 0.6671, 0.7788, 0.8038, 0.7787, 0.0031, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5464, 0.5167, 0.5312, 0.5204, 0.5303, 0.5206, 0.5302, 0.5252,\n", + " 0.5264, 0.5216, 0.5460, 0.5057, 0.5295, 0.5280, 0.5257, 0.5218, 0.5254,\n", + " 0.5290, 0.5255, 0.5263, 0.5261, 0.5262, 0.5385, 0.5633])\n", + "finalReturns: tensor([0.5842, 0.6326, 0.6007, 0.5124, 0.3842, 0.2149])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 23, 22, 23, 22, 22, 23, 22, 22, 23, 22, 22, 22, 22, 22, 23, 22, 22,\n", + " 27, 23, 23, 22, 22, 22, 0])\n", + "loss= tensor(5.6294, grad_fn=) , base rewards= tensor([2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041,\n", + " 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041, 2.9041,\n", + " 2.9041, 2.3293, 1.8351, 1.4136, 1.0266, 0.6685, 0.3275]) return= 131314.67447750745\n", + "probs of actions: tensor([0.3571, 0.3441, 0.6513, 0.3953, 0.5974, 0.6013, 0.4182, 0.6063, 0.5660,\n", + " 0.3563, 0.5332, 0.6063, 0.6232, 0.6000, 0.5383, 0.3729, 0.6065, 0.6052,\n", + " 0.0218, 0.4118, 0.2705, 0.7124, 0.6872, 0.7186, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5419, 0.5249, 0.5220, 0.5299, 0.5252, 0.5219, 0.5299, 0.5252,\n", + " 0.5219, 0.5299, 0.5252, 0.5264, 0.5261, 0.5262, 0.5217, 0.5300, 0.5252,\n", + " 0.5019, 0.5407, 0.5207, 0.5302, 0.5252, 0.5264, 0.5745])\n", + "finalReturns: tensor([0.8156, 0.8885, 0.8419, 0.7427, 0.5995, 0.4324, 0.2470])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 23, 23, 23, 23, 23, 23, 22, 23, 23, 22, 23, 22, 20, 23, 22, 23, 23,\n", + " 23, 23, 23, 23, 22, 23, 0])\n", + "loss= tensor(2.5241, grad_fn=) , base rewards= tensor([3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482,\n", + " 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482, 3.2482,\n", + " 2.6695, 2.1762, 1.7414, 1.3482, 0.9849, 0.6432, 0.3172]) return= 131291.9557196191\n", + "probs of actions: tensor([0.7267, 0.7023, 0.7028, 0.7538, 0.6919, 0.7213, 0.7498, 0.2223, 0.7321,\n", + " 0.7212, 0.1687, 0.7095, 0.2447, 0.0093, 0.6804, 0.2080, 0.7106, 0.7318,\n", + " 0.7188, 0.7547, 0.6970, 0.6964, 0.2844, 0.7467, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5419, 0.5204, 0.5258, 0.5244, 0.5248, 0.5247, 0.5292, 0.5209,\n", + " 0.5257, 0.5290, 0.5210, 0.5301, 0.5336, 0.5144, 0.5318, 0.5203, 0.5258,\n", + " 0.5244, 0.5248, 0.5247, 0.5247, 0.5292, 0.5209, 0.5786])\n", + "finalReturns: tensor([1.0049, 1.0578, 1.0266, 0.9367, 0.8051, 0.6438, 0.4563, 0.2614])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 16 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 23, 23, 23, 23, 23, 27, 23, 23, 23, 23, 27, 22, 23, 23, 23, 22, 23,\n", + " 23, 23, 23, 23, 23, 23, 0])\n", + "loss= tensor(4.1050, grad_fn=) , base rewards= tensor([3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591,\n", + " 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 3.5591, 2.9813,\n", + " 2.4879, 2.0498, 1.6550, 1.2904, 0.9477, 0.6211, 0.3062]) return= 131053.19988043512\n", + "probs of actions: tensor([0.7668, 0.7477, 0.7517, 0.7799, 0.7302, 0.7619, 0.0950, 0.7659, 0.7621,\n", + " 0.7609, 0.7681, 0.0614, 0.1864, 0.7542, 0.6877, 0.7610, 0.1592, 0.7650,\n", + " 0.7330, 0.7773, 0.7630, 0.7196, 0.7487, 0.8173, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5419, 0.5204, 0.5258, 0.5244, 0.5248, 0.5047, 0.5400, 0.5209,\n", + " 0.5257, 0.5245, 0.5048, 0.5445, 0.5171, 0.5266, 0.5242, 0.5293, 0.5209,\n", + " 0.5257, 0.5245, 0.5248, 0.5247, 0.5247, 0.5247, 0.5776])\n", + "finalReturns: tensor([1.2177, 1.2661, 1.2387, 1.1511, 1.0214, 0.8613, 0.6793, 0.4812, 0.2714])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([23, 23, 23, 27, 27, 27, 23, 23, 27, 23, 27, 23, 23, 27, 27, 23, 27, 27,\n", + " 27, 27, 27, 23, 23, 22, 0])\n", + "loss= tensor(9.6563, grad_fn=) , base rewards= tensor([3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219,\n", + " 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.7219, 3.1328, 2.6420,\n", + " 2.2066, 1.8260, 1.4805, 1.1610, 0.8602, 0.5731, 0.2854]) return= 130253.95806091337\n", + "probs of actions: tensor([0.5601, 0.5729, 0.5629, 0.4018, 0.3564, 0.3282, 0.4954, 0.5843, 0.4051,\n", + " 0.5535, 0.4352, 0.5639, 0.5251, 0.3924, 0.5742, 0.5398, 0.3543, 0.4443,\n", + " 0.5178, 0.4116, 0.2818, 0.5405, 0.6194, 0.1406, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4583, 0.5419, 0.5204, 0.5058, 0.5197, 0.5162, 0.5371, 0.5216, 0.5055,\n", + " 0.5398, 0.5010, 0.5410, 0.5207, 0.5057, 0.5197, 0.5362, 0.5018, 0.5207,\n", + " 0.5160, 0.5172, 0.5169, 0.5369, 0.5217, 0.5300, 0.5736])\n", + "finalReturns: tensor([1.5490, 1.6019, 1.5909, 1.5056, 1.3702, 1.1986, 1.0012, 0.7650, 0.5304,\n", + " 0.2882])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 23, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 22, 27, 23, 0])\n", + "loss= tensor(5.8675, grad_fn=) , base rewards= tensor([3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.9442,\n", + " 3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.9442, 3.3544, 2.8637, 2.4413,\n", + " 2.0669, 1.7265, 1.4106, 1.1124, 0.8272, 0.5516, 0.2698]) return= 129554.93117643229\n", + "probs of actions: tensor([0.8762, 0.8405, 0.1034, 0.9194, 0.8752, 0.8740, 0.9195, 0.8534, 0.9118,\n", + " 0.8799, 0.9213, 0.8607, 0.8698, 0.9070, 0.9539, 0.9097, 0.9026, 0.9266,\n", + " 0.9496, 0.9206, 0.8964, 0.0236, 0.8098, 0.2168, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5318, 0.5029, 0.5205, 0.5160, 0.5171, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5414, 0.4979, 0.5417, 0.5734])\n", + "finalReturns: tensor([1.8287, 1.9016, 1.8754, 1.7808, 1.6383, 1.4618, 1.2608, 1.0420, 0.7858,\n", + " 0.5636, 0.3035])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.3084, grad_fn=) , base rewards= tensor([4.1841, 4.1841, 4.1841, 4.1841, 4.1841, 4.1841, 4.1841, 4.1841, 4.1841,\n", + " 4.1841, 4.1841, 4.1841, 4.1841, 4.1841, 3.5943, 3.1036, 2.6813, 2.3068,\n", + " 1.9664, 1.6505, 1.3523, 1.0671, 0.7915, 0.5229, 0.2595]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9714, 0.9610, 0.9711, 0.9835, 0.9692, 0.9713, 0.9829, 0.9650, 0.9811,\n", + " 0.9735, 0.9837, 0.9670, 0.9692, 0.9851, 0.9930, 0.9845, 0.9812, 0.9859,\n", + " 0.9918, 0.9852, 0.9800, 0.9791, 0.9566, 0.9344, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([2.0919, 2.1648, 2.1385, 2.0440, 1.9015, 1.7249, 1.5239, 1.3052, 1.0735,\n", + " 0.8322, 0.5839, 0.3303])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0437, grad_fn=) , base rewards= tensor([4.4407, 4.4407, 4.4407, 4.4407, 4.4407, 4.4407, 4.4407, 4.4407, 4.4407,\n", + " 4.4407, 4.4407, 4.4407, 4.4407, 3.8509, 3.3602, 2.9378, 2.5634, 2.2230,\n", + " 1.9071, 1.6089, 1.3237, 1.0481, 0.7795, 0.5161, 0.2566]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9954, 0.9937, 0.9958, 0.9977, 0.9947, 0.9956, 0.9974, 0.9943, 0.9972,\n", + " 0.9960, 0.9976, 0.9947, 0.9961, 0.9984, 0.9995, 0.9984, 0.9975, 0.9986,\n", + " 0.9997, 0.9986, 0.9983, 0.9978, 0.9940, 0.9915, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([2.3522, 2.4251, 2.3989, 2.3043, 2.1618, 1.9853, 1.7843, 1.5655, 1.3338,\n", + " 1.0925, 0.8442, 0.5907, 0.3332])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 67016 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([4.6951, 4.6951, 4.6951, 4.6951, 4.6951, 4.6951, 4.6951, 4.6951, 4.6951,\n", + " 4.6951, 4.6951, 4.6951, 4.1053, 3.6146, 3.1923, 2.8179, 2.4775, 2.1615,\n", + " 1.8634, 1.5782, 1.3025, 1.0339, 0.7705, 0.5110, 0.2544]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9983, 0.9978, 0.9985, 0.9992, 0.9981, 0.9985, 0.9991, 0.9980, 0.9990,\n", + " 0.9986, 0.9991, 0.9990, 0.9989, 0.9997, 1.0000, 0.9998, 0.9992, 0.9999,\n", + " 1.0000, 1.0000, 0.9999, 0.9993, 0.9979, 0.9973, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([2.6147, 2.6876, 2.6614, 2.5668, 2.4243, 2.2478, 2.0468, 1.8280, 1.5963,\n", + " 1.3550, 1.1067, 0.8532, 0.5957, 0.3354])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0165, grad_fn=) , base rewards= tensor([4.9480, 4.9480, 4.9480, 4.9480, 4.9480, 4.9480, 4.9480, 4.9480, 4.9480,\n", + " 4.9480, 4.9480, 4.3581, 3.8674, 3.4451, 3.0707, 2.7303, 2.4144, 2.1162,\n", + " 1.8310, 1.5553, 1.2867, 1.0233, 0.7638, 0.5073, 0.2528]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9983, 0.9978, 0.9985, 0.9992, 0.9981, 0.9985, 0.9991, 0.9980, 0.9990,\n", + " 0.9986, 0.9991, 0.9990, 0.9989, 0.9997, 1.0000, 0.9998, 0.9992, 0.9999,\n", + " 1.0000, 1.0000, 0.9999, 0.9993, 0.9979, 0.9973, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([2.8788, 2.9517, 2.9255, 2.8309, 2.6884, 2.5119, 2.3109, 2.0921, 1.8604,\n", + " 1.6191, 1.3708, 1.1173, 0.8598, 0.5995, 0.3370])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 9 ep 11308 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0184, grad_fn=) , base rewards= tensor([5.1996, 5.1996, 5.1996, 5.1996, 5.1996, 5.1996, 5.1996, 5.1996, 5.1996,\n", + " 5.1996, 4.6098, 4.1191, 3.6967, 3.3223, 2.9819, 2.6660, 2.3678, 2.0826,\n", + " 1.8069, 1.5383, 1.2750, 1.0155, 0.7589, 0.5044, 0.2516]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9984, 0.9979, 0.9986, 0.9992, 0.9982, 0.9985, 0.9991, 0.9981, 0.9990,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9997, 1.0000, 0.9998, 0.9992, 1.0000,\n", + " 1.0000, 1.0000, 0.9999, 0.9994, 0.9980, 0.9975, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.1441, 3.2170, 3.1908, 3.0962, 2.9537, 2.7772, 2.5762, 2.3574, 2.1257,\n", + " 1.8844, 1.6361, 1.3826, 1.1251, 0.8648, 0.6023, 0.3382])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0226, grad_fn=) , base rewards= tensor([5.4503, 5.4503, 5.4503, 5.4503, 5.4503, 5.4503, 5.4503, 5.4503, 5.4503,\n", + " 4.8605, 4.3698, 3.9474, 3.5730, 3.2326, 2.9167, 2.6185, 2.3333, 2.0576,\n", + " 1.7890, 1.5257, 1.2662, 1.0096, 0.7551, 0.5023, 0.2507]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9984, 0.9979, 0.9986, 0.9992, 0.9982, 0.9985, 0.9991, 0.9981, 0.9990,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9997, 1.0000, 0.9998, 0.9992, 1.0000,\n", + " 1.0000, 1.0000, 0.9999, 0.9994, 0.9980, 0.9975, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.4103, 3.4832, 3.4570, 3.3624, 3.2199, 3.0434, 2.8424, 2.6236, 2.3919,\n", + " 2.1506, 1.9023, 1.6488, 1.3914, 1.1310, 0.8685, 0.6044, 0.3391])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 23219 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0149, grad_fn=) , base rewards= tensor([5.7003, 5.7003, 5.7003, 5.7003, 5.7003, 5.7003, 5.7003, 5.7003, 5.1105,\n", + " 4.6198, 4.1974, 3.8230, 3.4826, 3.1667, 2.8685, 2.5833, 2.3077, 2.0391,\n", + " 1.7757, 1.5162, 1.2596, 1.0052, 0.7523, 0.5007, 0.2500]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9988, 0.9983, 0.9990, 0.9994, 0.9986, 0.9989, 0.9993, 0.9990, 1.0000,\n", + " 0.9993, 0.9995, 0.9994, 0.9998, 0.9998, 1.0000, 1.0000, 0.9996, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9996, 0.9986, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.6772, 3.7501, 3.7239, 3.6293, 3.4868, 3.3103, 3.1093, 2.8905, 2.6588,\n", + " 2.4175, 2.1692, 1.9157, 1.6582, 1.3979, 1.1354, 0.8713, 0.6060, 0.3398])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0181, grad_fn=) , base rewards= tensor([5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.3600, 4.8693,\n", + " 4.4470, 4.0725, 3.7322, 3.4162, 3.1181, 2.8329, 2.5572, 2.2886, 2.0252,\n", + " 1.7657, 1.5091, 1.2547, 1.0019, 0.7503, 0.4996, 0.2495]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9988, 0.9983, 0.9990, 0.9994, 0.9986, 0.9989, 0.9993, 0.9990, 1.0000,\n", + " 0.9993, 0.9995, 0.9994, 0.9998, 0.9998, 1.0000, 1.0000, 0.9996, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9996, 0.9986, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.9446, 4.0175, 3.9913, 3.8967, 3.7542, 3.5777, 3.3767, 3.1579, 2.9262,\n", + " 2.6849, 2.4366, 2.1831, 1.9257, 1.6653, 1.4028, 1.1387, 0.8734, 0.6072,\n", + " 0.3403])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 63 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0223, grad_fn=) , base rewards= tensor([6.1990, 6.1990, 6.1990, 6.1990, 6.1990, 6.1990, 5.6091, 5.1185, 4.6961,\n", + " 4.3217, 3.9813, 3.6654, 3.3672, 3.0820, 2.8063, 2.5377, 2.2744, 2.0149,\n", + " 1.7583, 1.5038, 1.2510, 0.9994, 0.7487, 0.4987, 0.2491]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9988, 0.9984, 0.9990, 0.9994, 0.9986, 0.9990, 0.9994, 0.9990, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9996, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9996, 0.9986, 0.9985, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.2124, 4.2853, 4.2591, 4.1645, 4.0220, 3.8455, 3.6445, 3.4257, 3.1940,\n", + " 2.9527, 2.7044, 2.4509, 2.1934, 1.9331, 1.6706, 1.4065, 1.1412, 0.8750,\n", + " 0.6081, 0.3407])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 250 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0241, grad_fn=) , base rewards= tensor([6.4476, 6.4476, 6.4476, 6.4476, 6.4476, 5.8581, 5.3673, 4.9450, 4.5705,\n", + " 4.2302, 3.9142, 3.6161, 3.3309, 3.0552, 2.7866, 2.5232, 2.2637, 2.0071,\n", + " 1.7527, 1.4999, 1.2483, 0.9976, 0.7475, 0.4980, 0.2489]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9989, 0.9985, 0.9991, 0.9995, 0.9990, 0.9993, 0.9996, 0.9991, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9997, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9997, 0.9987, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.4805, 4.5534, 4.5271, 4.4326, 4.2901, 4.1135, 3.9125, 3.6938, 3.4621,\n", + " 3.2208, 2.9725, 2.7189, 2.4615, 2.2012, 1.9387, 1.6746, 1.4093, 1.1430,\n", + " 0.8761, 0.6087, 0.3410])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0272, grad_fn=) , base rewards= tensor([6.6975, 6.6975, 6.6975, 6.6975, 6.1064, 5.6160, 5.1936, 4.8192, 4.4788,\n", + " 4.1629, 3.8647, 3.5795, 3.3038, 3.0352, 2.7719, 2.5124, 2.2558, 2.0013,\n", + " 1.7485, 1.4969, 1.2462, 0.9962, 0.7466, 0.4975, 0.2486]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9989, 0.9985, 0.9991, 0.9995, 0.9990, 0.9993, 0.9996, 0.9991, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9997, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9997, 0.9987, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.7487, 4.8216, 4.7954, 4.7008, 4.5583, 4.3818, 4.1808, 3.9621, 3.7303,\n", + " 3.4891, 3.2408, 2.9872, 2.7298, 2.4694, 2.2070, 1.9429, 1.6775, 1.4113,\n", + " 1.1444, 0.8770, 0.6092, 0.3412])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0326, grad_fn=) , base rewards= tensor([6.9408, 6.9408, 6.9408, 6.3561, 5.8642, 5.4422, 5.0677, 4.7273, 4.4114,\n", + " 4.1132, 3.8280, 3.5523, 3.2837, 3.0203, 2.7608, 2.5042, 2.2498, 1.9970,\n", + " 1.7454, 1.4947, 1.2447, 0.9951, 0.7460, 0.4971, 0.2485]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9989, 0.9985, 0.9991, 0.9995, 0.9990, 0.9993, 0.9996, 0.9991, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9997, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9997, 0.9987, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.0173, 5.0902, 5.0638, 4.9693, 4.8268, 4.6503, 4.4493, 4.2305, 3.9988,\n", + " 3.7575, 3.5092, 3.2557, 2.9982, 2.7379, 2.4754, 2.2113, 1.9460, 1.6798,\n", + " 1.4129, 1.1455, 0.8777, 0.6096, 0.3413])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 1 ep 594 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0351, grad_fn=) , base rewards= tensor([7.2101, 7.2101, 6.5997, 6.1137, 5.6903, 5.3161, 4.9756, 4.6597, 4.3615,\n", + " 4.0763, 3.8007, 3.5321, 3.2687, 3.0092, 2.7526, 2.4982, 2.2454, 1.9938,\n", + " 1.7430, 1.4930, 1.2435, 0.9943, 0.7455, 0.4968, 0.2484]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9989, 0.9990, 0.9994, 0.9997, 0.9990, 0.9994, 0.9996, 0.9991, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9997, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9997, 0.9987, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.2854, 5.3583, 5.3326, 5.2378, 5.0954, 4.9188, 4.7178, 4.4991, 4.2673,\n", + " 4.0261, 3.7778, 3.5242, 3.2668, 3.0064, 2.7440, 2.4799, 2.2145, 1.9483,\n", + " 1.6814, 1.4140, 1.1462, 0.8782, 0.6099, 0.3415])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 69 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0403, grad_fn=) , base rewards= tensor([7.3783, 6.8670, 6.3576, 5.9396, 5.5641, 5.2240, 4.9080, 4.6098, 4.3246,\n", + " 4.0490, 3.7804, 3.5170, 3.2575, 3.0009, 2.7465, 2.4936, 2.2420, 1.9913,\n", + " 1.7413, 1.4918, 1.2426, 0.9938, 0.7451, 0.4966, 0.2483]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9994, 0.9997, 0.9991, 0.9994, 0.9997, 0.9991, 1.0000,\n", + " 0.9994, 0.9995, 0.9995, 0.9998, 0.9998, 1.0000, 1.0000, 0.9997, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 0.9997, 0.9987, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.5556, 5.6285, 5.6005, 5.5067, 5.3639, 5.1875, 4.9865, 4.7677, 4.5360,\n", + " 4.2947, 4.0464, 3.7929, 3.5354, 3.2751, 3.0126, 2.7485, 2.4832, 2.2170,\n", + " 1.9501, 1.6827, 1.4149, 1.1468, 0.8786, 0.6101, 0.3416])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682835632 saved\n", + "[1662531, 'tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.])', 129338.69866666665, 75332.17066666666, 0.04029531031847, 1e-05, 1, 0, 'tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\\n 27, 27, 27, 27, 27, 27, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682835632', 25, 50, 172677.5835126837, 219861.0138117109, 91603.02777699233, 132330.31466666664, 129338.69866666666, 72150.91909080048, 72150.91909080048, 88030.91902269641, 88030.91902269641, 105848.51071772553, 72121.02259730823, 87961.7660416823]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 4, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107,\n", + " 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107,\n", + " 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107, 0.5107]) return= 127695.93011642047\n", + "probs of actions: tensor([0.0087, 0.9502, 0.0086, 0.9312, 0.9305, 0.9451, 0.9223, 0.9450, 0.9302,\n", + " 0.9339, 0.9603, 0.9469, 0.9478, 0.9461, 0.9511, 0.9430, 0.0276, 0.9222,\n", + " 0.9427, 0.9465, 0.9359, 0.0034, 0.9471, 0.9232, 0.9943],\n", + " grad_fn=)\n", + "rewards: tensor([0.5108, 0.5166, 0.5077, 0.5174, 0.5079, 0.5103, 0.5097, 0.5098, 0.5098,\n", + " 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5097, 0.5134,\n", + " 0.5089, 0.5100, 0.5097, 0.5082, 0.5242, 0.5062, 0.5107])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 0, 18, 6, 0, 0, 1, 0, 0, 0, 0, 18, 0, 0, 0, 18,\n", + " 18, 0, 0, 18, 0, 18, 0])\n", + "loss= tensor(0.0075, grad_fn=) , base rewards= tensor([1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078,\n", + " 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078,\n", + " 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 1.0078, 0.5138]) return= 129636.67739657205\n", + "probs of actions: tensor([0.3905, 0.2322, 0.2606, 0.3254, 0.3457, 0.0249, 0.3994, 0.4527, 0.0195,\n", + " 0.5938, 0.7716, 0.4525, 0.6561, 0.3951, 0.5880, 0.6364, 0.4128, 0.3614,\n", + " 0.4197, 0.4487, 0.4621, 0.3929, 0.5632, 0.8044, 0.9996],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5633, 0.4644, 0.5760, 0.5143, 0.5087, 0.5100,\n", + " 0.5133, 0.5089, 0.5100, 0.5097, 0.4774, 0.5761, 0.4939, 0.5138, 0.4764,\n", + " 0.5439, 0.5591, 0.4978, 0.4804, 0.5753, 0.4616, 0.5803])\n", + "finalReturns: tensor([0.0341, 0.0665])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 16, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102,\n", + " 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 1.5102,\n", + " 1.5102, 1.5102, 1.5102, 1.5102, 1.5102, 0.9476, 0.4506]) return= 132450.34798175492\n", + "probs of actions: tensor([0.9696, 0.9712, 0.9630, 0.9755, 0.9730, 0.9697, 0.9775, 0.9711, 0.9708,\n", + " 0.9457, 0.9814, 0.9735, 0.9778, 0.9767, 0.9721, 0.9678, 0.9664, 0.9676,\n", + " 0.0071, 0.9770, 0.9657, 0.9756, 0.9838, 0.9828, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5369, 0.5226, 0.5320, 0.5296, 0.5302, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.1126, 0.1450, 0.1119])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0026, grad_fn=) , base rewards= tensor([1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273,\n", + " 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273, 1.9273,\n", + " 1.9273, 1.9273, 1.9273, 1.9273, 1.3648, 0.8678, 0.4172]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9932, 0.9936, 0.9917, 0.9944, 0.9938, 0.9933, 0.9947, 0.9937, 0.9934,\n", + " 0.9874, 0.9960, 0.9942, 0.9954, 0.9948, 0.9939, 0.9928, 0.9918, 0.9923,\n", + " 0.9933, 0.9947, 0.9919, 0.9962, 0.9969, 0.9958, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.2255, 0.2579, 0.2248, 0.1453])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 81988 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204,\n", + " 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204, 2.3204,\n", + " 2.3204, 2.3204, 2.3204, 1.7579, 1.2609, 0.8103, 0.3931]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9987, 0.9987, 0.9984, 0.9988, 0.9987, 0.9986, 0.9989, 0.9988, 0.9986,\n", + " 0.9973, 0.9993, 0.9988, 0.9991, 0.9989, 0.9988, 0.9986, 0.9981, 0.9983,\n", + " 0.9986, 0.9989, 0.9990, 0.9992, 0.9999, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.3625, 0.3949, 0.3618, 0.2823, 0.1694])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 19 ep 56 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0018, grad_fn=) , base rewards= tensor([2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958,\n", + " 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958, 2.6958,\n", + " 2.6958, 2.6958, 2.1333, 1.6363, 1.1857, 0.7685, 0.3754]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9986, 0.9987, 0.9983, 0.9988, 0.9986, 0.9985, 0.9988, 0.9987, 0.9986,\n", + " 0.9973, 0.9992, 0.9988, 0.9991, 0.9989, 0.9988, 0.9986, 0.9981, 0.9983,\n", + " 0.9985, 0.9990, 0.9990, 0.9992, 0.9999, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.5172, 0.5496, 0.5165, 0.4370, 0.3241, 0.1871])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 344 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0027, grad_fn=) , base rewards= tensor([3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583,\n", + " 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583, 3.0583,\n", + " 3.0583, 2.4958, 1.9987, 1.5482, 1.1309, 0.7379, 0.3624]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9987, 0.9987, 0.9984, 0.9988, 0.9987, 0.9986, 0.9989, 0.9988, 0.9986,\n", + " 0.9974, 0.9993, 0.9988, 0.9992, 0.9989, 0.9988, 0.9987, 0.9982, 0.9984,\n", + " 0.9990, 0.9993, 0.9990, 0.9993, 0.9999, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.6848, 0.7172, 0.6842, 0.6046, 0.4918, 0.3547, 0.2001])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 653 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0039, grad_fn=) , base rewards= tensor([3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111,\n", + " 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111, 3.4111,\n", + " 2.8486, 2.3516, 1.9010, 1.4838, 1.0907, 0.7153, 0.3529]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9987, 0.9988, 0.9985, 0.9988, 0.9987, 0.9986, 0.9989, 0.9988, 0.9986,\n", + " 0.9974, 0.9993, 0.9988, 0.9992, 0.9989, 0.9988, 0.9987, 0.9982, 0.9990,\n", + " 0.9991, 0.9994, 0.9990, 0.9993, 0.9999, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([0.8621, 0.8945, 0.8614, 0.7819, 0.6690, 0.5320, 0.3773, 0.2096])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 23347 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0031, grad_fn=) , base rewards= tensor([3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569,\n", + " 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.7569, 3.1944,\n", + " 2.6974, 2.2468, 1.8296, 1.4365, 1.0611, 0.6986, 0.3458]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([1.0464, 1.0788, 1.0457, 0.9662, 0.8533, 0.7163, 0.5616, 0.3940, 0.2167])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974,\n", + " 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 4.0974, 3.5349, 3.0379,\n", + " 2.5873, 2.1701, 1.7770, 1.4016, 1.0391, 0.6863, 0.3405]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([1.2360, 1.2684, 1.2353, 1.1558, 1.0429, 0.9059, 0.7512, 0.5836, 0.4063,\n", + " 0.2220])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0059, grad_fn=) , base rewards= tensor([4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 4.4340,\n", + " 4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 4.4340, 3.8715, 3.3744, 2.9239,\n", + " 2.5066, 2.1136, 1.7381, 1.3757, 1.0228, 0.6770, 0.3366]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([1.4295, 1.4619, 1.4289, 1.3493, 1.2365, 1.0994, 0.9448, 0.7771, 0.5999,\n", + " 0.4156, 0.2259])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0074, grad_fn=) , base rewards= tensor([4.7676, 4.7676, 4.7676, 4.7676, 4.7676, 4.7676, 4.7676, 4.7676, 4.7676,\n", + " 4.7676, 4.7676, 4.7676, 4.7676, 4.7676, 4.2051, 3.7081, 3.2575, 2.8402,\n", + " 2.4472, 2.0718, 1.7093, 1.3564, 1.0107, 0.6702, 0.3336]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([1.6260, 1.6584, 1.6253, 1.5458, 1.4330, 1.2959, 1.1412, 0.9736, 0.7964,\n", + " 0.6120, 0.4224, 0.2289])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0088, grad_fn=) , base rewards= tensor([5.0990, 5.0990, 5.0990, 5.0990, 5.0990, 5.0990, 5.0990, 5.0990, 5.0990,\n", + " 5.0990, 5.0990, 5.0990, 5.0990, 4.5365, 4.0395, 3.5889, 3.1717, 2.7786,\n", + " 2.4032, 2.0407, 1.6879, 1.3421, 1.0016, 0.6651, 0.3314]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([1.8247, 1.8571, 1.8240, 1.7445, 1.6316, 1.4946, 1.3399, 1.1723, 0.9950,\n", + " 0.8107, 0.6211, 0.4275, 0.2311])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0107, grad_fn=) , base rewards= tensor([5.4288, 5.4288, 5.4288, 5.4288, 5.4288, 5.4288, 5.4288, 5.4288, 5.4288,\n", + " 5.4288, 5.4288, 5.4288, 4.8663, 4.3693, 3.9187, 3.5015, 3.1084, 2.7330,\n", + " 2.3705, 2.0177, 1.6719, 1.3314, 0.9949, 0.6612, 0.3298]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([2.0250, 2.0574, 2.0243, 1.9448, 1.8319, 1.6949, 1.5402, 1.3726, 1.1953,\n", + " 1.0110, 0.8214, 0.6278, 0.4314, 0.2327])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 10 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0121, grad_fn=) , base rewards= tensor([5.7574, 5.7574, 5.7574, 5.7574, 5.7574, 5.7574, 5.7574, 5.7574, 5.7574,\n", + " 5.7574, 5.7574, 5.1949, 4.6979, 4.2473, 3.8300, 3.4370, 3.0615, 2.6991,\n", + " 2.3462, 2.0005, 1.6600, 1.3234, 0.9898, 0.6584, 0.3286]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9992, 0.9993, 0.9991, 0.9993, 0.9992, 0.9991, 0.9993, 0.9993, 0.9992,\n", + " 0.9985, 0.9996, 0.9993, 0.9995, 0.9994, 0.9993, 0.9992, 0.9990, 0.9996,\n", + " 0.9995, 0.9997, 0.9995, 0.9998, 1.0000, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([2.2265, 2.2589, 2.2258, 2.1463, 2.0335, 1.8964, 1.7418, 1.5741, 1.3969,\n", + " 1.2125, 1.0229, 0.8294, 0.6329, 0.4342, 0.2339])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 207 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0116, grad_fn=) , base rewards= tensor([6.0850, 6.0850, 6.0850, 6.0850, 6.0850, 6.0850, 6.0850, 6.0850, 6.0850,\n", + " 6.0850, 5.5225, 5.0255, 4.5749, 4.1577, 3.7646, 3.3892, 3.0267, 2.6739,\n", + " 2.3281, 1.9876, 1.6511, 1.3174, 0.9860, 0.6562, 0.3276]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([2.4290, 2.4614, 2.4283, 2.3488, 2.2359, 2.0989, 1.9442, 1.7766, 1.5993,\n", + " 1.4150, 1.2254, 1.0318, 0.8354, 0.6367, 0.4364, 0.2349])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0139, grad_fn=) , base rewards= tensor([6.4120, 6.4120, 6.4120, 6.4120, 6.4120, 6.4120, 6.4120, 6.4120, 6.4120,\n", + " 5.8495, 5.3525, 4.9019, 4.4846, 4.0916, 3.7162, 3.3537, 3.0008, 2.6551,\n", + " 2.3146, 1.9780, 1.6444, 1.3130, 0.9832, 0.6546, 0.3270]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([2.6321, 2.6645, 2.6314, 2.5519, 2.4391, 2.3020, 2.1473, 1.9797, 1.8025,\n", + " 1.6181, 1.4285, 1.2350, 1.0385, 0.8398, 0.6395, 0.4380, 0.2355])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0161, grad_fn=) , base rewards= tensor([6.7384, 6.7384, 6.7384, 6.7384, 6.7384, 6.7384, 6.7384, 6.7384, 6.1759,\n", + " 5.6789, 5.2283, 4.8111, 4.4180, 4.0426, 3.6802, 3.3273, 2.9815, 2.6410,\n", + " 2.3045, 1.9708, 1.6394, 1.3096, 0.9811, 0.6534, 0.3264]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([2.8358, 2.8682, 2.8351, 2.7556, 2.6427, 2.5057, 2.3510, 2.1833, 2.0061,\n", + " 1.8218, 1.6322, 1.4386, 1.2422, 1.0435, 0.8432, 0.6416, 0.4392, 0.2361])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0183, grad_fn=) , base rewards= tensor([7.0645, 7.0645, 7.0645, 7.0645, 7.0645, 7.0645, 7.0645, 6.5020, 6.0050,\n", + " 5.5544, 5.1371, 4.7441, 4.3687, 4.0062, 3.6533, 3.3076, 2.9671, 2.6305,\n", + " 2.2969, 1.9655, 1.6357, 1.3071, 0.9795, 0.6525, 0.3261]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([3.0398, 3.0722, 3.0391, 2.9596, 2.8467, 2.7097, 2.5550, 2.3874, 2.2102,\n", + " 2.0258, 1.8362, 1.6427, 1.4462, 1.2475, 1.0472, 0.8457, 0.6432, 0.4401,\n", + " 0.2364])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0212, grad_fn=) , base rewards= tensor([7.3903, 7.3903, 7.3903, 7.3903, 7.3903, 7.3903, 6.8277, 6.3307, 5.8802,\n", + " 5.4629, 5.0698, 4.6944, 4.3320, 3.9791, 3.6333, 3.2929, 2.9563, 2.6227,\n", + " 2.2912, 1.9614, 1.6329, 1.3052, 0.9783, 0.6518, 0.3258]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([3.2441, 3.2765, 3.2435, 3.1639, 3.0511, 2.9141, 2.7594, 2.5917, 2.4145,\n", + " 2.2302, 2.0405, 1.8470, 1.6505, 1.4519, 1.2516, 1.0500, 0.8476, 0.6444,\n", + " 0.4408, 0.2367])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0241, grad_fn=) , base rewards= tensor([7.7156, 7.7156, 7.7156, 7.7156, 7.7156, 7.1533, 6.6563, 6.2057, 5.7885,\n", + " 5.3954, 5.0200, 4.6575, 4.3047, 3.9589, 3.6184, 3.2818, 2.9482, 2.6168,\n", + " 2.2870, 1.9584, 1.6308, 1.3038, 0.9774, 0.6513, 0.3256]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([3.4487, 3.4811, 3.4480, 3.3685, 3.2556, 3.1186, 2.9639, 2.7963, 2.6190,\n", + " 2.4347, 2.2451, 2.0516, 1.8551, 1.6564, 1.4561, 1.2546, 1.0521, 0.8490,\n", + " 0.6453, 0.4413, 0.2369])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: AdversaryModes.imitation_128\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0268, grad_fn=) , base rewards= tensor([8.0419, 8.0419, 8.0419, 8.0419, 7.4785, 6.9817, 6.5311, 6.1139, 5.7208,\n", + " 5.3454, 4.9829, 4.6301, 4.2843, 3.9438, 3.6072, 3.2736, 2.9422, 2.6124,\n", + " 2.2838, 1.9562, 1.6292, 1.3028, 0.9767, 0.6509, 0.3254]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([3.6534, 3.6858, 3.6527, 3.5732, 3.4603, 3.3233, 3.1686, 3.0010, 2.8237,\n", + " 2.6394, 2.4498, 2.2563, 2.0598, 1.8611, 1.6608, 1.4593, 1.2568, 1.0537,\n", + " 0.8500, 0.6460, 0.4417, 0.2371])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0304, grad_fn=) , base rewards= tensor([8.3638, 8.3638, 8.3638, 7.8046, 7.3068, 6.8564, 6.4391, 6.0461, 5.6706,\n", + " 5.3082, 4.9553, 4.6095, 4.2691, 3.9325, 3.5989, 3.2674, 2.9377, 2.6091,\n", + " 2.2814, 1.9545, 1.6280, 1.3020, 0.9762, 0.6507, 0.3253]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([3.8583, 3.8907, 3.8575, 3.7780, 3.6652, 3.5281, 3.3735, 3.2058, 3.0286,\n", + " 2.8442, 2.6546, 2.4611, 2.2646, 2.0660, 1.8656, 1.6641, 1.4617, 1.2585,\n", + " 1.0549, 0.8508, 0.6465, 0.4419, 0.2372])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0335, grad_fn=) , base rewards= tensor([8.7023, 8.7023, 8.1266, 7.6327, 7.1814, 6.7643, 6.3712, 5.9958, 5.6334,\n", + " 5.2805, 4.9347, 4.5942, 4.2577, 3.9241, 3.5926, 3.2628, 2.9343, 2.6066,\n", + " 2.2797, 1.9532, 1.6271, 1.3014, 0.9758, 0.6504, 0.3252]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9995, 0.9997, 0.9996, 0.9995, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([4.0630, 4.0954, 4.0626, 3.9829, 3.8701, 3.7331, 3.5784, 3.4107, 3.2335,\n", + " 3.0492, 2.8596, 2.6660, 2.4695, 2.2709, 2.0706, 1.8690, 1.6666, 1.4634,\n", + " 1.2598, 1.0558, 0.8514, 0.6469, 0.4422, 0.2373])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0369, grad_fn=) , base rewards= tensor([8.9755, 8.4643, 7.9549, 7.5072, 7.0893, 6.6964, 6.3209, 5.9585, 5.6056,\n", + " 5.2598, 4.9193, 4.5828, 4.2492, 3.9177, 3.5879, 3.2594, 2.9317, 2.6048,\n", + " 2.2783, 1.9523, 1.6265, 1.3009, 0.9755, 0.6503, 0.3251]) return= 132442.06666666665\n", + "probs of actions: tensor([0.9993, 0.9994, 0.9992, 0.9994, 0.9993, 0.9993, 0.9994, 0.9994, 0.9993,\n", + " 0.9990, 0.9997, 0.9996, 0.9997, 0.9996, 0.9996, 0.9995, 0.9991, 0.9996,\n", + " 0.9996, 0.9997, 0.9996, 0.9998, 1.0000, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5433, 0.5268, 0.5309, 0.5299, 0.5302, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301,\n", + " 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5301, 0.5625])\n", + "finalReturns: tensor([4.2687, 4.3011, 4.2672, 4.1880, 4.0751, 3.9381, 3.7834, 3.6157, 3.4385,\n", + " 3.2542, 3.0646, 2.8710, 2.6745, 2.4759, 2.2756, 2.0740, 1.8716, 1.6684,\n", + " 1.4648, 1.2607, 1.0564, 0.8519, 0.6472, 0.4423, 0.2374])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682849652 saved\n", + "[586616, 'tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.])', 132442.06666666665, 85788.46666666665, 0.036905523389577866, 1e-05, 1, 0, 'tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\\n 18, 18, 18, 18, 18, 18, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682849652', 25, 50, 164645.8985006173, 193521.60851536895, 78111.91688437786, 135363.21866666665, 132442.06666666665, 102604.52812037412, 102604.52812037412, 120699.79187222247, 120699.79187222247, 90646.446578478, 102630.27987904308, 120699.79187222247]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098,\n", + " 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098,\n", + " 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098]) return= 127541.45169466147\n", + "probs of actions: tensor([0.8878, 0.8998, 0.9017, 0.0455, 0.8904, 0.8897, 0.8844, 0.9010, 0.9006,\n", + " 0.9017, 0.8732, 0.9087, 0.8745, 0.8932, 0.8736, 0.9308, 0.8922, 0.0170,\n", + " 0.8716, 0.8762, 0.8754, 0.8779, 0.8982, 0.9095, 0.9904],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5094, 0.5099, 0.5097, 0.5134, 0.5089, 0.5100, 0.5097, 0.5098,\n", + " 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5098, 0.5094,\n", + " 0.5170, 0.5080, 0.5102, 0.5097, 0.5098, 0.5098, 0.5098])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([ 0, 16, 0, 10, 3, 17, 1, 19, 1, 0, 1, 19, 1, 0, 0, 0, 1, 1,\n", + " 0, 19, 0, 19, 0, 25, 0])\n", + "loss= tensor(0.1094, grad_fn=) , base rewards= tensor([1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062,\n", + " 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062,\n", + " 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 1.0062, 0.5143]) return= 129474.82480479611\n", + "probs of actions: tensor([0.3228, 0.0171, 0.2714, 0.0419, 0.0283, 0.0064, 0.0947, 0.2192, 0.0974,\n", + " 0.4085, 0.0975, 0.1958, 0.0921, 0.3377, 0.2460, 0.5109, 0.0855, 0.0916,\n", + " 0.2574, 0.2246, 0.2617, 0.2131, 0.3345, 0.0302, 0.9922],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4838, 0.5686, 0.4856, 0.5489, 0.4818, 0.5720, 0.4622, 0.5829,\n", + " 0.4958, 0.5132, 0.4764, 0.5791, 0.4967, 0.5131, 0.5090, 0.5099, 0.5132,\n", + " 0.5125, 0.4730, 0.5801, 0.4568, 0.5844, 0.4294, 0.6079])\n", + "finalReturns: tensor([0.0311, 0.0936])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([19, 19, 19, 19, 19, 20, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0571, grad_fn=) , base rewards= tensor([1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092,\n", + " 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 1.5092,\n", + " 1.5092, 1.5092, 1.5092, 1.5092, 1.5092, 0.9437, 0.4474]) return= 132272.56485156258\n", + "probs of actions: tensor([0.8868, 0.8613, 0.8450, 0.8907, 0.8717, 0.0441, 0.8733, 0.8735, 0.9006,\n", + " 0.8514, 0.8717, 0.8657, 0.8498, 0.8412, 0.8213, 0.8708, 0.8853, 0.8783,\n", + " 0.8333, 0.8497, 0.8522, 0.8566, 0.9069, 0.7395, 0.9979],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5434, 0.5259, 0.5303, 0.5292, 0.5256, 0.5332, 0.5285, 0.5296,\n", + " 0.5293, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294,\n", + " 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5655])\n", + "finalReturns: tensor([0.1151, 0.1512, 0.1181])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 20, 0])\n", + "loss= tensor(0.5379, grad_fn=) , base rewards= tensor([1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216,\n", + " 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216, 1.9216,\n", + " 1.9216, 1.9216, 1.9216, 1.9216, 1.3561, 0.8598, 0.4124]) return= 132280.08116666667\n", + "probs of actions: tensor([0.9403, 0.9196, 0.9068, 0.9415, 0.9396, 0.9242, 0.9294, 0.9377, 0.9528,\n", + " 0.9275, 0.9298, 0.9316, 0.9182, 0.9129, 0.8965, 0.9457, 0.9382, 0.9369,\n", + " 0.9005, 0.9167, 0.9171, 0.9177, 0.9507, 0.1169, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5434, 0.5259, 0.5303, 0.5292, 0.5295, 0.5294, 0.5294, 0.5294,\n", + " 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5294,\n", + " 0.5294, 0.5294, 0.5294, 0.5294, 0.5294, 0.5255, 0.5693])\n", + "finalReturns: tensor([0.2320, 0.2681, 0.2350, 0.1569])\n", + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([19, 20, 19, 19, 19, 19, 19, 20, 19, 19, 19, 19, 19, 19, 19, 19, 20, 19,\n", + " 19, 19, 19, 20, 19, 19, 0])\n", + "loss= tensor(1.0797, grad_fn=) , base rewards= tensor([2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038,\n", + " 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038, 2.3038,\n", + " 2.3038, 2.3038, 2.3038, 1.7384, 1.2420, 0.7946, 0.3855]) return= 132246.351396498\n", + "probs of actions: tensor([0.8866, 0.1261, 0.8280, 0.8925, 0.8865, 0.8621, 0.8719, 0.0946, 0.9101,\n", + " 0.8700, 0.8727, 0.8724, 0.8557, 0.8425, 0.8268, 0.8876, 0.0950, 0.8847,\n", + " 0.8229, 0.8516, 0.8295, 0.1281, 0.9126, 0.6660, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5395, 0.5297, 0.5293, 0.5294, 0.5294, 0.5294, 0.5255, 0.5332,\n", + " 0.5285, 0.5296, 0.5293, 0.5294, 0.5294, 0.5294, 0.5294, 0.5255, 0.5332,\n", + " 0.5285, 0.5296, 0.5293, 0.5255, 0.5332, 0.5285, 0.5657])\n", + "finalReturns: tensor([0.3784, 0.4145, 0.3853, 0.2996, 0.1803])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([19, 19, 19, 25, 20, 19, 20, 19, 19, 19, 19, 19, 23, 19, 20, 19, 20, 20,\n", + " 19, 20, 20, 19, 19, 19, 0])\n", + "loss= tensor(2.0426, grad_fn=) , base rewards= tensor([2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633,\n", + " 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633, 2.6633,\n", + " 2.6633, 2.6633, 2.0985, 1.6020, 1.1580, 0.7504, 0.3663]) return= 132091.35601931607\n", + "probs of actions: tensor([0.7048, 0.6305, 0.5994, 0.0062, 0.2655, 0.6701, 0.2830, 0.6955, 0.7536,\n", + " 0.6773, 0.6796, 0.6751, 0.0043, 0.6330, 0.3343, 0.6932, 0.2750, 0.2573,\n", + " 0.5974, 0.3659, 0.3144, 0.5819, 0.7250, 0.3477, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5434, 0.5259, 0.5039, 0.5481, 0.5276, 0.5260, 0.5331, 0.5285,\n", + " 0.5296, 0.5293, 0.5294, 0.5126, 0.5445, 0.5218, 0.5341, 0.5243, 0.5296,\n", + " 0.5322, 0.5248, 0.5294, 0.5322, 0.5287, 0.5296, 0.5655])\n", + "finalReturns: tensor([0.5469, 0.5869, 0.5539, 0.4658, 0.3446, 0.1992])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([20, 20, 20, 20, 19, 20, 20, 20, 20, 20, 20, 20, 19, 19, 20, 20, 19, 19,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.9034, grad_fn=) , base rewards= tensor([3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040,\n", + " 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040, 3.0040,\n", + " 3.0040, 2.4383, 1.9420, 1.4980, 1.0904, 0.7094, 0.3476]) return= 132119.19007904181\n", + "probs of actions: tensor([0.6944, 0.7625, 0.7787, 0.6775, 0.2659, 0.7191, 0.7076, 0.7213, 0.6555,\n", + " 0.7170, 0.7109, 0.7317, 0.2381, 0.2190, 0.7402, 0.7420, 0.2519, 0.2741,\n", + " 0.8336, 0.8034, 0.7274, 0.7529, 0.7599, 0.9213, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5433, 0.5248, 0.5294, 0.5322, 0.5248, 0.5294, 0.5283, 0.5286,\n", + " 0.5285, 0.5285, 0.5285, 0.5324, 0.5287, 0.5257, 0.5292, 0.5322, 0.5287,\n", + " 0.5257, 0.5292, 0.5283, 0.5286, 0.5285, 0.5285, 0.5685])\n", + "finalReturns: tensor([0.7334, 0.7734, 0.7404, 0.6561, 0.5351, 0.3877, 0.2209])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([20, 20, 20, 20, 20, 21, 20, 19, 25, 19, 19, 19, 19, 21, 20, 20, 20, 19,\n", + " 20, 20, 19, 20, 19, 20, 0])\n", + "loss= tensor(4.4889, grad_fn=) , base rewards= tensor([3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606,\n", + " 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606, 3.3606,\n", + " 2.7921, 2.2965, 1.8489, 1.4398, 1.0574, 0.6917, 0.3419]) return= 132054.13451253538\n", + "probs of actions: tensor([0.6917, 0.7543, 0.7701, 0.6788, 0.7036, 0.0511, 0.7061, 0.2013, 0.0152,\n", + " 0.2061, 0.2140, 0.1935, 0.1996, 0.0562, 0.7250, 0.7468, 0.7122, 0.2247,\n", + " 0.7869, 0.8139, 0.1817, 0.7292, 0.1659, 0.9044, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5433, 0.5248, 0.5294, 0.5283, 0.5245, 0.5323, 0.5315, 0.5025,\n", + " 0.5523, 0.5237, 0.5308, 0.5290, 0.5215, 0.5330, 0.5274, 0.5288, 0.5323,\n", + " 0.5248, 0.5295, 0.5322, 0.5248, 0.5333, 0.5245, 0.5695])\n", + "finalReturns: tensor([0.9104, 0.9465, 0.9173, 0.8354, 0.7124, 0.5700, 0.4023, 0.2276])\n", + "----------------------------------------\n", + "iter 2 stage 16 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([19, 20, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 23, 20, 25, 20, 20, 21,\n", + " 20, 20, 27, 21, 20, 20, 0])\n", + "loss= tensor(10.3548, grad_fn=) , base rewards= tensor([3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175,\n", + " 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.6175, 3.0539,\n", + " 2.5571, 2.1132, 1.7088, 1.3293, 0.9688, 0.6424, 0.3189]) return= 131844.90001474044\n", + "probs of actions: tensor([0.1382, 0.7796, 0.0968, 0.7182, 0.7469, 0.7440, 0.7399, 0.7577, 0.7211,\n", + " 0.7426, 0.7502, 0.7602, 0.0066, 0.7539, 0.0349, 0.7833, 0.7792, 0.0772,\n", + " 0.7695, 0.8051, 0.0124, 0.0893, 0.8103, 0.9007, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5395, 0.5297, 0.5254, 0.5293, 0.5283, 0.5286, 0.5285, 0.5285,\n", + " 0.5285, 0.5285, 0.5285, 0.5156, 0.5399, 0.5032, 0.5482, 0.5236, 0.5256,\n", + " 0.5320, 0.5277, 0.4958, 0.5511, 0.5257, 0.5292, 0.5683])\n", + "finalReturns: tensor([1.1615, 1.2015, 1.1727, 1.0846, 0.9614, 0.8450, 0.6544, 0.4551, 0.2495])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([20, 20, 20, 20, 27, 20, 20, 21, 19, 20, 20, 20, 21, 20, 19, 25, 20, 20,\n", + " 20, 20, 20, 20, 25, 20, 0])\n", + "loss= tensor(7.6280, grad_fn=) , base rewards= tensor([3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346,\n", + " 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.9346, 3.3696, 2.8732,\n", + " 2.4457, 2.0460, 1.6717, 1.3147, 0.9705, 0.6359, 0.3083]) return= 131802.06019900876\n", + "probs of actions: tensor([0.7385, 0.7852, 0.7893, 0.7300, 0.0182, 0.7516, 0.7516, 0.0807, 0.0850,\n", + " 0.7540, 0.7621, 0.7685, 0.0843, 0.7577, 0.0585, 0.0655, 0.7731, 0.7445,\n", + " 0.7731, 0.7853, 0.7374, 0.7530, 0.0523, 0.8993, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5433, 0.5248, 0.5294, 0.4954, 0.5553, 0.5219, 0.5261, 0.5358,\n", + " 0.5239, 0.5297, 0.5282, 0.5245, 0.5323, 0.5315, 0.5025, 0.5484, 0.5236,\n", + " 0.5298, 0.5282, 0.5286, 0.5285, 0.5060, 0.5475, 0.5638])\n", + "finalReturns: tensor([1.3723, 1.4348, 1.3828, 1.2867, 1.1566, 1.0027, 0.8312, 0.6468, 0.4754,\n", + " 0.2555])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([20, 25, 25, 20, 19, 25, 21, 27, 21, 20, 21, 25, 25, 20, 19, 19, 19, 20,\n", + " 25, 25, 23, 25, 25, 25, 0])\n", + "loss= tensor(24.3833, grad_fn=) , base rewards= tensor([4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 4.2216,\n", + " 4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 4.2216, 3.6567, 3.1602, 2.7129,\n", + " 2.3005, 1.9135, 1.5480, 1.2121, 0.8942, 0.5849, 0.2885]) return= 131224.90587325243\n", + "probs of actions: tensor([0.3167, 0.4112, 0.4304, 0.3126, 0.0764, 0.4228, 0.0819, 0.0535, 0.0741,\n", + " 0.3408, 0.0841, 0.4277, 0.4054, 0.3495, 0.0591, 0.0609, 0.0489, 0.3048,\n", + " 0.4070, 0.4643, 0.0152, 0.4746, 0.4893, 0.3663, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5208, 0.5213, 0.5437, 0.5287, 0.5032, 0.5441, 0.4945, 0.5514,\n", + " 0.5256, 0.5251, 0.5096, 0.5241, 0.5430, 0.5288, 0.5295, 0.5294, 0.5255,\n", + " 0.5068, 0.5248, 0.5299, 0.5138, 0.5231, 0.5207, 0.5838])\n", + "finalReturns: tensor([1.5945, 1.6306, 1.5975, 1.5155, 1.4024, 1.2826, 1.1233, 0.9293, 0.7334,\n", + " 0.5197, 0.2953])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 13 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 20, 25, 20, 25, 25, 20, 25, 25, 25, 25, 25, 25,\n", + " 20, 25, 25, 25, 27, 21, 0])\n", + "loss= tensor(11.5393, grad_fn=) , base rewards= tensor([4.3408, 4.3408, 4.3408, 4.3408, 4.3408, 4.3408, 4.3408, 4.3408, 4.3408,\n", + " 4.3408, 4.3408, 4.3408, 4.3408, 4.3408, 3.7524, 3.2614, 2.8326, 2.4489,\n", + " 2.0972, 1.7685, 1.4565, 1.1431, 0.8458, 0.5561, 0.2730]) return= 130632.29857987192\n", + "probs of actions: tensor([0.8027, 0.7853, 0.8031, 0.8005, 0.7618, 0.7843, 0.0751, 0.7990, 0.0598,\n", + " 0.7952, 0.7745, 0.0666, 0.7593, 0.8055, 0.8090, 0.8378, 0.8045, 0.7969,\n", + " 0.0747, 0.8099, 0.7747, 0.8152, 0.0467, 0.0235, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5401, 0.5165, 0.5224, 0.5209, 0.5213, 0.5437, 0.5023, 0.5485,\n", + " 0.5011, 0.5263, 0.5424, 0.5026, 0.5259, 0.5200, 0.5215, 0.5211, 0.5212,\n", + " 0.5437, 0.5023, 0.5260, 0.5200, 0.5111, 0.5472, 0.5667])\n", + "finalReturns: tensor([1.9858, 2.0483, 2.0193, 1.9266, 1.7891, 1.6197, 1.4047, 1.2144, 1.0019,\n", + " 0.7792, 0.5578, 0.2936])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 27, 25, 27, 25, 27,\n", + " 25, 25, 25, 25, 25, 25, 0])\n", + "loss= tensor(16.6462, grad_fn=) , base rewards= tensor([4.5332, 4.5332, 4.5332, 4.5332, 4.5332, 4.5332, 4.5332, 4.5332, 4.5332,\n", + " 4.5332, 4.5332, 4.5332, 4.5332, 3.9495, 3.4574, 3.0288, 2.6513, 2.3024,\n", + " 1.9819, 1.6745, 1.3840, 1.0988, 0.8192, 0.5435, 0.2707]) return= 130222.86739483997\n", + "probs of actions: tensor([0.8502, 0.8415, 0.8612, 0.8445, 0.8176, 0.8402, 0.8292, 0.8532, 0.8535,\n", + " 0.8500, 0.8340, 0.8461, 0.8389, 0.1052, 0.8543, 0.0961, 0.8421, 0.1346,\n", + " 0.8162, 0.8575, 0.8188, 0.8667, 0.9187, 0.9012, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5401, 0.5165, 0.5224, 0.5209, 0.5213, 0.5212, 0.5212, 0.5212,\n", + " 0.5212, 0.5212, 0.5212, 0.5212, 0.5108, 0.5289, 0.5089, 0.5293, 0.5088,\n", + " 0.5294, 0.5192, 0.5217, 0.5211, 0.5212, 0.5212, 0.5837])\n", + "finalReturns: tensor([2.2921, 2.3546, 2.3359, 2.2356, 2.1043, 1.9237, 1.7355, 1.5135, 1.2849,\n", + " 1.0484, 0.8069, 0.5614, 0.3130])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([25, 25, 25, 25, 27, 25, 27, 25, 27, 25, 25, 25, 25, 27, 27, 27, 25, 25,\n", + " 27, 25, 25, 27, 25, 27, 0])\n", + "loss= tensor(23.1371, grad_fn=) , base rewards= tensor([4.7819, 4.7819, 4.7819, 4.7819, 4.7819, 4.7819, 4.7819, 4.7819, 4.7819,\n", + " 4.7819, 4.7819, 4.7819, 4.1977, 3.7057, 3.2771, 2.8934, 2.5475, 2.2274,\n", + " 1.9262, 1.6334, 1.3481, 1.0734, 0.8000, 0.5293, 0.2653]) return= 129983.17438300277\n", + "probs of actions: tensor([0.8312, 0.8252, 0.8517, 0.8265, 0.1764, 0.8258, 0.1594, 0.8394, 0.1417,\n", + " 0.8382, 0.8193, 0.8525, 0.8306, 0.1470, 0.1561, 0.1345, 0.8147, 0.7903,\n", + " 0.1904, 0.8504, 0.8082, 0.1412, 0.9162, 0.0991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5401, 0.5165, 0.5224, 0.5105, 0.5289, 0.5089, 0.5293, 0.5088,\n", + " 0.5294, 0.5192, 0.5217, 0.5211, 0.5108, 0.5185, 0.5165, 0.5274, 0.5196,\n", + " 0.5112, 0.5288, 0.5193, 0.5113, 0.5287, 0.5089, 0.5918])\n", + "finalReturns: tensor([2.5538, 2.6163, 2.5872, 2.5050, 2.3702, 2.1996, 1.9923, 1.7738, 1.5555,\n", + " 1.3120, 1.0674, 0.8294, 0.5714, 0.3265])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([25, 27, 25, 25, 27, 25, 27, 27, 25, 25, 27, 27, 25, 25, 25, 25, 25, 27,\n", + " 27, 25, 25, 27, 25, 27, 0])\n", + "loss= tensor(19.3476, grad_fn=) , base rewards= tensor([5.0490, 5.0490, 5.0490, 5.0490, 5.0490, 5.0490, 5.0490, 5.0490, 5.0490,\n", + " 5.0490, 5.0490, 4.4650, 3.9730, 3.5509, 3.1764, 2.8302, 2.5058, 2.1969,\n", + " 1.8996, 1.6107, 1.3334, 1.0633, 0.7937, 0.5257, 0.2638]) return= 129940.02348244\n", + "probs of actions: tensor([0.6411, 0.3478, 0.6864, 0.6324, 0.3795, 0.6402, 0.3471, 0.3273, 0.6574,\n", + " 0.6662, 0.3993, 0.2574, 0.6499, 0.6282, 0.6171, 0.6509, 0.5852, 0.4329,\n", + " 0.4035, 0.6756, 0.6048, 0.3174, 0.7760, 0.2519, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5297, 0.5242, 0.5205, 0.5110, 0.5288, 0.5089, 0.5189, 0.5268,\n", + " 0.5198, 0.5111, 0.5184, 0.5270, 0.5198, 0.5216, 0.5211, 0.5212, 0.5108,\n", + " 0.5185, 0.5269, 0.5198, 0.5112, 0.5288, 0.5089, 0.5918])\n", + "finalReturns: tensor([2.8077, 2.8806, 2.8543, 2.7493, 2.6041, 2.4288, 2.2321, 2.0197, 1.8063,\n", + " 1.5767, 1.3270, 1.0774, 0.8358, 0.5750, 0.3281])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 25, 25, 27, 25, 25, 27, 27, 25, 25, 25, 27, 25, 27,\n", + " 27, 25, 25, 27, 25, 27, 0])\n", + "loss= tensor(23.0461, grad_fn=) , base rewards= tensor([5.3010, 5.3010, 5.3010, 5.3010, 5.3010, 5.3010, 5.3010, 5.3010, 5.3010,\n", + " 5.3010, 4.7192, 4.2266, 3.7982, 3.4206, 3.0777, 2.7543, 2.4466, 2.1500,\n", + " 1.8670, 1.5875, 1.3174, 1.0525, 0.7869, 0.5219, 0.2621]) return= 129813.23890870859\n", + "probs of actions: tensor([0.5159, 0.5150, 0.4584, 0.5240, 0.5492, 0.4800, 0.4801, 0.4968, 0.4940,\n", + " 0.4976, 0.5986, 0.4028, 0.4706, 0.4470, 0.4710, 0.5364, 0.4000, 0.5993,\n", + " 0.5524, 0.4923, 0.4229, 0.4827, 0.6139, 0.3995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5274, 0.5196, 0.5112, 0.5288,\n", + " 0.5193, 0.5113, 0.5183, 0.5270, 0.5198, 0.5216, 0.5107, 0.5289, 0.5089,\n", + " 0.5189, 0.5268, 0.5198, 0.5111, 0.5288, 0.5089, 0.5918])\n", + "finalReturns: tensor([3.0709, 3.1334, 3.1147, 3.0248, 2.8754, 2.6986, 2.5004, 2.2974, 2.0651,\n", + " 1.8392, 1.5998, 1.3431, 1.0881, 0.8426, 0.5789, 0.3297])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([25, 27, 27, 27, 27, 27, 27, 25, 25, 27, 25, 25, 27, 25, 25, 27, 25, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(31.1249, grad_fn=) , base rewards= tensor([5.5427, 5.5427, 5.5427, 5.5427, 5.5427, 5.5427, 5.5427, 5.5427, 5.5427,\n", + " 4.9605, 4.4680, 4.0396, 3.6620, 3.3132, 2.9870, 2.6824, 2.3868, 2.0995,\n", + " 1.8233, 1.5489, 1.2825, 1.0205, 0.7620, 0.5062, 0.2524]) return= 129679.56150960914\n", + "probs of actions: tensor([0.2493, 0.7420, 0.6959, 0.7517, 0.7673, 0.7372, 0.7310, 0.2662, 0.2334,\n", + " 0.7474, 0.1887, 0.3415, 0.7633, 0.2293, 0.2571, 0.7751, 0.1964, 0.8103,\n", + " 0.7621, 0.7381, 0.8030, 0.7262, 0.6998, 0.6726, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4487, 0.5297, 0.5138, 0.5177, 0.5167, 0.5170, 0.5169, 0.5273, 0.5197,\n", + " 0.5112, 0.5288, 0.5193, 0.5113, 0.5287, 0.5193, 0.5113, 0.5287, 0.5089,\n", + " 0.5189, 0.5164, 0.5170, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.3375, 3.4000, 3.3813, 3.2810, 3.1392, 2.9768, 2.7742, 2.5595, 2.3439,\n", + " 2.1024, 1.8696, 1.6252, 1.3751, 1.1201, 0.8616, 0.6005, 0.3374])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 25, 27, 27, 27, 27, 27, 27, 25, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 25, 27, 27, 27, 0])\n", + "loss= tensor(15.3898, grad_fn=) , base rewards= tensor([5.7261, 5.7261, 5.7261, 5.7261, 5.7261, 5.7261, 5.7261, 5.7261, 5.1368,\n", + " 4.6459, 4.2236, 3.8492, 3.5088, 3.1929, 2.8892, 2.6013, 2.3234, 2.0532,\n", + " 1.7886, 1.5282, 1.2709, 1.0159, 0.7627, 0.5058, 0.2524]) return= 129467.4131065994\n", + "probs of actions: tensor([0.9444, 0.9402, 0.9242, 0.9438, 0.0534, 0.9387, 0.9331, 0.9445, 0.9529,\n", + " 0.9536, 0.9645, 0.0761, 0.9519, 0.9444, 0.9565, 0.9595, 0.9607, 0.9553,\n", + " 0.9569, 0.9400, 0.0355, 0.9364, 0.9489, 0.9312, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5270, 0.5093, 0.5188, 0.5164, 0.5170,\n", + " 0.5169, 0.5169, 0.5273, 0.5093, 0.5188, 0.5164, 0.5170, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5273, 0.5093, 0.5188, 0.5164, 0.5899])\n", + "finalReturns: tensor([3.6596, 3.7325, 3.7063, 3.6117, 3.4692, 3.2823, 3.0890, 2.8738, 2.6452,\n", + " 2.4061, 2.1594, 1.9071, 1.6506, 1.3909, 1.1186, 0.8625, 0.6006, 0.3376])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 6 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.5009, grad_fn=) , base rewards= tensor([5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.9498, 5.3600, 4.8693,\n", + " 4.4470, 4.0725, 3.7322, 3.4162, 3.1181, 2.8329, 2.5572, 2.2886, 2.0252,\n", + " 1.7657, 1.5091, 1.2547, 1.0019, 0.7503, 0.4996, 0.2495]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9869, 0.9858, 0.9812, 0.9867, 0.9870, 0.9850, 0.9836, 0.9897, 0.9896,\n", + " 0.9908, 0.9930, 0.9842, 0.9890, 0.9900, 0.9919, 0.9932, 0.9919, 0.9909,\n", + " 0.9907, 0.9878, 0.9923, 0.9858, 0.9907, 0.9860, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([3.9446, 4.0175, 3.9913, 3.8967, 3.7542, 3.5777, 3.3767, 3.1579, 2.9262,\n", + " 2.6849, 2.4366, 2.1831, 1.9257, 1.6653, 1.4028, 1.1387, 0.8734, 0.6072,\n", + " 0.3403])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 99999 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.1744, grad_fn=) , base rewards= tensor([6.1990, 6.1990, 6.1990, 6.1990, 6.1990, 6.1990, 5.6091, 5.1185, 4.6961,\n", + " 4.3217, 3.9813, 3.6654, 3.3672, 3.0820, 2.8063, 2.5377, 2.2744, 2.0149,\n", + " 1.7583, 1.5038, 1.2510, 0.9994, 0.7487, 0.4987, 0.2491]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9952, 0.9947, 0.9929, 0.9951, 0.9951, 0.9953, 0.9948, 0.9969, 0.9974,\n", + " 0.9973, 0.9979, 0.9956, 0.9958, 0.9967, 0.9979, 0.9983, 0.9980, 0.9967,\n", + " 0.9975, 0.9965, 0.9977, 0.9943, 0.9977, 0.9957, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.2124, 4.2853, 4.2591, 4.1645, 4.0220, 3.8455, 3.6445, 3.4257, 3.1940,\n", + " 2.9527, 2.7044, 2.4509, 2.1934, 1.9331, 1.6706, 1.4065, 1.1412, 0.8750,\n", + " 0.6081, 0.3407])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 66024 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0306, grad_fn=) , base rewards= tensor([6.4476, 6.4476, 6.4476, 6.4476, 6.4476, 5.8581, 5.3673, 4.9450, 4.5705,\n", + " 4.2302, 3.9142, 3.6161, 3.3309, 3.0552, 2.7866, 2.5232, 2.2637, 2.0071,\n", + " 1.7527, 1.4999, 1.2483, 0.9976, 0.7475, 0.4980, 0.2489]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9984, 0.9989, 0.9990, 0.9993, 0.9992, 0.9996, 0.9996,\n", + " 0.9996, 0.9998, 0.9994, 0.9993, 0.9995, 0.9997, 0.9999, 0.9997, 0.9995,\n", + " 0.9997, 0.9994, 0.9998, 0.9989, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.4805, 4.5534, 4.5271, 4.4326, 4.2901, 4.1135, 3.9125, 3.6938, 3.4621,\n", + " 3.2208, 2.9725, 2.7189, 2.4615, 2.2012, 1.9387, 1.6746, 1.4093, 1.1430,\n", + " 0.8761, 0.6087, 0.3410])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 370 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0339, grad_fn=) , base rewards= tensor([6.6975, 6.6975, 6.6975, 6.6975, 6.1064, 5.6160, 5.1936, 4.8192, 4.4788,\n", + " 4.1629, 3.8647, 3.5795, 3.3038, 3.0352, 2.7719, 2.5124, 2.2558, 2.0013,\n", + " 1.7485, 1.4969, 1.2462, 0.9962, 0.7466, 0.4975, 0.2486]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9990, 0.9989, 0.9985, 0.9990, 0.9991, 0.9993, 0.9993, 0.9996, 0.9996,\n", + " 0.9996, 0.9998, 0.9994, 0.9993, 0.9995, 0.9997, 0.9999, 0.9997, 0.9996,\n", + " 0.9998, 0.9994, 0.9998, 0.9990, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([4.7487, 4.8216, 4.7954, 4.7008, 4.5583, 4.3818, 4.1808, 3.9621, 3.7303,\n", + " 3.4891, 3.2408, 2.9872, 2.7298, 2.4694, 2.2070, 1.9429, 1.6775, 1.4113,\n", + " 1.1444, 0.8770, 0.6092, 0.3412])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 4830 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0356, grad_fn=) , base rewards= tensor([6.9408, 6.9408, 6.9408, 6.3561, 5.8642, 5.4422, 5.0677, 4.7273, 4.4114,\n", + " 4.1132, 3.8280, 3.5523, 3.2837, 3.0203, 2.7608, 2.5042, 2.2498, 1.9970,\n", + " 1.7454, 1.4947, 1.2447, 0.9951, 0.7460, 0.4971, 0.2485]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9991, 0.9990, 0.9990, 0.9990, 0.9991, 0.9995, 0.9994, 0.9997, 0.9997,\n", + " 0.9997, 0.9999, 0.9995, 0.9994, 0.9996, 0.9998, 0.9999, 0.9997, 0.9996,\n", + " 0.9998, 0.9994, 0.9998, 0.9990, 0.9998, 0.9995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.0173, 5.0902, 5.0638, 4.9693, 4.8268, 4.6503, 4.4493, 4.2305, 3.9988,\n", + " 3.7575, 3.5092, 3.2557, 2.9982, 2.7379, 2.4754, 2.2113, 1.9460, 1.6798,\n", + " 1.4129, 1.1455, 0.8777, 0.6096, 0.3413])\n", + "----------------------------------------\n", + "iter 2 stage 1 ep 10 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0417, grad_fn=) , base rewards= tensor([7.2101, 7.2101, 6.5997, 6.1137, 5.6903, 5.3161, 4.9756, 4.6597, 4.3615,\n", + " 4.0763, 3.8007, 3.5321, 3.2687, 3.0092, 2.7526, 2.4982, 2.2454, 1.9938,\n", + " 1.7430, 1.4930, 1.2435, 0.9943, 0.7455, 0.4968, 0.2484]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9991, 0.9990, 0.9990, 0.9990, 0.9991, 0.9995, 0.9994, 0.9997, 0.9997,\n", + " 0.9997, 0.9999, 0.9995, 0.9994, 0.9996, 0.9998, 0.9999, 0.9997, 0.9996,\n", + " 0.9998, 0.9994, 0.9998, 0.9990, 0.9998, 0.9995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.2854, 5.3583, 5.3326, 5.2378, 5.0954, 4.9188, 4.7178, 4.4991, 4.2673,\n", + " 4.0261, 3.7778, 3.5242, 3.2668, 3.0064, 2.7440, 2.4799, 2.2145, 1.9483,\n", + " 1.6814, 1.4140, 1.1462, 0.8782, 0.6099, 0.3415])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 0 adversary: AdversaryModes.imitation_128\n", + " actions: tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\n", + " 27, 27, 27, 27, 27, 27, 0])\n", + "loss= tensor(0.0479, grad_fn=) , base rewards= tensor([7.3783, 6.8670, 6.3576, 5.9396, 5.5641, 5.2240, 4.9080, 4.6098, 4.3246,\n", + " 4.0490, 3.7804, 3.5170, 3.2575, 3.0009, 2.7465, 2.4936, 2.2420, 1.9913,\n", + " 1.7413, 1.4918, 1.2426, 0.9938, 0.7451, 0.4966, 0.2483]) return= 129338.69866666665\n", + "probs of actions: tensor([0.9991, 0.9990, 0.9990, 0.9990, 0.9991, 0.9995, 0.9994, 0.9997, 0.9997,\n", + " 0.9997, 0.9999, 0.9995, 0.9994, 0.9996, 0.9998, 0.9999, 0.9997, 0.9996,\n", + " 0.9998, 0.9994, 0.9998, 0.9990, 0.9998, 0.9995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4383, 0.5375, 0.5118, 0.5182, 0.5166, 0.5170, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169,\n", + " 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5169, 0.5898])\n", + "finalReturns: tensor([5.5556, 5.6285, 5.6005, 5.5067, 5.3639, 5.1875, 4.9865, 4.7677, 4.5360,\n", + " 4.2947, 4.0464, 3.7929, 3.5354, 3.2751, 3.0126, 2.7485, 2.4832, 2.2170,\n", + " 1.9501, 1.6827, 1.4149, 1.1468, 0.8786, 0.6101, 0.3416])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682912335 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2471239, 'tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.])', 129338.69866666665, 75332.17066666666, 0.047861263155937195, 1e-05, 1, 0, 'tensor([27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,\\n 27, 27, 27, 27, 27, 27, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682912335', 25, 50, 172677.5835126837, 219861.0138117109, 91586.68399118823, 132334.4363268229, 129338.69866666666, 72150.91909080048, 72150.91909080048, 88030.91902269641, 88030.91902269641, 105848.51071772553, 72150.91909080048, 88030.91902269641]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 11, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045,\n", + " 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045,\n", + " 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045, 0.6045]) return= 138853.62351012303\n", + "probs of actions: tensor([0.8900, 0.8782, 0.9039, 0.8629, 0.8870, 0.8853, 0.8782, 0.8892, 0.8739,\n", + " 0.9083, 0.9194, 0.8914, 0.9129, 0.9059, 0.8999, 0.8765, 0.8980, 0.8966,\n", + " 0.8917, 0.8911, 0.8851, 0.8940, 0.9132, 0.0012, 0.9840],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5613, 0.5616, 0.5618, 0.5620, 0.5621,\n", + " 0.5622, 0.5623, 0.5623, 0.5624, 0.5624, 0.5503, 0.6045])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([8, 9, 8, 8, 9, 9, 8, 1, 8, 8, 8, 9, 8, 9, 8, 0, 0, 0, 5, 0, 8, 9, 8, 5,\n", + " 0])\n", + "loss= tensor(0.0605, grad_fn=) , base rewards= tensor([0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075,\n", + " 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075,\n", + " 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.8075, 0.3942]) return= 111874.68821578428\n", + "probs of actions: tensor([0.3709, 0.2137, 0.2994, 0.3707, 0.2204, 0.1786, 0.3582, 0.0190, 0.2927,\n", + " 0.3360, 0.3653, 0.2350, 0.3832, 0.1780, 0.3652, 0.2011, 0.1929, 0.2182,\n", + " 0.0257, 0.2460, 0.3083, 0.1934, 0.2999, 0.0109, 0.9932],\n", + " grad_fn=)\n", + "rewards: tensor([0.5048, 0.5451, 0.5831, 0.5434, 0.5128, 0.4952, 0.4839, 0.4771, 0.4374,\n", + " 0.4362, 0.4353, 0.4329, 0.4374, 0.4345, 0.4386, 0.4435, 0.4161, 0.3962,\n", + " 0.3790, 0.3861, 0.3677, 0.3817, 0.3986, 0.4109, 0.4100])\n", + "finalReturns: tensor([0.0134, 0.0159])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([ 9, 11, 15, 15, 15, 15, 13, 11, 11, 11, 8, 11, 9, 16, 10, 11, 11, 14,\n", + " 11, 8, 0, 9, 15, 15, 0])\n", + "loss= tensor(0.2034, grad_fn=) , base rewards= tensor([1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501,\n", + " 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 1.2501,\n", + " 1.2501, 1.2501, 1.2501, 1.2501, 1.2501, 0.8086, 0.3944]) return= 123413.1590088095\n", + "probs of actions: tensor([0.1262, 0.2931, 0.2773, 0.2741, 0.2788, 0.2340, 0.0820, 0.3281, 0.2858,\n", + " 0.3215, 0.0544, 0.3065, 0.1199, 0.0377, 0.0284, 0.3071, 0.3022, 0.0157,\n", + " 0.3336, 0.0777, 0.0206, 0.1411, 0.4354, 0.3270, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.5448, 0.5776, 0.5443, 0.5482, 0.5390, 0.5378, 0.5301, 0.5136,\n", + " 0.5014, 0.4980, 0.4750, 0.4766, 0.4504, 0.4838, 0.4741, 0.4720, 0.4629,\n", + " 0.4796, 0.4818, 0.4751, 0.4305, 0.4190, 0.4414, 0.4811])\n", + "finalReturns: tensor([0.0914, 0.1139, 0.0867])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 8, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548,\n", + " 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548, 1.5548,\n", + " 1.5548, 1.5548, 1.5548, 1.5548, 1.1058, 0.7056, 0.3403]) return= 111734.54075265459\n", + "probs of actions: tensor([0.9539, 0.9634, 0.9569, 0.9437, 0.0011, 0.9408, 0.9508, 0.9561, 0.9347,\n", + " 0.9630, 0.9612, 0.9563, 0.9605, 0.9461, 0.9509, 0.9305, 0.9621, 0.9472,\n", + " 0.9524, 0.9441, 0.9524, 0.9738, 0.9814, 0.9642, 0.9999],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4956, 0.4418, 0.4379, 0.4350, 0.4329,\n", + " 0.4312, 0.4300, 0.4291, 0.4284, 0.4279, 0.4275, 0.4273, 0.4270, 0.4269,\n", + " 0.4268, 0.4267, 0.4266, 0.4266, 0.4265, 0.4265, 0.4490])\n", + "finalReturns: tensor([0.1737, 0.1962, 0.1698, 0.1087])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0103, grad_fn=) , base rewards= tensor([1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779,\n", + " 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779, 1.8779,\n", + " 1.8779, 1.8779, 1.8779, 1.4285, 1.0281, 0.6626, 0.3222]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9843, 0.9883, 0.9852, 0.9815, 0.9834, 0.9801, 0.9822, 0.9850, 0.9790,\n", + " 0.9890, 0.9879, 0.9852, 0.9864, 0.9812, 0.9827, 0.9752, 0.9875, 0.9837,\n", + " 0.9836, 0.9815, 0.9887, 0.9899, 0.9930, 0.9900, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.2781, 0.3006, 0.2743, 0.2131, 0.1269])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 82452 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872,\n", + " 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872, 2.1872,\n", + " 2.1872, 2.1872, 1.7377, 1.3371, 0.9715, 0.6310, 0.3088]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9987, 0.9991, 0.9988, 0.9984, 0.9986, 0.9982, 0.9984, 0.9987, 0.9981,\n", + " 0.9991, 0.9991, 0.9987, 0.9989, 0.9983, 0.9985, 0.9978, 0.9990, 0.9986,\n", + " 0.9985, 0.9990, 0.9993, 0.9994, 0.9998, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.3959, 0.4184, 0.3921, 0.3309, 0.2447, 0.1402])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 358 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870,\n", + " 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870, 2.4870,\n", + " 2.4870, 2.0371, 1.6364, 1.2707, 0.9301, 0.6079, 0.2990]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9989, 0.9992, 0.9989, 0.9986, 0.9988, 0.9984, 0.9986, 0.9989, 0.9984,\n", + " 0.9992, 0.9992, 0.9989, 0.9990, 0.9985, 0.9986, 0.9981, 0.9991, 0.9988,\n", + " 0.9990, 0.9991, 0.9994, 0.9994, 0.9998, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.5235, 0.5460, 0.5197, 0.4585, 0.3722, 0.2678, 0.1501])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 94 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0026, grad_fn=) , base rewards= tensor([2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797,\n", + " 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797, 2.7797,\n", + " 2.3296, 1.9286, 1.5627, 1.2221, 0.8997, 0.5908, 0.2918]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9989, 0.9992, 0.9990, 0.9987, 0.9988, 0.9985, 0.9987, 0.9989, 0.9984,\n", + " 0.9993, 0.9992, 0.9990, 0.9991, 0.9986, 0.9987, 0.9982, 0.9992, 0.9990,\n", + " 0.9991, 0.9992, 0.9994, 0.9995, 0.9998, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.6584, 0.6809, 0.6545, 0.5933, 0.5071, 0.4026, 0.2849, 0.1573])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674,\n", + " 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 3.0674, 2.6169,\n", + " 2.2157, 1.8496, 1.5087, 1.1863, 0.8773, 0.5782, 0.2864]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9989, 0.9992, 0.9990, 0.9987, 0.9988, 0.9985, 0.9987, 0.9989, 0.9984,\n", + " 0.9993, 0.9992, 0.9990, 0.9991, 0.9986, 0.9987, 0.9982, 0.9992, 0.9990,\n", + " 0.9991, 0.9992, 0.9994, 0.9995, 0.9998, 0.9996, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.7987, 0.8212, 0.7948, 0.7336, 0.6473, 0.5429, 0.4251, 0.2975, 0.1627])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 15 ep 305 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0035, grad_fn=) , base rewards= tensor([3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516,\n", + " 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 3.3516, 2.9005, 2.4989,\n", + " 2.1326, 1.7916, 1.4690, 1.1598, 0.8606, 0.5688, 0.2824]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9990, 0.9991, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9995, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([0.9431, 0.9656, 0.9392, 0.8779, 0.7916, 0.6871, 0.5693, 0.4417, 0.3069,\n", + " 0.1667])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.6335,\n", + " 3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.6335, 3.1817, 2.7796, 2.4128,\n", + " 2.0716, 1.7488, 1.4395, 1.1402, 0.8483, 0.5618, 0.2794]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9990, 0.9992, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9995, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.0905, 1.1130, 1.0866, 1.0253, 0.9389, 0.8344, 0.7166, 0.5889, 0.4541,\n", + " 0.3139, 0.1697])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 9 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0065, grad_fn=) , base rewards= tensor([3.9141, 3.9141, 3.9141, 3.9141, 3.9141, 3.9141, 3.9141, 3.9141, 3.9141,\n", + " 3.9141, 3.9141, 3.9141, 3.9141, 3.9141, 3.4613, 3.0585, 2.6912, 2.3496,\n", + " 2.0265, 1.7171, 1.4177, 1.1256, 0.8391, 0.5566, 0.2772]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9995, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9995, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.2403, 1.2628, 1.2363, 1.1749, 1.0885, 0.9839, 0.8661, 0.7384, 0.6036,\n", + " 0.4633, 0.3191, 0.1719])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0079, grad_fn=) , base rewards= tensor([4.1941, 4.1941, 4.1941, 4.1941, 4.1941, 4.1941, 4.1941, 4.1941, 4.1941,\n", + " 4.1941, 4.1941, 4.1941, 4.1941, 3.7400, 3.3363, 2.9684, 2.6263, 2.3029,\n", + " 1.9932, 1.6936, 1.4014, 1.1147, 0.8322, 0.5527, 0.2755]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9995, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9995, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.3918, 1.4143, 1.3877, 1.3263, 1.2399, 1.1352, 1.0173, 0.8896, 0.7547,\n", + " 0.6144, 0.4702, 0.3230, 0.1736])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0095, grad_fn=) , base rewards= tensor([4.4745, 4.4745, 4.4745, 4.4745, 4.4745, 4.4745, 4.4745, 4.4745, 4.4745,\n", + " 4.4745, 4.4745, 4.4745, 4.0187, 3.6137, 3.2449, 2.9022, 2.5783, 2.2683,\n", + " 1.9684, 1.6760, 1.3893, 1.1066, 0.8270, 0.5498, 0.2742]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9995, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9996, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.5447, 1.5672, 1.5406, 1.4791, 1.3925, 1.2878, 1.1698, 1.0421, 0.9071,\n", + " 0.7668, 0.6226, 0.4753, 0.3259, 0.1748])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0108, grad_fn=) , base rewards= tensor([4.7560, 4.7560, 4.7560, 4.7560, 4.7560, 4.7560, 4.7560, 4.7560, 4.7560,\n", + " 4.7560, 4.7560, 4.2979, 3.8913, 3.5214, 3.1778, 2.8533, 2.5428, 2.2426,\n", + " 1.9500, 1.6630, 1.3802, 1.1005, 0.8232, 0.5476, 0.2733]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9989, 0.9990, 0.9992, 0.9988,\n", + " 0.9995, 0.9995, 0.9992, 0.9993, 0.9990, 0.9991, 0.9990, 0.9996, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.6988, 1.7213, 1.6946, 1.6330, 1.5463, 1.4415, 1.3234, 1.1955, 1.0605,\n", + " 0.9202, 0.7759, 0.6286, 0.4792, 0.3281, 0.1757])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0122, grad_fn=) , base rewards= tensor([5.0396, 5.0396, 5.0396, 5.0396, 5.0396, 5.0396, 5.0396, 5.0396, 5.0396,\n", + " 5.0396, 4.5784, 4.1697, 3.7981, 3.4534, 3.1281, 2.8170, 2.5164, 2.2234,\n", + " 1.9362, 1.6532, 1.3734, 1.0960, 0.8203, 0.5460, 0.2726]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9989, 0.9990, 0.9992, 0.9989,\n", + " 0.9995, 0.9995, 0.9993, 0.9993, 0.9990, 0.9991, 0.9990, 0.9996, 0.9994,\n", + " 0.9994, 0.9994, 0.9996, 0.9996, 0.9999, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([1.8539, 1.8764, 1.8496, 1.7878, 1.7009, 1.5959, 1.4777, 1.3498, 1.2147,\n", + " 1.0743, 0.9299, 0.7827, 0.6332, 0.4821, 0.3297, 0.1764])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 8 ep 31 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0130, grad_fn=) , base rewards= tensor([5.3265, 5.3265, 5.3265, 5.3265, 5.3265, 5.3265, 5.3265, 5.3265, 5.3265,\n", + " 4.8611, 4.4494, 4.0759, 3.7296, 3.4032, 3.0913, 2.7901, 2.4967, 2.2091,\n", + " 1.9259, 1.6459, 1.3684, 1.0926, 0.8182, 0.5448, 0.2721]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9991, 0.9992, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9995, 0.9995, 0.9994, 0.9994, 0.9992, 0.9992, 0.9991, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.0099, 2.0324, 2.0054, 1.9434, 1.8563, 1.7511, 1.6327, 1.5047, 1.3695,\n", + " 1.2290, 1.0846, 0.9372, 0.7877, 0.6366, 0.4842, 0.3309, 0.1770])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0149, grad_fn=) , base rewards= tensor([5.6180, 5.6180, 5.6180, 5.6180, 5.6180, 5.6180, 5.6180, 5.6180, 5.1471,\n", + " 4.7315, 4.3551, 4.0068, 3.6790, 3.3660, 3.0639, 2.7700, 2.4820, 2.1984,\n", + " 1.9182, 1.6405, 1.3646, 1.0900, 0.8166, 0.5438, 0.2717]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9991, 0.9992, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9995, 0.9995, 0.9994, 0.9994, 0.9992, 0.9992, 0.9991, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.1668, 2.1893, 2.1621, 2.0997, 2.0124, 1.9069, 1.7883, 1.6601, 1.5248,\n", + " 1.3842, 1.2397, 1.0923, 0.9427, 0.7915, 0.6391, 0.4858, 0.3318, 0.1774])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0173, grad_fn=) , base rewards= tensor([5.9160, 5.9160, 5.9160, 5.9160, 5.9160, 5.9160, 5.9160, 5.4376, 5.0168,\n", + " 4.6366, 4.2857, 3.9558, 3.6414, 3.3383, 3.0435, 2.7550, 2.4710, 2.1905,\n", + " 1.9125, 1.6364, 1.3617, 1.0881, 0.8153, 0.5432, 0.2714]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9991, 0.9992, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9995, 0.9994, 0.9994, 0.9992, 0.9992, 0.9991, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.3247, 2.3472, 2.3197, 2.2569, 2.1692, 2.0634, 1.9445, 1.8160, 1.6805,\n", + " 1.5398, 1.3951, 1.2477, 1.0980, 0.9468, 0.7944, 0.6410, 0.4870, 0.3325,\n", + " 0.1777])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0201, grad_fn=) , base rewards= tensor([6.2229, 6.2229, 6.2229, 6.2229, 6.2229, 6.2229, 5.7345, 5.3065, 4.9214,\n", + " 4.5668, 4.2343, 3.9180, 3.6135, 3.3177, 3.0283, 2.7438, 2.4628, 2.1845,\n", + " 1.9082, 1.6333, 1.3596, 1.0867, 0.8144, 0.5426, 0.2712]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9991, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9995, 0.9994, 0.9994, 0.9992, 0.9992, 0.9991, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.4838, 2.5063, 2.4783, 2.4151, 2.3268, 2.2205, 2.1012, 1.9724, 1.8367,\n", + " 1.6957, 1.5510, 1.4034, 1.2536, 1.1023, 0.9498, 0.7965, 0.6425, 0.4879,\n", + " 0.3330, 0.1779])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0225, grad_fn=) , base rewards= tensor([6.5419, 6.5419, 6.5419, 6.5419, 6.5419, 6.0399, 5.6025, 5.2106, 4.8512,\n", + " 4.5152, 4.1963, 3.8899, 3.5927, 3.3023, 3.0169, 2.7354, 2.4567, 2.1800,\n", + " 1.9049, 1.6310, 1.3580, 1.0856, 0.8138, 0.5423, 0.2710]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9995, 0.9994, 0.9994, 0.9992, 0.9992, 0.9992, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.6442, 2.6667, 2.6382, 2.5743, 2.4853, 2.3784, 2.2586, 2.1294, 1.9932,\n", + " 1.8521, 1.7071, 1.5593, 1.4095, 1.2581, 1.1056, 0.9521, 0.7981, 0.6435,\n", + " 0.4886, 0.3334, 0.1780])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0253, grad_fn=) , base rewards= tensor([6.8775, 6.8775, 6.8775, 6.8775, 6.3572, 5.9069, 5.5059, 5.1400, 4.7993,\n", + " 4.4769, 4.1680, 3.8689, 3.5771, 3.2908, 3.0084, 2.7291, 2.4521, 2.1767,\n", + " 1.9025, 1.6293, 1.3568, 1.0848, 0.8132, 0.5420, 0.2709]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9995, 0.9994, 0.9995, 0.9992, 0.9992, 0.9992, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.8065, 2.8290, 2.7997, 2.7348, 2.6449, 2.5372, 2.4167, 2.2869, 2.1503,\n", + " 2.0088, 1.8636, 1.7156, 1.5656, 1.4141, 1.2615, 1.1080, 0.9539, 0.7993,\n", + " 0.6443, 0.4891, 0.3337, 0.1782])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0276, grad_fn=) , base rewards= tensor([7.2357, 7.2357, 7.2357, 6.6905, 6.2228, 5.8096, 5.4348, 5.0878, 4.7608,\n", + " 4.4484, 4.1469, 3.8532, 3.5655, 3.2822, 3.0021, 2.7244, 2.4486, 2.1741,\n", + " 1.9007, 1.6280, 1.3559, 1.0842, 0.8129, 0.5417, 0.2708]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9995, 0.9994, 0.9995, 0.9992, 0.9992, 0.9992, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([2.9710, 2.9935, 2.9633, 2.8971, 2.8059, 2.6971, 2.5757, 2.4451, 2.3080,\n", + " 2.1660, 2.0204, 1.8722, 1.7220, 1.5703, 1.4175, 1.2640, 1.1098, 0.9551,\n", + " 0.8002, 0.6449, 0.4895, 0.3339, 0.1783])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0295, grad_fn=) , base rewards= tensor([7.6252, 7.6252, 7.0457, 6.5544, 6.1245, 5.7379, 5.3822, 5.0490, 4.7321,\n", + " 4.4272, 4.1311, 3.8415, 3.5568, 3.2757, 2.9973, 2.7209, 2.4460, 2.1723,\n", + " 1.8993, 1.6271, 1.3552, 1.0838, 0.8126, 0.5416, 0.2707]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9996, 0.9996, 0.9994, 0.9995, 0.9992, 0.9993, 0.9992, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([3.1385, 3.1610, 3.1295, 3.0617, 2.9688, 2.8585, 2.7358, 2.6043, 2.4664,\n", + " 2.3237, 2.1777, 2.0291, 1.8786, 1.7267, 1.5738, 1.4201, 1.2658, 1.1111,\n", + " 0.9561, 0.8008, 0.6454, 0.4898, 0.3341, 0.1783])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0320, grad_fn=) , base rewards= tensor([7.9425, 7.4312, 6.9074, 6.4547, 6.0520, 5.6848, 5.3432, 5.0202, 4.7108,\n", + " 4.4114, 4.1193, 3.8328, 3.5503, 3.2709, 2.9937, 2.7183, 2.4441, 2.1709,\n", + " 1.8983, 1.6263, 1.3547, 1.0834, 0.8124, 0.5415, 0.2707]) return= 112524.66365021843\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9991, 0.9992, 0.9993, 0.9990,\n", + " 0.9996, 0.9996, 0.9994, 0.9995, 0.9992, 0.9993, 0.9992, 0.9996, 0.9995,\n", + " 0.9995, 0.9995, 0.9996, 0.9997, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5570, 0.5228, 0.4978, 0.4795, 0.4659, 0.4559, 0.4484, 0.4429,\n", + " 0.4387, 0.4356, 0.4333, 0.4316, 0.4303, 0.4293, 0.4286, 0.4280, 0.4276,\n", + " 0.4273, 0.4271, 0.4269, 0.4268, 0.4267, 0.4266, 0.4491])\n", + "finalReturns: tensor([3.3100, 3.3325, 3.2993, 3.2292, 3.1341, 3.0218, 2.8975, 2.7647, 2.6257,\n", + " 2.4822, 2.3355, 2.1864, 2.0356, 1.8834, 1.7303, 1.5764, 1.4221, 1.2673,\n", + " 1.1122, 0.9568, 0.8013, 0.6457, 0.4900, 0.3342, 0.1784])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682929682 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[683269, 'tensor([0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])', 112524.66365021843, 93537.02666495038, 0.03203679621219635, 1e-05, 1, 0, 'tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\\n 15, 15, 15, 15, 15, 15, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682929682', 25, 50, 161287.58344151574, 184572.3091501231, 73453.3647159636, 135545.41866666666, 132647.75466666667, 112524.66365021843, 112524.66365021843, 117051.59338141435, 117058.92268888396, 85375.85726043607, 112524.66365021843, 117061.61105796597]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723,\n", + " 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723,\n", + " 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723, 0.4723]) return= 133459.1809763887\n", + "probs of actions: tensor([0.9112, 0.0541, 0.9293, 0.9027, 0.9259, 0.9068, 0.9231, 0.9408, 0.9248,\n", + " 0.9224, 0.9068, 0.9271, 0.9228, 0.9337, 0.9150, 0.0406, 0.9252, 0.9250,\n", + " 0.8971, 0.9140, 0.9118, 0.9137, 0.9213, 0.9058, 0.9889],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5237, 0.5370, 0.5433, 0.5481, 0.5517, 0.5544, 0.5564, 0.5579,\n", + " 0.5591, 0.5599, 0.5606, 0.5610, 0.5614, 0.5617, 0.5618, 0.5658, 0.5390,\n", + " 0.5193, 0.5047, 0.4940, 0.4860, 0.4800, 0.4756, 0.4723])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([8, 8, 0, 7, 7, 6, 1, 6, 1, 0, 7, 0, 7, 7, 0, 0, 9, 7, 8, 7, 0, 7, 7, 7,\n", + " 0])\n", + "loss= tensor(0.0095, grad_fn=) , base rewards= tensor([0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497,\n", + " 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497,\n", + " 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.8497, 0.4157]) return= 112339.1163673332\n", + "probs of actions: tensor([0.0652, 0.0703, 0.3638, 0.4614, 0.4650, 0.0731, 0.0180, 0.0588, 0.0144,\n", + " 0.3030, 0.4144, 0.2663, 0.4258, 0.3902, 0.3342, 0.2061, 0.0289, 0.4026,\n", + " 0.0797, 0.4148, 0.0888, 0.5708, 0.4182, 0.5905, 0.9986],\n", + " grad_fn=)\n", + "rewards: tensor([0.5048, 0.5468, 0.5857, 0.5202, 0.5014, 0.4889, 0.4787, 0.4481, 0.4484,\n", + " 0.4296, 0.4075, 0.4222, 0.4021, 0.4132, 0.4265, 0.4101, 0.3900, 0.4128,\n", + " 0.4198, 0.4311, 0.4400, 0.4152, 0.4231, 0.4291, 0.4385])\n", + "finalReturns: tensor([0.0180, 0.0229])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 18, 18, 18, 16, 18, 18, 14, 18, 18, 21, 15, 18, 18, 18, 11, 18, 19,\n", + " 18, 18, 11, 18, 18, 11, 0])\n", + "loss= tensor(0.2019, grad_fn=) , base rewards= tensor([1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261,\n", + " 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 1.3261,\n", + " 1.3261, 1.3261, 1.3261, 1.3261, 1.3261, 0.8335, 0.3968]) return= 122146.33270204287\n", + "probs of actions: tensor([0.1114, 0.5005, 0.4775, 0.4623, 0.0738, 0.4914, 0.4920, 0.0551, 0.5121,\n", + " 0.4809, 0.0076, 0.0585, 0.4930, 0.4906, 0.5019, 0.1138, 0.4775, 0.0571,\n", + " 0.4833, 0.4679, 0.1263, 0.5121, 0.6630, 0.2893, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5320, 0.5428, 0.5274, 0.5228, 0.5002, 0.4957, 0.5052, 0.4755,\n", + " 0.4772, 0.4668, 0.5002, 0.4775, 0.4788, 0.4797, 0.5006, 0.4561, 0.4589,\n", + " 0.4711, 0.4739, 0.4963, 0.4529, 0.4602, 0.4860, 0.4778])\n", + "finalReturns: tensor([0.0979, 0.1303, 0.0809])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 18, 18, 18, 19, 18, 17, 18, 18, 18, 16, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 16, 16, 18, 18, 18, 0])\n", + "loss= tensor(0.0733, grad_fn=) , base rewards= tensor([1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379,\n", + " 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379, 1.3379,\n", + " 1.3379, 1.3379, 1.3379, 1.3379, 0.9393, 0.5929, 0.2833]) return= 102188.08265443008\n", + "probs of actions: tensor([0.8722, 0.8706, 0.8676, 0.8419, 0.0511, 0.8602, 0.0068, 0.8830, 0.8689,\n", + " 0.8490, 0.0319, 0.8320, 0.8612, 0.8626, 0.8607, 0.8587, 0.8471, 0.8518,\n", + " 0.8542, 0.0333, 0.0318, 0.9187, 0.9270, 0.7905, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5101, 0.4751, 0.4460, 0.4344, 0.4233, 0.4056, 0.3984,\n", + " 0.3931, 0.3959, 0.3796, 0.3790, 0.3786, 0.3782, 0.3780, 0.3778, 0.3776,\n", + " 0.3775, 0.3842, 0.3778, 0.3662, 0.3689, 0.3710, 0.4049])\n", + "finalReturns: tensor([0.1732, 0.2056, 0.1830, 0.1216])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0276, grad_fn=) , base rewards= tensor([1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350,\n", + " 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350, 1.6350,\n", + " 1.6350, 1.6350, 1.6350, 1.2248, 0.8702, 0.5549, 0.2674]) return= 102604.52812037413\n", + "probs of actions: tensor([0.9710, 0.9696, 0.9702, 0.9607, 0.9690, 0.9665, 0.9702, 0.9737, 0.9688,\n", + " 0.9612, 0.9591, 0.9589, 0.9674, 0.9678, 0.9658, 0.9667, 0.9641, 0.9647,\n", + " 0.9651, 0.9602, 0.9635, 0.9843, 0.9838, 0.9696, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5101, 0.4751, 0.4497, 0.4310, 0.4172, 0.4071, 0.3995,\n", + " 0.3939, 0.3897, 0.3865, 0.3842, 0.3824, 0.3811, 0.3801, 0.3794, 0.3789,\n", + " 0.3784, 0.3781, 0.3779, 0.3777, 0.3776, 0.3775, 0.4098])\n", + "finalReturns: tensor([0.2855, 0.3179, 0.2947, 0.2324, 0.1424])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 16, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.0543, grad_fn=) , base rewards= tensor([1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695,\n", + " 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695, 1.8695,\n", + " 1.8695, 1.8695, 1.4654, 1.1152, 0.8028, 0.5175, 0.2517]) return= 102462.48329383403\n", + "probs of actions: tensor([0.9692, 0.9680, 0.9683, 0.9593, 0.9679, 0.9651, 0.9692, 0.9716, 0.9667,\n", + " 0.9584, 0.9585, 0.9576, 0.9667, 0.9662, 0.9652, 0.9653, 0.9625, 0.9646,\n", + " 0.0057, 0.9604, 0.9625, 0.9790, 0.9841, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5101, 0.4751, 0.4497, 0.4310, 0.4172, 0.4071, 0.3995,\n", + " 0.3939, 0.3897, 0.3865, 0.3842, 0.3824, 0.3811, 0.3801, 0.3794, 0.3789,\n", + " 0.3852, 0.3717, 0.3731, 0.3741, 0.3749, 0.3755, 0.4083])\n", + "finalReturns: tensor([0.4081, 0.4405, 0.4176, 0.3558, 0.2662, 0.1566])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 19, 18, 18, 18, 18, 0])\n", + "loss= tensor(2.0158, grad_fn=) , base rewards= tensor([2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318,\n", + " 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318, 2.1318,\n", + " 2.1318, 1.7209, 1.3661, 1.0504, 0.7628, 0.4952, 0.2423]) return= 102665.3466452767\n", + "probs of actions: tensor([0.9743, 0.9729, 0.9736, 0.9664, 0.9736, 0.9710, 0.9747, 0.9763, 0.9718,\n", + " 0.9644, 0.9661, 0.9645, 0.9721, 0.9718, 0.9708, 0.9715, 0.9687, 0.9713,\n", + " 0.9729, 0.0345, 0.9690, 0.9847, 0.9871, 0.9855, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5101, 0.4751, 0.4497, 0.4310, 0.4172, 0.4071, 0.3995,\n", + " 0.3939, 0.3897, 0.3865, 0.3842, 0.3824, 0.3811, 0.3801, 0.3794, 0.3789,\n", + " 0.3784, 0.3744, 0.3811, 0.3801, 0.3794, 0.3788, 0.4108])\n", + "finalReturns: tensor([0.5514, 0.5838, 0.5642, 0.4988, 0.4063, 0.2945, 0.1686])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 17 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 18, 18, 18, 18, 0])\n", + "loss= tensor(0.2928, grad_fn=) , base rewards= tensor([2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675,\n", + " 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675, 2.3675,\n", + " 1.9563, 1.6011, 1.2853, 0.9975, 0.7298, 0.4768, 0.2344]) return= 102604.52812037413\n", + "probs of actions: tensor([0.9312, 0.9290, 0.9287, 0.9162, 0.9312, 0.9262, 0.9345, 0.9344, 0.9254,\n", + " 0.9113, 0.9177, 0.9099, 0.9296, 0.9272, 0.9277, 0.9261, 0.9193, 0.9308,\n", + " 0.9225, 0.9046, 0.9087, 0.9552, 0.9603, 0.9625, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5586, 0.5101, 0.4751, 0.4497, 0.4310, 0.4172, 0.4071, 0.3995,\n", + " 0.3939, 0.3897, 0.3865, 0.3842, 0.3824, 0.3811, 0.3801, 0.3794, 0.3789,\n", + " 0.3784, 0.3781, 0.3779, 0.3777, 0.3776, 0.3775, 0.4098])\n", + "finalReturns: tensor([0.6884, 0.7208, 0.6976, 0.6352, 0.5452, 0.4351, 0.3105, 0.1754])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 18, 18, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 18, 18, 19,\n", + " 18, 19, 18, 19, 19, 18, 0])\n", + "loss= tensor(4.2699, grad_fn=) , base rewards= tensor([2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183,\n", + " 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.4183, 2.0290,\n", + " 1.6949, 1.3995, 1.1316, 0.8834, 0.6494, 0.4260, 0.2101]) return= 97928.81160926864\n", + "probs of actions: tensor([0.3446, 0.6577, 0.6444, 0.3681, 0.6642, 0.6525, 0.6800, 0.6510, 0.6417,\n", + " 0.6183, 0.6431, 0.6039, 0.6727, 0.6523, 0.3263, 0.6423, 0.6035, 0.3472,\n", + " 0.6241, 0.3860, 0.4948, 0.3028, 0.2832, 0.7703, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5624, 0.5055, 0.4610, 0.4386, 0.4161, 0.3996, 0.3875, 0.3785,\n", + " 0.3718, 0.3668, 0.3631, 0.3603, 0.3582, 0.3529, 0.3586, 0.3569, 0.3520,\n", + " 0.3579, 0.3527, 0.3584, 0.3531, 0.3550, 0.3602, 0.3905])\n", + "finalReturns: tensor([0.8185, 0.8509, 0.8330, 0.7705, 0.6857, 0.5755, 0.4563, 0.3247, 0.1804])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 19, 18, 19, 18, 18, 19, 18, 19, 19, 19, 18, 19, 18, 19, 18, 19, 19,\n", + " 18, 19, 19, 19, 19, 18, 0])\n", + "loss= tensor(4.4872, grad_fn=) , base rewards= tensor([2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513,\n", + " 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.8513, 2.4309, 2.0693,\n", + " 1.7489, 1.4578, 1.1878, 0.9331, 0.6895, 0.4541, 0.2248]) return= 103665.53870452796\n", + "probs of actions: tensor([0.2510, 0.7391, 0.2437, 0.7508, 0.2622, 0.2638, 0.7149, 0.2397, 0.7548,\n", + " 0.7597, 0.7351, 0.2216, 0.7160, 0.2554, 0.7117, 0.2246, 0.7894, 0.7670,\n", + " 0.2307, 0.7989, 0.8463, 0.7543, 0.7680, 0.3619, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5549, 0.5138, 0.4741, 0.4551, 0.4350, 0.4165, 0.4126, 0.3999,\n", + " 0.3965, 0.3940, 0.3958, 0.3874, 0.3908, 0.3837, 0.3881, 0.3816, 0.3828,\n", + " 0.3874, 0.3812, 0.3825, 0.3834, 0.3842, 0.3884, 0.4180])\n", + "finalReturns: tensor([1.0263, 1.0587, 1.0387, 0.9762, 0.8799, 0.7687, 0.6410, 0.5011, 0.3523,\n", + " 0.1932])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 18, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(3.7333, grad_fn=) , base rewards= tensor([3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 3.0920,\n", + " 3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 3.0920, 2.6659, 2.3003, 1.9772,\n", + " 1.6841, 1.4127, 1.1569, 0.9125, 0.6766, 0.4468, 0.2217]) return= 104293.09788509886\n", + "probs of actions: tensor([0.0991, 0.8924, 0.9044, 0.8958, 0.8924, 0.8902, 0.8814, 0.9084, 0.9020,\n", + " 0.9004, 0.8872, 0.9107, 0.8797, 0.8967, 0.8710, 0.0876, 0.9185, 0.9141,\n", + " 0.9163, 0.9272, 0.9501, 0.9235, 0.9188, 0.8713, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4788, 0.5549, 0.5101, 0.4777, 0.4540, 0.4367, 0.4238, 0.4143, 0.4073,\n", + " 0.4020, 0.3981, 0.3951, 0.3929, 0.3913, 0.3901, 0.3929, 0.3852, 0.3855,\n", + " 0.3857, 0.3859, 0.3860, 0.3861, 0.3862, 0.3862, 0.4224])\n", + "finalReturns: tensor([1.2002, 1.2363, 1.2090, 1.1469, 1.0545, 0.9402, 0.8101, 0.6684, 0.5182,\n", + " 0.3618, 0.2007])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.1330, grad_fn=) , base rewards= tensor([3.0724, 3.0724, 3.0724, 3.0724, 3.0724, 3.0724, 3.0724, 3.0724, 3.0724,\n", + " 3.0724, 3.0724, 3.0724, 3.0724, 3.0724, 2.6699, 2.3266, 2.0248, 1.7523,\n", + " 1.5007, 1.2644, 1.0391, 0.8220, 0.6109, 0.4043, 0.2009]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9851, 0.9828, 0.9857, 0.9825, 0.9828, 0.9817, 0.9803, 0.9868, 0.9846,\n", + " 0.9830, 0.9800, 0.9857, 0.9797, 0.9868, 0.9807, 0.9862, 0.9914, 0.9871,\n", + " 0.9861, 0.9902, 0.9942, 0.9929, 0.9898, 0.9844, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([1.3152, 1.3513, 1.3294, 1.2673, 1.1766, 1.0656, 0.9398, 0.8033, 0.6588,\n", + " 0.5086, 0.3540, 0.1962])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0689, grad_fn=) , base rewards= tensor([3.2779, 3.2779, 3.2779, 3.2779, 3.2779, 3.2779, 3.2779, 3.2779, 3.2779,\n", + " 3.2779, 3.2779, 3.2779, 3.2779, 2.8735, 2.5289, 2.2262, 1.9530, 1.7010,\n", + " 1.4643, 1.2388, 1.0215, 0.8103, 0.6035, 0.4001, 0.1991]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9934, 0.9920, 0.9937, 0.9918, 0.9921, 0.9914, 0.9908, 0.9942, 0.9929,\n", + " 0.9919, 0.9907, 0.9933, 0.9896, 0.9951, 0.9918, 0.9950, 0.9964, 0.9951,\n", + " 0.9949, 0.9964, 0.9983, 0.9980, 0.9968, 0.9942, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([1.4780, 1.5141, 1.4922, 1.4299, 1.3391, 1.2279, 1.1020, 0.9654, 0.8209,\n", + " 0.6706, 0.5160, 0.3582, 0.1980])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0430, grad_fn=) , base rewards= tensor([3.4843, 3.4843, 3.4843, 3.4843, 3.4843, 3.4843, 3.4843, 3.4843, 3.4843,\n", + " 3.4843, 3.4843, 3.4843, 3.0773, 2.7310, 2.4271, 2.1530, 1.9004, 1.6632,\n", + " 1.4374, 1.2198, 1.0084, 0.8015, 0.5979, 0.3969, 0.1978]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9958, 0.9948, 0.9961, 0.9946, 0.9950, 0.9944, 0.9941, 0.9963, 0.9954,\n", + " 0.9947, 0.9939, 0.9959, 0.9941, 0.9979, 0.9955, 0.9974, 0.9982, 0.9979,\n", + " 0.9976, 0.9987, 0.9994, 0.9993, 0.9986, 0.9973, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([1.6425, 1.6786, 1.6565, 1.5941, 1.5031, 1.3918, 1.2657, 1.1290, 0.9844,\n", + " 0.8340, 0.6794, 0.5215, 0.3613, 0.1994])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 10 ep 96876 adversary: AdversaryModes.fight_132\n", + " actions: tensor([18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0057, grad_fn=) , base rewards= tensor([3.9867, 3.9867, 3.9867, 3.9867, 3.9867, 3.9867, 3.9867, 3.9867, 3.9867,\n", + " 3.9867, 3.9867, 3.5525, 3.1814, 2.8543, 2.5585, 2.2850, 2.0277, 1.7823,\n", + " 1.5456, 1.3153, 1.0897, 0.8677, 0.6483, 0.4308, 0.2149]) return= 104376.37516292125\n", + "probs of actions: tensor([8.0187e-04, 9.9891e-01, 9.9926e-01, 9.9889e-01, 9.9902e-01, 9.9886e-01,\n", + " 9.9884e-01, 9.9934e-01, 9.9911e-01, 9.9894e-01, 9.9903e-01, 9.9962e-01,\n", + " 9.9943e-01, 1.0000e+00, 9.9945e-01, 9.9960e-01, 9.9995e-01, 9.9999e-01,\n", + " 9.9977e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9992e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4788, 0.5549, 0.5101, 0.4777, 0.4540, 0.4367, 0.4238, 0.4143, 0.4073,\n", + " 0.4020, 0.3981, 0.3951, 0.3929, 0.3913, 0.3901, 0.3892, 0.3885, 0.3879,\n", + " 0.3876, 0.3873, 0.3871, 0.3869, 0.3868, 0.3867, 0.4227])\n", + "finalReturns: tensor([1.8914, 1.9275, 1.9034, 1.8376, 1.7421, 1.6255, 1.4936, 1.3505, 1.1993,\n", + " 1.0421, 0.8804, 0.7154, 0.5479, 0.3785, 0.2078])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 64 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0079, grad_fn=) , base rewards= tensor([3.9042, 3.9042, 3.9042, 3.9042, 3.9042, 3.9042, 3.9042, 3.9042, 3.9042,\n", + " 3.9042, 3.4893, 3.1375, 2.8297, 2.5529, 2.2983, 2.0597, 1.8328, 1.6145,\n", + " 1.4025, 1.1952, 0.9913, 0.7900, 0.5907, 0.3928, 0.1960]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9992, 0.9989, 0.9993, 0.9989, 0.9990, 0.9989, 0.9988, 0.9993, 0.9991,\n", + " 0.9990, 0.9990, 0.9996, 0.9994, 1.0000, 0.9994, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([1.9757, 2.0118, 1.9893, 1.9262, 1.8347, 1.7229, 1.5964, 1.4593, 1.3144,\n", + " 1.1639, 1.0090, 0.8511, 0.6908, 0.5288, 0.3654, 0.2011])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0104, grad_fn=) , base rewards= tensor([4.1205, 4.1205, 4.1205, 4.1205, 4.1205, 4.1205, 4.1205, 4.1205, 4.1205,\n", + " 3.6995, 3.3435, 3.0328, 2.7539, 2.4977, 2.2581, 2.0304, 1.8115, 1.5990,\n", + " 1.3914, 1.1873, 0.9859, 0.7864, 0.5884, 0.3915, 0.1954]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9992, 0.9989, 0.9993, 0.9989, 0.9990, 0.9989, 0.9988, 0.9993, 0.9991,\n", + " 0.9990, 0.9990, 0.9996, 0.9994, 1.0000, 0.9994, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([2.1443, 2.1804, 2.1575, 2.0941, 2.0021, 1.8898, 1.7631, 1.6257, 1.4806,\n", + " 1.3299, 1.1750, 1.0169, 0.8565, 0.6945, 0.5311, 0.3667, 0.2017])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0124, grad_fn=) , base rewards= tensor([4.3436, 4.3436, 4.3436, 4.3436, 4.3436, 4.3436, 4.3436, 4.3436, 3.9144,\n", + " 3.5528, 3.2380, 2.9563, 2.6982, 2.4571, 2.2283, 2.0086, 1.7956, 1.5875,\n", + " 1.3831, 1.1814, 0.9818, 0.7837, 0.5867, 0.3905, 0.1950]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9992, 0.9989, 0.9993, 0.9989, 0.9990, 0.9989, 0.9988, 0.9993, 0.9991,\n", + " 0.9990, 0.9990, 0.9996, 0.9994, 1.0000, 0.9994, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([2.3143, 2.3504, 2.3271, 2.2631, 2.1705, 2.0577, 1.9305, 1.7928, 1.6475,\n", + " 1.4965, 1.3414, 1.1832, 1.0228, 0.8606, 0.6972, 0.5328, 0.3677, 0.2021])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 98 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0142, grad_fn=) , base rewards= tensor([4.5761, 4.5761, 4.5761, 4.5761, 4.5761, 4.5761, 4.5761, 4.1358, 3.7666,\n", + " 3.4465, 3.1610, 2.9002, 2.6571, 2.4269, 2.2062, 1.9924, 1.7837, 1.5789,\n", + " 1.3769, 1.1770, 0.9787, 0.7816, 0.5854, 0.3898, 0.1947]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9989, 0.9990, 0.9994, 0.9992,\n", + " 0.9991, 0.9991, 0.9996, 0.9994, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([2.4860, 2.5221, 2.4983, 2.4334, 2.3400, 2.2266, 2.0988, 1.9607, 1.8149,\n", + " 1.6637, 1.5084, 1.3500, 1.1894, 1.0272, 0.8637, 0.6992, 0.5341, 0.3685,\n", + " 0.2024])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 43 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0167, grad_fn=) , base rewards= tensor([4.8214, 4.8214, 4.8214, 4.8214, 4.8214, 4.8214, 4.3662, 3.9867, 3.6595,\n", + " 3.3690, 3.1045, 2.8588, 2.6267, 2.4045, 2.1897, 1.9803, 1.7749, 1.5725,\n", + " 1.3723, 1.1737, 0.9764, 0.7801, 0.5844, 0.3892, 0.1945]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([2.6598, 2.6959, 2.6712, 2.6053, 2.5109, 2.3966, 2.2680, 2.1292, 1.9830,\n", + " 1.8314, 1.6758, 1.5172, 1.3565, 1.1941, 1.0305, 0.8660, 0.7008, 0.5351,\n", + " 0.3690, 0.2027])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0199, grad_fn=) , base rewards= tensor([5.0845, 5.0845, 5.0845, 5.0845, 5.0845, 4.6089, 4.2155, 3.8787, 3.5813,\n", + " 3.3120, 3.0628, 2.8281, 2.6041, 2.3879, 2.1774, 1.9713, 1.7683, 1.5677,\n", + " 1.3688, 1.1713, 0.9747, 0.7789, 0.5837, 0.3888, 0.1943]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([2.8362, 2.8723, 2.8465, 2.7792, 2.6835, 2.5679, 2.4383, 2.2987, 2.1518,\n", + " 1.9997, 1.8437, 1.6848, 1.5238, 1.3613, 1.1975, 1.0329, 0.8677, 0.7019,\n", + " 0.5358, 0.3694, 0.2028])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 3 ep 10 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0232, grad_fn=) , base rewards= tensor([5.3719, 5.3719, 5.3719, 5.3719, 4.8686, 4.4563, 4.1064, 3.7998, 3.5239,\n", + " 3.2700, 3.0319, 2.8053, 2.5873, 2.3754, 2.1683, 1.9645, 1.7633, 1.5641,\n", + " 1.3662, 1.1694, 0.9734, 0.7781, 0.5831, 0.3885, 0.1942]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([3.0159, 3.0520, 3.0249, 2.9557, 2.8581, 2.7409, 2.6099, 2.4692, 2.3215,\n", + " 2.1687, 2.0121, 1.8529, 1.6916, 1.5288, 1.3649, 1.2001, 1.0348, 0.8690,\n", + " 0.7028, 0.5364, 0.3697, 0.2030])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0260, grad_fn=) , base rewards= tensor([5.6933, 5.6933, 5.6933, 5.1517, 4.7135, 4.3457, 4.0266, 3.7419, 3.4815,\n", + " 3.2388, 3.0089, 2.7884, 2.5747, 2.3662, 2.1614, 1.9595, 1.7596, 1.5614,\n", + " 1.3643, 1.1680, 0.9725, 0.7774, 0.5827, 0.3883, 0.1941]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([3.2001, 3.2362, 3.2071, 3.1355, 3.0354, 2.9161, 2.7833, 2.6411, 2.4922,\n", + " 2.3385, 2.1812, 2.0214, 1.8597, 1.6966, 1.5325, 1.3676, 1.2021, 1.0362,\n", + " 0.8699, 0.7034, 0.5368, 0.3700, 0.2031])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0299, grad_fn=) , base rewards= tensor([6.0620, 6.0620, 5.4672, 4.9933, 4.6010, 4.2649, 3.9681, 3.6991, 3.4501,\n", + " 3.2157, 2.9918, 2.7757, 2.5653, 2.3592, 2.1563, 1.9557, 1.7569, 1.5593,\n", + " 1.3628, 1.1670, 0.9718, 0.7769, 0.5824, 0.3881, 0.1940]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([3.3901, 3.4262, 3.3946, 3.3197, 3.2163, 3.0940, 2.9588, 2.8147, 2.6642,\n", + " 2.5093, 2.3511, 2.1906, 2.0284, 1.8649, 1.7004, 1.5353, 1.3696, 1.2035,\n", + " 1.0372, 0.8706, 0.7039, 0.5371, 0.3701, 0.2031])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 19, 19, 0])\n", + "loss= tensor(0.0331, grad_fn=) , base rewards= tensor([6.3395, 5.8282, 5.3044, 4.8783, 4.5187, 4.2054, 3.9248, 3.6674, 3.4268,\n", + " 3.1984, 2.9790, 2.7662, 2.5583, 2.3540, 2.1524, 1.9529, 1.7548, 1.5578,\n", + " 1.3617, 1.1662, 0.9712, 0.7766, 0.5822, 0.3880, 0.1939]) return= 99272.14211264676\n", + "probs of actions: tensor([0.9993, 0.9990, 0.9993, 0.9990, 0.9991, 0.9990, 0.9991, 0.9995, 0.9993,\n", + " 0.9992, 0.9991, 0.9996, 0.9995, 1.0000, 0.9995, 0.9996, 0.9999, 1.0000,\n", + " 0.9998, 1.0000, 1.0000, 1.0000, 1.0000, 0.9999, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4751, 0.5587, 0.5055, 0.4672, 0.4394, 0.4191, 0.4042, 0.3931, 0.3849,\n", + " 0.3788, 0.3743, 0.3709, 0.3684, 0.3665, 0.3650, 0.3640, 0.3632, 0.3626,\n", + " 0.3621, 0.3618, 0.3616, 0.3614, 0.3612, 0.3611, 0.3971])\n", + "finalReturns: tensor([3.5878, 3.6239, 3.5889, 3.5096, 3.4019, 3.2758, 3.1373, 2.9905, 2.8380,\n", + " 2.6815, 2.5221, 2.3606, 2.1976, 2.0336, 1.8687, 1.7032, 1.5373, 1.3711,\n", + " 1.2046, 1.0380, 0.8712, 0.7043, 0.5373, 0.3703, 0.2032])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682974149 saved\n", + "[1777102, 'tensor([0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])', 99272.14211264676, 86128.77669412928, 0.033126410096883774, 1e-05, 1, 0, 'tensor([19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\\n 19, 19, 19, 19, 19, 19, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1682974149', 25, 50, 165673.58346428472, 196485.87523713993, 79648.59533906801, 135210.39999999997, 132281.41866666666, 99272.14211264675, 99263.9372312988, 117110.65916440394, 117121.26544005591, 92350.73961268678, 99272.14211264675, 117121.26544005591]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624,\n", + " 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624,\n", + " 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624]) return= 138554.5803254051\n", + "probs of actions: tensor([0.8737, 0.8892, 0.8547, 0.8885, 0.9043, 0.8971, 0.8719, 0.9021, 0.9021,\n", + " 0.8920, 0.8935, 0.8782, 0.8894, 0.8990, 0.8990, 0.9052, 0.8961, 0.8807,\n", + " 0.8858, 0.8928, 0.8808, 0.9072, 0.9093, 0.9040, 0.9838],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5613, 0.5616, 0.5618, 0.5620, 0.5621,\n", + " 0.5622, 0.5623, 0.5623, 0.5624, 0.5624, 0.5624, 0.5624])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 13, 11, 0, 0, 0, 7, 11, 16, 7, 11, 7, 1, 8, 5, 7,\n", + " 1, 5, 6, 11, 13, 11, 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062,\n", + " 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062,\n", + " 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.9062, 0.4390]) return= 116362.73893427021\n", + "probs of actions: tensor([4.2262e-01, 4.3894e-01, 4.4018e-01, 3.8976e-03, 4.5545e-01, 1.8125e-01,\n", + " 1.2230e-01, 1.1571e-01, 4.2787e-02, 4.4436e-01, 9.1077e-04, 5.0764e-02,\n", + " 5.1019e-01, 4.6578e-02, 3.3308e-02, 1.2511e-01, 3.2285e-02, 4.3355e-02,\n", + " 2.2989e-02, 2.9944e-02, 5.5487e-02, 4.7207e-01, 2.5546e-03, 7.9477e-01,\n", + " 9.9147e-01], grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5207, 0.5243, 0.5282, 0.4832, 0.4507, 0.4222,\n", + " 0.4204, 0.4243, 0.4754, 0.4603, 0.4753, 0.4722, 0.4397, 0.4477, 0.4383,\n", + " 0.4445, 0.4234, 0.4214, 0.4156, 0.4293, 0.4550, 0.4762])\n", + "finalReturns: tensor([0.0251, 0.0372])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 89767 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0003, grad_fn=) , base rewards= tensor([1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083,\n", + " 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 1.4083,\n", + " 1.4083, 1.4083, 1.4083, 1.4083, 1.4083, 0.9041, 0.4382]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9818, 0.9901, 0.9821, 0.9903, 0.9905, 0.9868, 0.9907, 0.9941, 0.9928,\n", + " 0.9893, 0.9932, 0.9848, 0.9921, 0.9868, 0.9691, 0.9914, 0.9843, 0.9874,\n", + " 0.9920, 0.9875, 0.9880, 0.9906, 0.9990, 0.9993, 0.9979],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.0801, 0.0922, 0.0660])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 21 ep 39489 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0004, grad_fn=) , base rewards= tensor([1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263,\n", + " 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263, 1.8263,\n", + " 1.8263, 1.8263, 1.8263, 1.8263, 1.3220, 0.8561, 0.4179]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9967, 0.9983, 0.9966, 0.9982, 0.9983, 0.9977, 0.9982, 0.9989, 0.9987,\n", + " 0.9981, 0.9987, 0.9971, 0.9985, 0.9973, 0.9934, 0.9985, 0.9974, 0.9975,\n", + " 0.9984, 0.9977, 0.9977, 0.9990, 0.9999, 0.9999, 0.9970],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.1543, 0.1664, 0.1402, 0.0863])\n", + "----------------------------------------\n", + "iter 2 stage 20 ep 15903 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0008, grad_fn=) , base rewards= tensor([2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295,\n", + " 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295,\n", + " 2.2295, 2.2295, 2.2295, 1.7252, 1.2592, 0.8210, 0.4030]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9983, 0.9991, 0.9982, 0.9991, 0.9991, 0.9988, 0.9990, 0.9994, 0.9993,\n", + " 0.9990, 0.9993, 0.9984, 0.9992, 0.9985, 0.9964, 0.9992, 0.9986, 0.9987,\n", + " 0.9991, 0.9987, 0.9990, 0.9995, 0.9999, 1.0000, 0.9962],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.2433, 0.2554, 0.2292, 0.1753, 0.1011])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 94 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0013, grad_fn=) , base rewards= tensor([2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218,\n", + " 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218,\n", + " 2.6218, 2.6218, 2.1174, 1.6514, 1.2131, 0.7951, 0.3921]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9983, 0.9991, 0.9982, 0.9991, 0.9991, 0.9988, 0.9991, 0.9995, 0.9993,\n", + " 0.9990, 0.9993, 0.9985, 0.9992, 0.9986, 0.9965, 0.9992, 0.9987, 0.9987,\n", + " 0.9992, 0.9990, 0.9990, 0.9995, 0.9999, 1.0000, 0.9961],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.3433, 0.3554, 0.3292, 0.2753, 0.2011, 0.1121])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0019, grad_fn=) , base rewards= tensor([3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061,\n", + " 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061, 3.0061,\n", + " 3.0061, 2.5016, 2.0355, 1.5972, 1.1791, 0.7760, 0.3839]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9983, 0.9991, 0.9982, 0.9991, 0.9991, 0.9988, 0.9991, 0.9995, 0.9993,\n", + " 0.9990, 0.9993, 0.9985, 0.9992, 0.9986, 0.9965, 0.9992, 0.9987, 0.9987,\n", + " 0.9992, 0.9990, 0.9990, 0.9995, 0.9999, 1.0000, 0.9961],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.4515, 0.4636, 0.4374, 0.3835, 0.3093, 0.2202, 0.1202])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 155 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0026, grad_fn=) , base rewards= tensor([3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845,\n", + " 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845, 3.3845,\n", + " 2.8798, 2.4136, 1.9752, 1.5571, 1.1540, 0.7619, 0.3779]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9983, 0.9992, 0.9983, 0.9991, 0.9992, 0.9988, 0.9991, 0.9995, 0.9993,\n", + " 0.9991, 0.9994, 0.9985, 0.9992, 0.9986, 0.9965, 0.9992, 0.9987, 0.9990,\n", + " 0.9994, 0.9990, 0.9991, 0.9996, 0.9999, 1.0000, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.5657, 0.5778, 0.5516, 0.4976, 0.4235, 0.3344, 0.2344, 0.1263])\n", + "----------------------------------------\n", + "iter 2 stage 16 ep 95 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0034, grad_fn=) , base rewards= tensor([3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586,\n", + " 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.7586, 3.2537,\n", + " 2.7873, 2.3488, 1.9307, 1.5275, 1.1353, 0.7513, 0.3734]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9984, 0.9992, 0.9983, 0.9992, 0.9992, 0.9989, 0.9992, 0.9995, 0.9994,\n", + " 0.9991, 0.9994, 0.9986, 0.9993, 0.9987, 0.9966, 0.9993, 0.9990, 0.9991,\n", + " 0.9994, 0.9991, 0.9991, 0.9996, 0.9999, 1.0000, 0.9963],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.6844, 0.6965, 0.6703, 0.6163, 0.5422, 0.4531, 0.3531, 0.2450, 0.1308])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0043, grad_fn=) , base rewards= tensor([4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295,\n", + " 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 4.1295, 3.6244, 3.1578,\n", + " 2.7192, 2.3010, 1.8977, 1.5055, 1.1214, 0.7435, 0.3700]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9984, 0.9992, 0.9983, 0.9992, 0.9992, 0.9989, 0.9992, 0.9995, 0.9994,\n", + " 0.9991, 0.9994, 0.9986, 0.9993, 0.9987, 0.9966, 0.9993, 0.9990, 0.9991,\n", + " 0.9994, 0.9991, 0.9991, 0.9996, 0.9999, 1.0000, 0.9963],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.8065, 0.8186, 0.7924, 0.7384, 0.6642, 0.5752, 0.4751, 0.3670, 0.2528,\n", + " 0.1341])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 11090 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0038, grad_fn=) , base rewards= tensor([4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 4.4983,\n", + " 4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 4.4983, 3.9928, 3.5260, 3.0872,\n", + " 2.6688, 2.2654, 1.8732, 1.4891, 1.1111, 0.7376, 0.3675]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.9311, 0.9432, 0.9170, 0.8630, 0.7888, 0.6997, 0.5997, 0.4915, 0.3774,\n", + " 0.2587, 0.1366])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0048, grad_fn=) , base rewards= tensor([4.8656, 4.8656, 4.8656, 4.8656, 4.8656, 4.8656, 4.8656, 4.8656, 4.8656,\n", + " 4.8656, 4.8656, 4.8656, 4.8656, 4.8656, 4.3597, 3.8925, 3.4535, 3.0349,\n", + " 2.6314, 2.2390, 1.8549, 1.4768, 1.1033, 0.7332, 0.3657]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.0577, 1.0698, 1.0435, 0.9895, 0.9153, 0.8262, 0.7262, 0.6180, 0.5038,\n", + " 0.3851, 0.2631, 0.1385])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 11])\n", + "loss= tensor(0.6158, grad_fn=) , base rewards= tensor([5.2321, 5.2321, 5.2321, 5.2321, 5.2321, 5.2321, 5.2321, 5.2321, 5.2321,\n", + " 5.2321, 5.2321, 5.2321, 5.2321, 4.7256, 4.2580, 3.8186, 3.3998, 2.9961,\n", + " 2.6036, 2.2193, 1.8412, 1.4677, 1.0975, 0.7299, 0.3643]) return= 125450.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.0084],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.4921])\n", + "finalReturns: tensor([1.1735, 1.1856, 1.1594, 1.1053, 1.0311, 0.9420, 0.8419, 0.7337, 0.6195,\n", + " 0.5008, 0.3788, 0.2542, 0.1278])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0069, grad_fn=) , base rewards= tensor([5.5984, 5.5984, 5.5984, 5.5984, 5.5984, 5.5984, 5.5984, 5.5984, 5.5984,\n", + " 5.5984, 5.5984, 5.5984, 5.0910, 4.6228, 4.1830, 3.7639, 3.3600, 2.9673,\n", + " 2.5829, 2.2046, 1.8310, 1.4608, 1.0932, 0.7275, 0.3632]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.3147, 1.3268, 1.3005, 1.2465, 1.1722, 1.0830, 0.9830, 0.8748, 0.7605,\n", + " 0.6418, 0.5198, 0.3952, 0.2688, 0.1410])\n", + "----------------------------------------\n", + "iter 2 stage 10 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0077, grad_fn=) , base rewards= tensor([5.9648, 5.9648, 5.9648, 5.9648, 5.9648, 5.9648, 5.9648, 5.9648, 5.9648,\n", + " 5.9648, 5.9648, 5.4563, 4.9874, 4.5470, 4.1274, 3.7232, 3.3303, 2.9457,\n", + " 2.5674, 2.1937, 1.8234, 1.4557, 1.0900, 0.7257, 0.3624]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.4446, 1.4567, 1.4304, 1.3763, 1.3020, 1.2128, 1.1127, 1.0045, 0.8902,\n", + " 0.7715, 0.6495, 0.5249, 0.3985, 0.2706, 0.1418])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0088, grad_fn=) , base rewards= tensor([6.3321, 6.3321, 6.3321, 6.3321, 6.3321, 6.3321, 6.3321, 6.3321, 6.3321,\n", + " 6.3321, 5.8221, 5.3521, 4.9109, 4.4908, 4.0862, 3.6930, 3.3082, 2.9296,\n", + " 2.5558, 2.1855, 1.8177, 1.4519, 1.0875, 0.7243, 0.3618]) return= 125571.79187222246\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.5753, 1.5874, 1.5610, 1.5068, 1.4325, 1.3433, 1.2431, 1.1348, 1.0206,\n", + " 0.9018, 0.7797, 0.6552, 0.5287, 0.4009, 0.2720, 0.1423])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([6.7008, 6.7008, 6.7008, 6.7008, 6.7008, 6.7008, 6.7008, 6.7008, 6.7008,\n", + " 6.1888, 5.7173, 5.2752, 4.8543, 4.4491, 4.0555, 3.6704, 3.2916, 2.9176,\n", + " 2.5471, 2.1793, 1.8134, 1.4490, 1.0857, 0.7232, 0.3614]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9916],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.7065, 1.7186, 1.6921, 1.6379, 1.5635, 1.4742, 1.3740, 1.2657, 1.1514,\n", + " 1.0326, 0.9105, 0.7859, 0.6594, 0.5316, 0.4027, 0.2730, 0.1428])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0105, grad_fn=) , base rewards= tensor([7.0715, 7.0715, 7.0715, 7.0715, 7.0715, 7.0715, 7.0715, 7.0715, 6.5570,\n", + " 6.0836, 5.6400, 5.2182, 4.8123, 4.4181, 4.0326, 3.6535, 3.2793, 2.9086,\n", + " 2.5407, 2.1747, 1.8102, 1.4469, 1.0844, 0.7225, 0.3611]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.8382, 1.8503, 1.8238, 1.7694, 1.6949, 1.6055, 1.5052, 1.3969, 1.2825,\n", + " 1.1637, 1.0416, 0.9170, 0.7905, 0.6626, 0.5337, 0.4041, 0.2738, 0.1431])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0117, grad_fn=) , base rewards= tensor([7.4454, 7.4454, 7.4454, 7.4454, 7.4454, 7.4454, 7.4454, 6.9273, 6.4514,\n", + " 6.0060, 5.5828, 5.1759, 4.7809, 4.3949, 4.0155, 3.6409, 3.2701, 2.9019,\n", + " 2.5358, 2.1712, 1.8078, 1.4453, 1.0833, 0.7219, 0.3608]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([1.9703, 1.9824, 1.9558, 1.9014, 1.8267, 1.7372, 1.6368, 1.5284, 1.4140,\n", + " 1.2951, 1.1729, 1.0483, 0.9218, 0.7939, 0.6650, 0.5354, 0.4051, 0.2744,\n", + " 0.1434])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0132, grad_fn=) , base rewards= tensor([7.8234, 7.8234, 7.8234, 7.8234, 7.8234, 7.8234, 7.3006, 6.8213, 6.3735,\n", + " 5.9485, 5.5402, 5.1443, 4.7576, 4.3776, 4.0027, 3.6315, 3.2631, 2.8969,\n", + " 2.5322, 2.1687, 1.8060, 1.4440, 1.0826, 0.7215, 0.3606]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.1030, 2.1151, 2.0884, 2.0337, 1.9589, 1.8692, 1.7687, 1.6602, 1.5457,\n", + " 1.4268, 1.3045, 1.1799, 1.0533, 0.9254, 0.7965, 0.6668, 0.5366, 0.4059,\n", + " 0.2748, 0.1436])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([8.2072, 8.2072, 8.2072, 8.2072, 8.2072, 7.6781, 7.1943, 6.7431, 6.3158,\n", + " 5.9058, 5.5086, 5.1208, 4.7401, 4.3647, 3.9931, 3.6244, 3.2580, 2.8931,\n", + " 2.5295, 2.1667, 1.8047, 1.4431, 1.0820, 0.7211, 0.3605]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.2362, 2.2483, 2.2214, 2.1666, 2.0915, 2.0016, 1.9009, 1.7922, 1.6776,\n", + " 1.5586, 1.4363, 1.3116, 1.1850, 1.0571, 0.9282, 0.7985, 0.6682, 0.5375,\n", + " 0.4064, 0.2752, 0.1437])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0158, grad_fn=) , base rewards= tensor([8.5988, 8.5988, 8.5988, 8.5988, 8.0612, 7.5713, 7.1158, 6.6852, 6.2729,\n", + " 5.8739, 5.4849, 5.1033, 4.7271, 4.3550, 3.9859, 3.6192, 3.2541, 2.8903,\n", + " 2.5274, 2.1653, 1.8037, 1.4425, 1.0816, 0.7209, 0.3604]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.3701, 2.3822, 2.3550, 2.2999, 2.2245, 2.1343, 2.0334, 1.9246, 1.8098,\n", + " 1.6907, 1.5683, 1.4435, 1.3169, 1.1889, 1.0599, 0.9302, 0.7999, 0.6692,\n", + " 0.5381, 0.4069, 0.2754, 0.1438])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0183, grad_fn=) , base rewards= tensor([9.0010, 9.0010, 9.0010, 8.4520, 7.9540, 7.4926, 7.0577, 6.6422, 6.2409,\n", + " 5.8502, 5.4673, 5.0901, 4.7173, 4.3477, 3.9806, 3.6152, 3.2512, 2.8881,\n", + " 2.5259, 2.1642, 1.8029, 1.4420, 1.0812, 0.7207, 0.3603]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.5048, 2.5169, 2.4894, 2.4338, 2.3580, 2.2675, 2.1663, 2.0572, 1.9422,\n", + " 1.8229, 1.7004, 1.5755, 1.4489, 1.3208, 1.1918, 1.0621, 0.9317, 0.8010,\n", + " 0.6699, 0.5387, 0.4072, 0.2756, 0.1439])\n", + "----------------------------------------\n", + "iter 2 stage 1 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0198, grad_fn=) , base rewards= tensor([9.4176, 9.4176, 8.8532, 8.3442, 7.8749, 7.4342, 7.0145, 6.6101, 6.2171,\n", + " 5.8325, 5.4541, 5.0803, 4.7100, 4.3423, 3.9765, 3.6122, 3.2490, 2.8866,\n", + " 2.5247, 2.1634, 1.8023, 1.4416, 1.0810, 0.7206, 0.3602]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9995, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.6405, 2.6526, 2.6247, 2.5685, 2.4922, 2.4012, 2.2995, 2.1901, 2.0749,\n", + " 1.9554, 1.8328, 1.7077, 1.5810, 1.4529, 1.3238, 1.1940, 1.0637, 0.9329,\n", + " 0.8018, 0.6705, 0.5390, 0.4074, 0.2757, 0.1439])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 0 adversary: AdversaryModes.fight_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0224, grad_fn=) , base rewards= tensor([9.7796, 9.2684, 8.7446, 8.2646, 7.8162, 7.3909, 6.9823, 6.5862, 6.1993,\n", + " 5.8192, 5.4442, 5.0730, 4.7046, 4.3383, 3.9735, 3.6100, 3.2473, 2.8854,\n", + " 2.5239, 2.1628, 1.8019, 1.4413, 1.0808, 0.7205, 0.3602]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9992, 0.9996, 0.9991, 0.9995, 0.9996, 0.9994, 0.9995, 0.9997, 0.9996,\n", + " 0.9995, 0.9996, 0.9992, 0.9996, 0.9993, 0.9990, 0.9997, 0.9998, 0.9997,\n", + " 0.9997, 0.9996, 0.9995, 0.9998, 1.0000, 1.0000, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([2.7775, 2.7896, 2.7612, 2.7043, 2.6272, 2.5355, 2.4333, 2.3235, 2.2079,\n", + " 2.0881, 1.9653, 1.8401, 1.7132, 1.5850, 1.4559, 1.3260, 1.1956, 1.0649,\n", + " 0.9338, 0.8024, 0.6709, 0.5393, 0.4076, 0.2758, 0.1440])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682983428 saved\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[396616, 'tensor([0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])', 125571.79187222246, 95728.31346963784, 0.022367581725120544, 1e-05, 1, 0, 'tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\\n 11, 11, 11, 11, 11, 11, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.99]', '0,[1e-05,1][1, 10000, 1, 1],1682983428', 25, 50, 156312.25008636713, 172508.0785299521, 67091.50476852678, 135143.75466666667, 132277.408, 125571.79187222247, 125571.79187222247, 128010.77984270274, 128010.77984270274, 78103.35371185312, 125571.79187222247, 128010.77984270274]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624,\n", + " 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624,\n", + " 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624, 0.5624]) return= 138554.5803254051\n", + "probs of actions: tensor([0.8580, 0.8369, 0.8854, 0.8691, 0.8611, 0.8791, 0.8596, 0.8337, 0.8636,\n", + " 0.8863, 0.8837, 0.8661, 0.8775, 0.8598, 0.8728, 0.8699, 0.8710, 0.8759,\n", + " 0.8779, 0.8717, 0.8976, 0.8724, 0.8831, 0.8544, 0.9742],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5613, 0.5616, 0.5618, 0.5620, 0.5621,\n", + " 0.5622, 0.5623, 0.5623, 0.5624, 0.5624, 0.5624, 0.5624])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 12, 11, 0, 0, 9, 11, 12, 17, 8, 13, 0, 9, 9, 10, 0, 10, 10,\n", + " 20, 10, 0, 0, 16, 12, 0])\n", + "loss= tensor(0.0255, grad_fn=) , base rewards= tensor([0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069,\n", + " 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069,\n", + " 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.8069, 0.3898]) return= 108454.93368961285\n", + "probs of actions: tensor([0.1475, 0.0568, 0.0506, 0.2173, 0.2489, 0.1672, 0.0495, 0.0950, 0.0052,\n", + " 0.0350, 0.1080, 0.1715, 0.1418, 0.1597, 0.0460, 0.3593, 0.0511, 0.0653,\n", + " 0.0013, 0.0516, 0.3377, 0.2581, 0.0042, 0.3484, 0.9947],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5575, 0.5313, 0.5190, 0.4628, 0.4147, 0.4106, 0.4148, 0.4085,\n", + " 0.4540, 0.4305, 0.4545, 0.4087, 0.4101, 0.4093, 0.4233, 0.3844, 0.3945,\n", + " 0.3722, 0.4409, 0.4471, 0.4115, 0.3602, 0.4027, 0.4282])\n", + "finalReturns: tensor([0.0240, 0.0384])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([ 7, 13, 13, 13, 13, 13, 13, 13, 12, 0, 13, 13, 13, 17, 13, 13, 13, 12,\n", + " 13, 13, 13, 13, 13, 12, 0])\n", + "loss= tensor(0.0636, grad_fn=) , base rewards= tensor([1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083,\n", + " 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 1.1083,\n", + " 1.1083, 1.1083, 1.1083, 1.1083, 1.1083, 0.7025, 0.3368]) return= 106345.43462592686\n", + "probs of actions: tensor([0.0019, 0.8371, 0.8408, 0.8583, 0.8412, 0.8676, 0.8239, 0.7916, 0.1241,\n", + " 0.0167, 0.8616, 0.8110, 0.8468, 0.0015, 0.8177, 0.8115, 0.8583, 0.1668,\n", + " 0.7993, 0.8224, 0.8249, 0.8218, 0.9099, 0.5416, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.5063, 0.5326, 0.5852, 0.5327, 0.4949, 0.4674, 0.4473, 0.4325, 0.4240,\n", + " 0.4270, 0.3638, 0.3701, 0.3749, 0.3665, 0.3940, 0.3929, 0.3920, 0.3939,\n", + " 0.3877, 0.3882, 0.3885, 0.3888, 0.3889, 0.3916, 0.4029])\n", + "finalReturns: tensor([0.0751, 0.0920, 0.0661])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 12, 13, 13, 14, 13, 12, 0])\n", + "loss= tensor(1.2667, grad_fn=) , base rewards= tensor([1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831,\n", + " 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831, 1.6831,\n", + " 1.6831, 1.6831, 1.6831, 1.6831, 1.2086, 0.7775, 0.3774]) return= 119140.59757259364\n", + "probs of actions: tensor([0.9729, 0.9534, 0.9539, 0.9617, 0.9595, 0.9673, 0.0031, 0.9340, 0.9457,\n", + " 0.9719, 0.9712, 0.9486, 0.9622, 0.9698, 0.9563, 0.9580, 0.9652, 0.9294,\n", + " 0.0450, 0.9563, 0.9583, 0.0017, 0.9820, 0.3256, 0.9998],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4784, 0.4791, 0.4741,\n", + " 0.4704, 0.4676, 0.4655, 0.4639, 0.4627, 0.4618, 0.4612, 0.4607, 0.4603,\n", + " 0.4625, 0.4564, 0.4571, 0.4549, 0.4615, 0.4634, 0.4739])\n", + "finalReturns: tensor([0.1705, 0.1901, 0.1599, 0.0965])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 12, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0540, grad_fn=) , base rewards= tensor([2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488,\n", + " 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488, 2.0488,\n", + " 2.0488, 2.0488, 2.0488, 1.5726, 1.1403, 0.7394, 0.3614]) return= 118964.00360478487\n", + "probs of actions: tensor([0.9881, 0.9788, 0.9789, 0.9827, 0.9821, 0.9856, 0.9772, 0.9685, 0.9748,\n", + " 0.9878, 0.9878, 0.0196, 0.9830, 0.9867, 0.9804, 0.9813, 0.9843, 0.9665,\n", + " 0.9737, 0.9803, 0.9839, 0.9912, 0.9935, 0.7924, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4669, 0.4596, 0.4595, 0.4594, 0.4594, 0.4593, 0.4593,\n", + " 0.4593, 0.4593, 0.4592, 0.4592, 0.4592, 0.4592, 0.4761])\n", + "finalReturns: tensor([0.2643, 0.2812, 0.2543, 0.1959, 0.1147])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 58190 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0039, grad_fn=) , base rewards= tensor([2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993,\n", + " 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993, 2.3993,\n", + " 2.3993, 2.3993, 1.9227, 1.4901, 1.0889, 0.7107, 0.3492]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9991, 0.9983, 0.9984, 0.9987, 0.9986, 0.9990, 0.9981, 0.9974, 0.9981,\n", + " 0.9992, 0.9991, 0.9981, 0.9987, 0.9989, 0.9984, 0.9985, 0.9988, 0.9975,\n", + " 0.9980, 0.9990, 0.9994, 0.9997, 0.9998, 0.9864, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([0.3745, 0.3914, 0.3644, 0.3061, 0.2249, 0.1270])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 1091 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0049, grad_fn=) , base rewards= tensor([2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400,\n", + " 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400, 2.7400,\n", + " 2.7400, 2.2632, 1.8304, 1.4292, 1.0509, 0.6894, 0.3402]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9991, 0.9983, 0.9984, 0.9987, 0.9986, 0.9990, 0.9982, 0.9974, 0.9981,\n", + " 0.9992, 0.9992, 0.9981, 0.9987, 0.9990, 0.9984, 0.9985, 0.9988, 0.9975,\n", + " 0.9990, 0.9990, 0.9994, 0.9998, 0.9998, 0.9863, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([0.4937, 0.5106, 0.4836, 0.4253, 0.3441, 0.2462, 0.1361])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 11404 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0041, grad_fn=) , base rewards= tensor([3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808,\n", + " 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808, 3.4808,\n", + " 2.9476, 2.4609, 2.0076, 1.5787, 1.1675, 0.7695, 0.3812]) return= 130250.32620960443\n", + "probs of actions: tensor([1.3511e-04, 9.9879e-01, 9.9887e-01, 9.9912e-01, 9.9907e-01, 9.9933e-01,\n", + " 9.9877e-01, 9.9826e-01, 9.9875e-01, 9.9946e-01, 9.9946e-01, 9.9876e-01,\n", + " 9.9916e-01, 9.9934e-01, 9.9897e-01, 9.9902e-01, 9.9923e-01, 9.9906e-01,\n", + " 9.9938e-01, 9.9941e-01, 9.9971e-01, 9.9991e-01, 9.9989e-01, 9.9131e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4991, 0.5475, 0.5395, 0.5336, 0.5292, 0.5259, 0.5234, 0.5215, 0.5201,\n", + " 0.5191, 0.5183, 0.5177, 0.5173, 0.5170, 0.5167, 0.5166, 0.5164, 0.5163,\n", + " 0.5162, 0.5162, 0.5161, 0.5161, 0.5161, 0.5161, 0.5329])\n", + "finalReturns: tensor([0.6652, 0.6821, 0.6526, 0.5897, 0.5025, 0.3975, 0.2795, 0.1518])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0054, grad_fn=) , base rewards= tensor([3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037,\n", + " 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 3.4037, 2.9264,\n", + " 2.4932, 2.0917, 1.7132, 1.3515, 1.0022, 0.6619, 0.3284]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9993, 0.9988, 0.9989, 0.9991, 0.9990, 0.9993, 0.9987, 0.9981, 0.9986,\n", + " 0.9994, 0.9994, 0.9986, 0.9991, 0.9993, 0.9988, 0.9989, 0.9991, 0.9989,\n", + " 0.9993, 0.9993, 0.9997, 0.9999, 0.9999, 0.9904, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([0.7505, 0.7674, 0.7405, 0.6821, 0.6009, 0.5030, 0.3928, 0.2737, 0.1478])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 15 ep 38 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0065, grad_fn=) , base rewards= tensor([3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298,\n", + " 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.7298, 3.2521, 2.8186,\n", + " 2.4169, 2.0383, 1.6765, 1.3270, 0.9867, 0.6532, 0.3247]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9988, 0.9989, 0.9991, 0.9990, 0.9993, 0.9987, 0.9981, 0.9986,\n", + " 0.9994, 0.9994, 0.9986, 0.9991, 0.9993, 0.9989, 0.9990, 0.9992, 0.9990,\n", + " 0.9993, 0.9993, 0.9997, 0.9999, 0.9999, 0.9905, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([0.8853, 0.9022, 0.8752, 0.8168, 0.7355, 0.6376, 0.5275, 0.4083, 0.2824,\n", + " 0.1515])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 64 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 4.0537,\n", + " 4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 4.0537, 3.5754, 3.1415, 2.7396,\n", + " 2.3607, 1.9987, 1.6492, 1.3088, 0.9752, 0.6467, 0.3220]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9988, 0.9989, 0.9991, 0.9990, 0.9993, 0.9987, 0.9981, 0.9987,\n", + " 0.9994, 0.9994, 0.9987, 0.9991, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9993, 0.9994, 0.9997, 0.9999, 0.9999, 0.9906, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.0228, 1.0397, 1.0127, 0.9542, 0.8730, 0.7751, 0.6649, 0.5457, 0.4198,\n", + " 0.2889, 0.1543])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0091, grad_fn=) , base rewards= tensor([4.3761, 4.3761, 4.3761, 4.3761, 4.3761, 4.3761, 4.3761, 4.3761, 4.3761,\n", + " 4.3761, 4.3761, 4.3761, 4.3761, 4.3761, 3.8971, 3.4627, 3.0604, 2.6813,\n", + " 2.3191, 1.9694, 1.6289, 1.2953, 0.9667, 0.6419, 0.3199]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9988, 0.9989, 0.9991, 0.9990, 0.9993, 0.9987, 0.9982, 0.9987,\n", + " 0.9994, 0.9994, 0.9987, 0.9991, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9993, 0.9994, 0.9997, 0.9999, 0.9999, 0.9906, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.1624, 1.1793, 1.1523, 1.0938, 1.0125, 0.9146, 0.8044, 0.6852, 0.5592,\n", + " 0.4283, 0.2937, 0.1563])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0108, grad_fn=) , base rewards= tensor([4.6979, 4.6979, 4.6979, 4.6979, 4.6979, 4.6979, 4.6979, 4.6979, 4.6979,\n", + " 4.6979, 4.6979, 4.6979, 4.6979, 4.2179, 3.7828, 3.3800, 3.0005, 2.6381,\n", + " 2.2882, 1.9476, 1.6138, 1.2851, 0.9603, 0.6382, 0.3183]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9988, 0.9989, 0.9991, 0.9990, 0.9993, 0.9987, 0.9982, 0.9987,\n", + " 0.9994, 0.9994, 0.9987, 0.9991, 0.9993, 0.9990, 0.9991, 0.9993, 0.9990,\n", + " 0.9993, 0.9994, 0.9997, 0.9999, 0.9999, 0.9906, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.3037, 1.3206, 1.2936, 1.2350, 1.1537, 1.0557, 0.9455, 0.8262, 0.7003,\n", + " 0.5694, 0.4347, 0.2973, 0.1579])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 197 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0113, grad_fn=) , base rewards= tensor([5.0197, 5.0197, 5.0197, 5.0197, 5.0197, 5.0197, 5.0197, 5.0197, 5.0197,\n", + " 5.0197, 5.0197, 5.0197, 4.5384, 4.1024, 3.6989, 3.3190, 2.9562, 2.6060,\n", + " 2.2652, 1.9313, 1.6025, 1.2776, 0.9555, 0.6355, 0.3172]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9989, 0.9989, 0.9992, 0.9991, 0.9993, 0.9988, 0.9982, 0.9987,\n", + " 0.9994, 0.9994, 0.9990, 0.9993, 0.9995, 0.9992, 0.9992, 0.9994, 0.9990,\n", + " 0.9994, 0.9994, 0.9997, 0.9999, 0.9999, 0.9910, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.4463, 1.4632, 1.4361, 1.3775, 1.2961, 1.1980, 1.0878, 0.9685, 0.8425,\n", + " 0.7116, 0.5769, 0.4395, 0.3001, 0.1591])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0126, grad_fn=) , base rewards= tensor([5.3422, 5.3422, 5.3422, 5.3422, 5.3422, 5.3422, 5.3422, 5.3422, 5.3422,\n", + " 5.3422, 5.3422, 4.8592, 4.4220, 4.0176, 3.6370, 3.2738, 2.9233, 2.5822,\n", + " 2.2481, 1.9191, 1.5941, 1.2719, 0.9519, 0.6335, 0.3163]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9989, 0.9989, 0.9992, 0.9991, 0.9993, 0.9988, 0.9982, 0.9987,\n", + " 0.9994, 0.9994, 0.9990, 0.9993, 0.9995, 0.9992, 0.9992, 0.9994, 0.9990,\n", + " 0.9994, 0.9994, 0.9997, 0.9999, 0.9999, 0.9910, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.5898, 1.6067, 1.5796, 1.5209, 1.4394, 1.3413, 1.2310, 1.1116, 0.9856,\n", + " 0.8546, 0.7200, 0.5826, 0.4431, 0.3021, 0.1599])\n", + "----------------------------------------\n", + "iter 0 stage 9 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0140, grad_fn=) , base rewards= tensor([5.6662, 5.6662, 5.6662, 5.6662, 5.6662, 5.6662, 5.6662, 5.6662, 5.6662,\n", + " 5.6662, 5.1809, 4.7421, 4.3365, 3.9550, 3.5911, 3.2402, 2.8987, 2.5644,\n", + " 2.2353, 1.9101, 1.5878, 1.2677, 0.9492, 0.6320, 0.3156]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9989, 0.9989, 0.9992, 0.9991, 0.9993, 0.9988, 0.9982, 0.9987,\n", + " 0.9994, 0.9994, 0.9990, 0.9993, 0.9995, 0.9992, 0.9992, 0.9994, 0.9990,\n", + " 0.9994, 0.9994, 0.9997, 0.9999, 0.9999, 0.9910, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.7342, 1.7511, 1.7239, 1.6651, 1.5835, 1.4853, 1.3749, 1.2555, 1.1294,\n", + " 0.9984, 0.8637, 0.7263, 0.5868, 0.4458, 0.3036, 0.1606])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 8 ep 109 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([5.9926, 5.9926, 5.9926, 5.9926, 5.9926, 5.9926, 5.9926, 5.9926, 5.9926,\n", + " 5.5042, 5.0631, 4.6560, 4.2733, 3.9086, 3.5570, 3.2151, 2.8804, 2.5511,\n", + " 2.2257, 1.9033, 1.5831, 1.2645, 0.9472, 0.6308, 0.3152]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9994, 0.9989, 0.9990, 0.9992, 0.9992, 0.9994, 0.9988, 0.9984, 0.9990,\n", + " 0.9996, 0.9996, 0.9991, 0.9994, 0.9995, 0.9993, 0.9992, 0.9995, 0.9991,\n", + " 0.9994, 0.9994, 0.9997, 0.9999, 0.9999, 0.9917, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([1.8793, 1.8962, 1.8689, 1.8100, 1.7283, 1.6299, 1.5194, 1.3999, 1.2738,\n", + " 1.1427, 1.0080, 0.8705, 0.7310, 0.5900, 0.4478, 0.3047, 0.1611])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 3450 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0113, grad_fn=) , base rewards= tensor([6.3224, 6.3224, 6.3224, 6.3224, 6.3224, 6.3224, 6.3224, 6.3224, 5.8299,\n", + " 5.3859, 4.9766, 4.5924, 4.2265, 3.8741, 3.5316, 3.1965, 2.8668, 2.5411,\n", + " 2.2185, 1.8982, 1.5795, 1.2622, 0.9457, 0.6300, 0.3148]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.0251, 2.0420, 2.0146, 1.9555, 1.8736, 1.7750, 1.6644, 1.5448, 1.4186,\n", + " 1.2874, 1.1527, 1.0152, 0.8756, 0.7345, 0.5923, 0.4493, 0.3056, 0.1614])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0138, grad_fn=) , base rewards= tensor([6.6570, 6.6570, 6.6570, 6.6570, 6.6570, 6.6570, 6.6570, 6.1590, 5.7110,\n", + " 5.2989, 4.9127, 4.5453, 4.1918, 3.8484, 3.5127, 3.1825, 2.8566, 2.5337,\n", + " 2.2132, 1.8944, 1.5769, 1.2604, 0.9446, 0.6293, 0.3145]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.1717, 2.1886, 2.1609, 2.1016, 2.0194, 1.9207, 1.8098, 1.6901, 1.5637,\n", + " 1.4325, 1.2977, 1.1601, 1.0205, 0.8794, 0.7372, 0.5941, 0.4504, 0.3062,\n", + " 0.1617])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0154, grad_fn=) , base rewards= tensor([6.9983, 6.9983, 6.9983, 6.9983, 6.9983, 6.9983, 6.4928, 6.0396, 5.6236,\n", + " 5.2347, 4.8653, 4.5103, 4.1659, 3.8293, 3.4985, 3.1721, 2.8489, 2.5281,\n", + " 2.2092, 1.8915, 1.5749, 1.2590, 0.9437, 0.6289, 0.3143]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.3190, 2.3359, 2.3080, 2.2483, 2.1658, 2.0668, 1.9557, 1.8357, 1.7092,\n", + " 1.5779, 1.4429, 1.3053, 1.1657, 1.0245, 0.8823, 0.7392, 0.5955, 0.4513,\n", + " 0.3067, 0.1619])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0175, grad_fn=) , base rewards= tensor([7.3486, 7.3486, 7.3486, 7.3486, 7.3486, 6.8331, 6.3728, 5.9518, 5.5591,\n", + " 5.1870, 4.8301, 4.4842, 4.1465, 3.8150, 3.4879, 3.1643, 2.8432, 2.5240,\n", + " 2.2061, 1.8894, 1.5734, 1.2580, 0.9431, 0.6285, 0.3142]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.4672, 2.4841, 2.4559, 2.3957, 2.3128, 2.2134, 2.1020, 1.9818, 1.8551,\n", + " 1.7236, 1.5885, 1.4507, 1.3110, 1.1698, 1.0275, 0.8844, 0.7407, 0.5965,\n", + " 0.4519, 0.3071, 0.1621])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0196, grad_fn=) , base rewards= tensor([7.7112, 7.7112, 7.7112, 7.7112, 7.1822, 6.7124, 6.2846, 5.8870, 5.5113,\n", + " 5.1517, 4.8038, 4.4647, 4.1321, 3.8043, 3.4800, 3.1585, 2.8389, 2.5208,\n", + " 2.2039, 1.8878, 1.5723, 1.2573, 0.9426, 0.6282, 0.3140]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.6167, 2.6336, 2.6048, 2.5441, 2.4606, 2.3606, 2.2488, 2.1282, 2.0012,\n", + " 1.8695, 1.7343, 1.5964, 1.4566, 1.3153, 1.1730, 1.0298, 0.8860, 0.7418,\n", + " 0.5972, 0.4524, 0.3073, 0.1622])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0223, grad_fn=) , base rewards= tensor([8.0905, 8.0905, 8.0905, 7.5434, 7.0607, 6.6237, 6.2194, 5.8389, 5.4757,\n", + " 5.1253, 4.7843, 4.4502, 4.1213, 3.7963, 3.4741, 3.1541, 2.8357, 2.5185,\n", + " 2.2022, 1.8866, 1.5715, 1.2567, 0.9423, 0.6280, 0.3140]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9994,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finalReturns: tensor([2.7675, 2.7844, 2.7551, 2.6936, 2.6093, 2.5086, 2.3962, 2.2752, 2.1478,\n", + " 2.0158, 1.8803, 1.7423, 1.6023, 1.4610, 1.3185, 1.1753, 1.0315, 0.8872,\n", + " 0.7426, 0.5978, 0.4527, 0.3075, 0.1623])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0253, grad_fn=) , base rewards= tensor([8.4928, 8.4928, 7.9208, 7.4207, 6.9713, 6.5581, 6.1711, 5.8032, 5.4492,\n", + " 5.1056, 4.7696, 4.4393, 4.1132, 3.7903, 3.4697, 3.1508, 2.8333, 2.5167,\n", + " 2.2009, 1.8857, 1.5708, 1.2563, 0.9420, 0.6279, 0.3139]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9995,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([2.9203, 2.9372, 2.9071, 2.8445, 2.7591, 2.6576, 2.5444, 2.4227, 2.2948,\n", + " 2.1624, 2.0267, 1.8884, 1.7483, 1.6068, 1.4642, 1.3209, 1.1771, 1.0328,\n", + " 0.8881, 0.7432, 0.5982, 0.4530, 0.3077, 0.1623])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 13, 13, 13, 13, 13, 0])\n", + "loss= tensor(0.0272, grad_fn=) , base rewards= tensor([8.8318, 8.3206, 7.7967, 7.3305, 6.9053, 6.5095, 6.1352, 5.7766, 5.4295,\n", + " 5.0909, 4.7587, 4.4312, 4.1072, 3.7858, 3.4663, 3.1484, 2.8315, 2.5154,\n", + " 2.2000, 1.8850, 1.5704, 1.2560, 0.9418, 0.6278, 0.3138]) return= 119073.90192566637\n", + "probs of actions: tensor([0.9995, 0.9991, 0.9992, 0.9993, 0.9993, 0.9995, 0.9990, 0.9990, 0.9995,\n", + " 0.9998, 0.9996, 0.9996, 0.9998, 0.9999, 0.9994, 0.9993, 0.9998, 0.9994,\n", + " 0.9995, 0.9996, 0.9999, 1.0000, 0.9999, 0.9931, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4943, 0.5550, 0.5302, 0.5120, 0.4986, 0.4886, 0.4811, 0.4756, 0.4715,\n", + " 0.4684, 0.4661, 0.4644, 0.4631, 0.4621, 0.4614, 0.4608, 0.4604, 0.4601,\n", + " 0.4599, 0.4597, 0.4596, 0.4595, 0.4594, 0.4594, 0.4762])\n", + "finalReturns: tensor([3.0756, 3.0925, 3.0613, 2.9973, 2.9105, 2.8077, 2.6935, 2.5710, 2.4424,\n", + " 2.3095, 2.1734, 2.0348, 1.8944, 1.7528, 1.6101, 1.4667, 1.3227, 1.1784,\n", + " 1.0337, 0.8888, 0.7437, 0.5985, 0.4532, 0.3078, 0.1624])\n", + "0,[1e-05,1][1, 10000, 1, 1],1682999908 saved\n", + "[674563, 'tensor([0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])', 119073.90192566637, 95284.79046306085, 0.027228858321905136, 1e-05, 1, 0, 'tensor([13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\\n 13, 13, 13, 13, 13, 13, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.99 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1682999908', 25, 50, 158873.58343048888, 178559.0269066819, 70287.27661109495, 135436.67200000002, 132554.6666666667, 119073.90192566635, 119073.90192566635, 125827.28267117329, 125827.28267117329, 81831.91688437786, 119073.90192566635, 125827.28267117329]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718,\n", + " 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718,\n", + " 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718, 0.4718]) return= 131596.28685975395\n", + "probs of actions: tensor([0.9367, 0.9428, 0.9187, 0.9468, 0.9307, 0.9152, 0.9421, 0.9478, 0.9220,\n", + " 0.9468, 0.9338, 0.9398, 0.9479, 0.0224, 0.9485, 0.9489, 0.9547, 0.9500,\n", + " 0.9286, 0.9317, 0.9214, 0.0105, 0.9444, 0.9322, 0.9943],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5573,\n", + " 0.5586, 0.5595, 0.5603, 0.5608, 0.5612, 0.5653, 0.5386, 0.5190, 0.5046,\n", + " 0.4938, 0.4859, 0.4800, 0.4751, 0.4791, 0.4749, 0.4718])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([ 9, 10, 4, 9, 9, 0, 0, 7, 10, 10, 9, 0, 11, 9, 7, 0, 9, 8,\n", + " 7, 8, 8, 9, 9, 9, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901,\n", + " 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901,\n", + " 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.7901, 0.3823]) return= 106695.37744149746\n", + "probs of actions: tensor([0.4556, 0.1081, 0.0112, 0.4412, 0.4102, 0.1664, 0.2821, 0.0526, 0.1414,\n", + " 0.1179, 0.4751, 0.2725, 0.0115, 0.4704, 0.0645, 0.2235, 0.4843, 0.0924,\n", + " 0.0722, 0.1001, 0.0992, 0.3777, 0.4121, 0.6827, 0.9964],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.5469, 0.5947, 0.5226, 0.4935, 0.4803, 0.4345, 0.3968, 0.3897,\n", + " 0.3977, 0.4057, 0.4152, 0.3756, 0.3937, 0.4012, 0.4030, 0.3707, 0.3823,\n", + " 0.3882, 0.3869, 0.3901, 0.3909, 0.3959, 0.3997, 0.4106])\n", + "finalReturns: tensor([0.0202, 0.0283])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([10, 10, 9, 10, 9, 10, 10, 9, 10, 10, 16, 10, 9, 10, 9, 10, 10, 10,\n", + " 10, 11, 16, 9, 11, 10, 0])\n", + "loss= tensor(0.2371, grad_fn=) , base rewards= tensor([1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213,\n", + " 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 1.2213,\n", + " 1.2213, 1.2213, 1.2213, 1.2213, 1.2213, 0.7816, 0.3779]) return= 113419.76902528579\n", + "probs of actions: tensor([0.5822, 0.5528, 0.2460, 0.5698, 0.2272, 0.5105, 0.5893, 0.2325, 0.5383,\n", + " 0.5680, 0.0183, 0.5190, 0.2591, 0.5497, 0.2466, 0.5711, 0.5934, 0.5512,\n", + " 0.5538, 0.0713, 0.0181, 0.2689, 0.0841, 0.4928, 0.9997],\n", + " grad_fn=)\n", + "rewards: tensor([0.5012, 0.5506, 0.5911, 0.5393, 0.5089, 0.4798, 0.4634, 0.4531, 0.4389,\n", + " 0.4330, 0.4131, 0.4455, 0.4398, 0.4290, 0.4276, 0.4199, 0.4189, 0.4181,\n", + " 0.4175, 0.4150, 0.4044, 0.4407, 0.4276, 0.4295, 0.4360])\n", + "finalReturns: tensor([0.0718, 0.0839, 0.0582])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 16, 20, 20, 16, 16, 20, 20, 20, 20, 20, 10, 14, 20, 16, 16, 20, 16,\n", + " 16, 20, 16, 16, 16, 14, 0])\n", + "loss= tensor(0.8845, grad_fn=) , base rewards= tensor([1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640,\n", + " 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640, 1.1640,\n", + " 1.1640, 1.1640, 1.1640, 1.1640, 0.8126, 0.5105, 0.2430]) return= 91897.17702893353\n", + "probs of actions: tensor([0.5741, 0.2196, 0.5670, 0.5593, 0.1998, 0.2072, 0.5479, 0.5890, 0.5455,\n", + " 0.5652, 0.5592, 0.0451, 0.0846, 0.5561, 0.2024, 0.2001, 0.5917, 0.1945,\n", + " 0.2057, 0.5518, 0.2183, 0.1572, 0.1927, 0.1121, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5731, 0.4861, 0.4486, 0.4358, 0.4027, 0.3643, 0.3593, 0.3555,\n", + " 0.3527, 0.3506, 0.3791, 0.3378, 0.3062, 0.3299, 0.3251, 0.3071, 0.3306,\n", + " 0.3256, 0.3075, 0.3309, 0.3259, 0.3221, 0.3252, 0.3369])\n", + "finalReturns: tensor([0.1460, 0.1716, 0.1516, 0.0939])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0227, grad_fn=) , base rewards= tensor([1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830,\n", + " 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830, 1.4830,\n", + " 1.4830, 1.4830, 1.4830, 1.0978, 0.7724, 0.4884, 0.2338]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9743, 0.9730, 0.9708, 0.9723, 0.9681, 0.9578, 0.9686, 0.9745, 0.9643,\n", + " 0.9707, 0.9698, 0.9638, 0.9648, 0.9697, 0.9709, 0.9736, 0.9771, 0.9706,\n", + " 0.9658, 0.9669, 0.9809, 0.9906, 0.9810, 0.9655, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([0.2814, 0.3214, 0.3019, 0.2410, 0.1509])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 19 ep 75221 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([16, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476,\n", + " 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476, 2.2476,\n", + " 2.2476, 2.2476, 1.7571, 1.3343, 0.9589, 0.6172, 0.2998]) return= 116915.56065675804\n", + "probs of actions: tensor([0.0013, 0.9986, 0.9984, 0.9986, 0.9983, 0.9976, 0.9984, 0.9988, 0.9981,\n", + " 0.9985, 0.9985, 0.9982, 0.9982, 0.9985, 0.9986, 0.9988, 0.9990, 0.9986,\n", + " 0.9983, 0.9991, 0.9993, 0.9998, 0.9994, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4856, 0.5433, 0.5192, 0.5015, 0.4884, 0.4786, 0.4714, 0.4660, 0.4620,\n", + " 0.4590, 0.4567, 0.4550, 0.4538, 0.4528, 0.4521, 0.4516, 0.4512, 0.4509,\n", + " 0.4507, 0.4505, 0.4504, 0.4503, 0.4502, 0.4502, 0.4901])\n", + "finalReturns: tensor([0.4940, 0.5340, 0.5065, 0.4316, 0.3231, 0.1903])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 10555 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([16, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351,\n", + " 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351, 2.5351,\n", + " 2.5351, 2.0444, 1.6215, 1.2460, 0.9042, 0.5868, 0.2870]) return= 116915.56065675804\n", + "probs of actions: tensor([8.3469e-04, 9.9912e-01, 9.9896e-01, 9.9913e-01, 9.9889e-01, 9.9846e-01,\n", + " 9.9898e-01, 9.9922e-01, 9.9876e-01, 9.9908e-01, 9.9905e-01, 9.9887e-01,\n", + " 9.9881e-01, 9.9905e-01, 9.9910e-01, 9.9924e-01, 9.9937e-01, 9.9911e-01,\n", + " 9.9914e-01, 9.9956e-01, 9.9962e-01, 9.9994e-01, 9.9966e-01, 9.9913e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4856, 0.5433, 0.5192, 0.5015, 0.4884, 0.4786, 0.4714, 0.4660, 0.4620,\n", + " 0.4590, 0.4567, 0.4550, 0.4538, 0.4528, 0.4521, 0.4516, 0.4512, 0.4509,\n", + " 0.4507, 0.4505, 0.4504, 0.4503, 0.4502, 0.4502, 0.4901])\n", + "finalReturns: tensor([0.6572, 0.6972, 0.6697, 0.5948, 0.4862, 0.3535, 0.2032])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 51 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0027, grad_fn=) , base rewards= tensor([2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125,\n", + " 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125, 2.1125,\n", + " 1.7262, 1.4000, 1.1155, 0.8604, 0.6264, 0.4075, 0.1997]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9991, 0.9991, 0.9989, 0.9991, 0.9988, 0.9983, 0.9988, 0.9991, 0.9986,\n", + " 0.9989, 0.9989, 0.9986, 0.9986, 0.9989, 0.9989, 0.9991, 0.9992, 0.9990,\n", + " 0.9990, 0.9995, 0.9995, 0.9999, 0.9996, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([0.6896, 0.7296, 0.7100, 0.6490, 0.5588, 0.4478, 0.3219, 0.1849])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0038, grad_fn=) , base rewards= tensor([2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083,\n", + " 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 2.3083, 1.9214,\n", + " 1.5947, 1.3099, 1.0547, 0.8205, 0.6015, 0.3936, 0.1938]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9991, 0.9991, 0.9989, 0.9991, 0.9988, 0.9983, 0.9988, 0.9991, 0.9986,\n", + " 0.9989, 0.9989, 0.9986, 0.9986, 0.9989, 0.9989, 0.9991, 0.9992, 0.9990,\n", + " 0.9990, 0.9995, 0.9995, 0.9999, 0.9996, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([0.8407, 0.8807, 0.8611, 0.8000, 0.7098, 0.5988, 0.4728, 0.3358, 0.1909])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0052, grad_fn=) , base rewards= tensor([2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005,\n", + " 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.5005, 2.1127, 1.7854,\n", + " 1.5002, 1.2447, 1.0103, 0.7912, 0.5831, 0.3833, 0.1894]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9991, 0.9991, 0.9989, 0.9991, 0.9988, 0.9983, 0.9988, 0.9991, 0.9986,\n", + " 0.9989, 0.9989, 0.9986, 0.9986, 0.9989, 0.9989, 0.9991, 0.9992, 0.9990,\n", + " 0.9990, 0.9995, 0.9995, 0.9999, 0.9996, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([0.9963, 1.0363, 1.0166, 0.9555, 0.8653, 0.7542, 0.6281, 0.4911, 0.3461,\n", + " 0.1952])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 37 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0065, grad_fn=) , base rewards= tensor([2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.6904,\n", + " 2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.6904, 2.3015, 1.9734, 1.6877,\n", + " 1.4317, 1.1971, 0.9777, 0.7696, 0.5696, 0.3756, 0.1862]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9992, 0.9991, 0.9990, 0.9991, 0.9988, 0.9983, 0.9989, 0.9991, 0.9986,\n", + " 0.9989, 0.9989, 0.9987, 0.9986, 0.9989, 0.9990, 0.9991, 0.9993, 0.9991,\n", + " 0.9990, 0.9995, 0.9995, 0.9999, 0.9996, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.1554, 1.1954, 1.1756, 1.1144, 1.0240, 0.9129, 0.7867, 0.6497, 0.5047,\n", + " 0.3538, 0.1985])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 122 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0081, grad_fn=) , base rewards= tensor([2.8792, 2.8792, 2.8792, 2.8792, 2.8792, 2.8792, 2.8792, 2.8792, 2.8792,\n", + " 2.8792, 2.8792, 2.8792, 2.8792, 2.8792, 2.4887, 2.1597, 1.8732, 1.6167,\n", + " 1.3817, 1.1621, 0.9537, 0.7536, 0.5595, 0.3700, 0.1837]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9991, 0.9991, 0.9989, 0.9991, 0.9988, 0.9983, 0.9988, 0.9991, 0.9985,\n", + " 0.9989, 0.9989, 0.9986, 0.9986, 0.9990, 0.9991, 0.9992, 0.9994, 0.9991,\n", + " 0.9990, 0.9994, 0.9995, 0.9999, 0.9996, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.3170, 1.3570, 1.3372, 1.2759, 1.1854, 1.0741, 0.9479, 0.8108, 0.6657,\n", + " 0.5147, 0.3594, 0.2009])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 12 ep 263 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0084, grad_fn=) , base rewards= tensor([3.0679, 3.0679, 3.0679, 3.0679, 3.0679, 3.0679, 3.0679, 3.0679, 3.0679,\n", + " 3.0679, 3.0679, 3.0679, 3.0679, 2.6754, 2.3450, 2.0575, 1.8003, 1.5648,\n", + " 1.3448, 1.1362, 0.9359, 0.7417, 0.5520, 0.3657, 0.1819]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9993, 0.9992, 0.9991, 0.9992, 0.9989, 0.9985, 0.9990, 0.9992, 0.9987,\n", + " 0.9990, 0.9990, 0.9988, 0.9990, 0.9992, 0.9993, 0.9994, 0.9995, 0.9993,\n", + " 0.9991, 0.9995, 0.9996, 0.9999, 0.9996, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.4808, 1.5208, 1.5008, 1.4393, 1.3487, 1.2373, 1.1109, 0.9737, 0.8286,\n", + " 0.6775, 0.5222, 0.3637, 0.2027])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 203 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0104, grad_fn=) , base rewards= tensor([3.2577, 3.2577, 3.2577, 3.2577, 3.2577, 3.2577, 3.2577, 3.2577, 3.2577,\n", + " 3.2577, 3.2577, 3.2577, 2.8625, 2.5301, 2.2414, 1.9833, 1.7471, 1.5266,\n", + " 1.3176, 1.1171, 0.9227, 0.7329, 0.5465, 0.3626, 0.1806]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9990, 0.9992, 0.9989, 0.9984, 0.9990, 0.9992, 0.9987,\n", + " 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9993, 0.9995, 0.9995, 0.9993,\n", + " 0.9991, 0.9995, 0.9996, 0.9999, 0.9996, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.6463, 1.6863, 1.6661, 1.6044, 1.5136, 1.4020, 1.2755, 1.1381, 0.9929,\n", + " 0.8418, 0.6864, 0.5278, 0.3668, 0.2041])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 31 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0128, grad_fn=) , base rewards= tensor([3.4496, 3.4496, 3.4496, 3.4496, 3.4496, 3.4496, 3.4496, 3.4496, 3.4496,\n", + " 3.4496, 3.4496, 3.0507, 2.7159, 2.4254, 2.1660, 1.9289, 1.7078, 1.4984,\n", + " 1.2975, 1.1028, 0.9128, 0.7263, 0.5423, 0.3602, 0.1796]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9990, 0.9991, 0.9989, 0.9984, 0.9989, 0.9992, 0.9987,\n", + " 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9993, 0.9995, 0.9995, 0.9993,\n", + " 0.9990, 0.9995, 0.9996, 0.9999, 0.9996, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.8132, 1.8532, 1.8329, 1.7709, 1.6798, 1.5679, 1.4412, 1.3037, 1.1583,\n", + " 1.0071, 0.8516, 0.6930, 0.5319, 0.3692, 0.2051])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0154, grad_fn=) , base rewards= tensor([3.6449, 3.6449, 3.6449, 3.6449, 3.6449, 3.6449, 3.6449, 3.6449, 3.6449,\n", + " 3.6449, 3.2412, 2.9030, 2.6101, 2.3491, 2.1108, 1.8889, 1.6788, 1.4775,\n", + " 1.2825, 1.0922, 0.9055, 0.7214, 0.5392, 0.3585, 0.1788]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9990, 0.9991, 0.9989, 0.9984, 0.9989, 0.9992, 0.9987,\n", + " 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9993, 0.9995, 0.9995, 0.9993,\n", + " 0.9990, 0.9995, 0.9996, 0.9999, 0.9996, 0.9990, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([1.9816, 2.0216, 2.0010, 1.9386, 1.8471, 1.7349, 1.6079, 1.4702, 1.3246,\n", + " 1.1733, 1.0177, 0.8590, 0.6979, 0.5351, 0.3709, 0.2058])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 4590 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0115, grad_fn=) , base rewards= tensor([3.8453, 3.8453, 3.8453, 3.8453, 3.8453, 3.8453, 3.8453, 3.8453, 3.8453,\n", + " 3.4351, 3.0924, 2.7964, 2.5332, 2.2933, 2.0702, 1.8593, 1.6573, 1.4619,\n", + " 1.2713, 1.0843, 0.9000, 0.7177, 0.5369, 0.3571, 0.1783]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9993, 0.9991, 0.9987, 0.9991, 0.9993, 0.9990,\n", + " 0.9998, 0.9993, 0.9994, 0.9992, 0.9998, 0.9996, 0.9998, 0.9997, 0.9994,\n", + " 0.9992, 0.9996, 0.9997, 1.0000, 0.9997, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([2.1515, 2.1915, 2.1704, 2.1076, 2.0155, 1.9029, 1.7756, 1.6375, 1.4917,\n", + " 1.3402, 1.1845, 1.0256, 0.8645, 0.7016, 0.5374, 0.3722, 0.2064])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0136, grad_fn=) , base rewards= tensor([4.0530, 4.0530, 4.0530, 4.0530, 4.0530, 4.0530, 4.0530, 4.0530, 3.6339,\n", + " 3.2852, 2.9850, 2.7188, 2.4768, 2.2522, 2.0402, 1.8374, 1.6413, 1.4503,\n", + " 1.2630, 1.0784, 0.8959, 0.7149, 0.5351, 0.3562, 0.1778]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9993, 0.9991, 0.9987, 0.9991, 0.9993, 0.9990,\n", + " 0.9998, 0.9993, 0.9994, 0.9992, 0.9998, 0.9996, 0.9998, 0.9997, 0.9994,\n", + " 0.9992, 0.9996, 0.9997, 1.0000, 0.9997, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([2.3229, 2.3629, 2.3413, 2.2778, 2.1851, 2.0719, 1.9440, 1.8056, 1.6595,\n", + " 1.5077, 1.3518, 1.1928, 1.0315, 0.8686, 0.7043, 0.5391, 0.3732, 0.2068])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0162, grad_fn=) , base rewards= tensor([4.2707, 4.2707, 4.2707, 4.2707, 4.2707, 4.2707, 4.2707, 3.8397, 3.4828,\n", + " 3.1770, 2.9068, 2.6620, 2.4353, 2.2218, 2.0179, 1.8210, 1.6294, 1.4416,\n", + " 1.2567, 1.0740, 0.8928, 0.7129, 0.5338, 0.3554, 0.1775]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9993, 0.9991, 0.9987, 0.9991, 0.9993, 0.9990,\n", + " 0.9998, 0.9993, 0.9994, 0.9992, 0.9998, 0.9996, 0.9998, 0.9997, 0.9994,\n", + " 0.9992, 0.9996, 0.9997, 1.0000, 0.9997, 0.9992, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([2.4962, 2.5362, 2.5140, 2.4495, 2.3560, 2.2420, 2.1134, 1.9745, 1.8279,\n", + " 1.6758, 1.5196, 1.3605, 1.1990, 1.0359, 0.8716, 0.7064, 0.5404, 0.3740,\n", + " 0.2071])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 5 ep 9276 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 16, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0145, grad_fn=) , base rewards= tensor([4.4575, 4.4575, 4.4575, 4.4575, 4.4575, 4.4575, 4.0237, 3.6649, 3.3577,\n", + " 3.0866, 2.8411, 2.6139, 2.4000, 2.1958, 1.9988, 1.8070, 1.6192, 1.4342,\n", + " 1.2514, 1.0702, 0.8902, 0.7111, 0.5327, 0.3548, 0.1772]) return= 95556.53901947841\n", + "probs of actions: tensor([9.9949e-01, 9.9946e-01, 9.9936e-01, 9.9944e-01, 7.3200e-04, 9.9900e-01,\n", + " 9.9951e-01, 9.9947e-01, 9.9918e-01, 9.9991e-01, 9.9956e-01, 9.9956e-01,\n", + " 9.9941e-01, 9.9991e-01, 9.9975e-01, 9.9983e-01, 9.9981e-01, 9.9959e-01,\n", + " 9.9938e-01, 9.9969e-01, 9.9974e-01, 1.0000e+00, 9.9982e-01, 9.9942e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4434, 0.3938, 0.3812, 0.3718, 0.3649,\n", + " 0.3597, 0.3559, 0.3530, 0.3508, 0.3492, 0.3480, 0.3471, 0.3464, 0.3459,\n", + " 0.3455, 0.3453, 0.3450, 0.3449, 0.3448, 0.3447, 0.3846])\n", + "finalReturns: tensor([2.6650, 2.7050, 2.6826, 2.6180, 2.5242, 2.4100, 2.2813, 2.1422, 1.9956,\n", + " 1.8434, 1.6872, 1.5279, 1.3665, 1.2034, 1.0390, 0.8738, 0.7078, 0.5413,\n", + " 0.3745, 0.2074])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0170, grad_fn=) , base rewards= tensor([4.7526, 4.7526, 4.7526, 4.7526, 4.7526, 4.2835, 3.9008, 3.5771, 3.2943,\n", + " 3.0405, 2.8074, 2.5891, 2.3818, 2.1824, 1.9889, 1.7998, 1.6138, 1.4303,\n", + " 1.2486, 1.0682, 0.8888, 0.7102, 0.5321, 0.3544, 0.1771]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9995, 0.9995, 0.9994, 0.9994, 0.9993, 0.9990, 0.9995, 0.9995, 0.9992,\n", + " 0.9999, 0.9996, 0.9996, 0.9994, 0.9999, 0.9998, 0.9998, 0.9998, 0.9996,\n", + " 0.9994, 0.9997, 0.9997, 1.0000, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([2.8504, 2.8904, 2.8660, 2.7988, 2.7025, 2.5860, 2.4554, 2.3148, 2.1670,\n", + " 2.0138, 1.8569, 1.6971, 1.5352, 1.3718, 1.2072, 1.0417, 0.8756, 0.7091,\n", + " 0.5421, 0.3749, 0.2075])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0192, grad_fn=) , base rewards= tensor([5.0293, 5.0293, 5.0293, 5.0293, 4.5301, 4.1271, 3.7894, 3.4968, 3.2361,\n", + " 2.9979, 2.7761, 2.5661, 2.3648, 2.1699, 1.9797, 1.7930, 1.6089, 1.4267,\n", + " 1.2460, 1.0663, 0.8875, 0.7093, 0.5316, 0.3541, 0.1770]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9995, 0.9995, 0.9994, 0.9994, 0.9993, 0.9990, 0.9995, 0.9995, 0.9992,\n", + " 0.9999, 0.9996, 0.9996, 0.9994, 0.9999, 0.9998, 0.9998, 0.9998, 0.9996,\n", + " 0.9994, 0.9997, 0.9997, 1.0000, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([3.0328, 3.0728, 3.0468, 2.9775, 2.8790, 2.7607, 2.6286, 2.4867, 2.3378,\n", + " 2.1839, 2.0264, 1.8661, 1.7039, 1.5402, 1.3754, 1.2098, 1.0436, 0.8769,\n", + " 0.7099, 0.5427, 0.3753, 0.2077])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0217, grad_fn=) , base rewards= tensor([5.3425, 5.3425, 5.3425, 4.8018, 4.3708, 4.0140, 3.7081, 3.4380, 3.1931,\n", + " 2.9665, 2.7529, 2.5490, 2.3522, 2.1605, 1.9728, 1.7879, 1.6051, 1.4240,\n", + " 1.2440, 1.0650, 0.8866, 0.7087, 0.5311, 0.3539, 0.1769]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9995, 0.9995, 0.9994, 0.9994, 0.9993, 0.9990, 0.9995, 0.9995, 0.9992,\n", + " 0.9999, 0.9996, 0.9996, 0.9994, 0.9999, 0.9998, 0.9998, 0.9998, 0.9996,\n", + " 0.9994, 0.9997, 0.9997, 1.0000, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([3.2203, 3.2603, 3.2321, 3.1600, 3.0587, 2.9379, 2.8037, 2.6601, 2.5099,\n", + " 2.3549, 2.1966, 2.0357, 1.8730, 1.7090, 1.5439, 1.3781, 1.2117, 1.0450,\n", + " 0.8779, 0.7106, 0.5431, 0.3755, 0.2078])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0241, grad_fn=) , base rewards= tensor([5.7070, 5.7070, 5.1084, 4.6387, 4.2556, 3.9315, 3.6486, 3.3946, 3.1614,\n", + " 2.9431, 2.7357, 2.5362, 2.3427, 2.1535, 1.9676, 1.7841, 1.6023, 1.4219,\n", + " 1.2426, 1.0639, 0.8858, 0.7082, 0.5308, 0.3537, 0.1768]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9995, 0.9995, 0.9994, 0.9994, 0.9993, 0.9990, 0.9995, 0.9995, 0.9992,\n", + " 0.9999, 0.9996, 0.9996, 0.9994, 0.9999, 0.9998, 0.9998, 0.9998, 0.9996,\n", + " 0.9994, 0.9997, 0.9997, 1.0000, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([3.4144, 3.4544, 3.4234, 3.3474, 3.2424, 3.1183, 2.9813, 2.8354, 2.6835,\n", + " 2.5271, 2.3677, 2.2060, 2.0427, 1.8782, 1.7128, 1.5467, 1.3801, 1.2132,\n", + " 1.0460, 0.8786, 0.7111, 0.5434, 0.3757, 0.2079])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 0])\n", + "loss= tensor(0.0264, grad_fn=) , base rewards= tensor([5.9753, 5.4641, 4.9403, 4.5206, 4.1715, 3.8710, 3.6046, 3.3625, 3.1378,\n", + " 2.9257, 2.7228, 2.5267, 2.3357, 2.1483, 1.9637, 1.7812, 1.6003, 1.4204,\n", + " 1.2415, 1.0631, 0.8853, 0.7078, 0.5306, 0.3536, 0.1767]) return= 95926.91902269641\n", + "probs of actions: tensor([0.9995, 0.9995, 0.9994, 0.9994, 0.9993, 0.9990, 0.9995, 0.9995, 0.9992,\n", + " 0.9999, 0.9996, 0.9996, 0.9994, 0.9999, 0.9998, 0.9998, 0.9998, 0.9996,\n", + " 0.9994, 0.9997, 0.9997, 1.0000, 0.9998, 0.9994, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4712, 0.5587, 0.5007, 0.4591, 0.4290, 0.4071, 0.3910, 0.3791, 0.3703,\n", + " 0.3637, 0.3588, 0.3552, 0.3525, 0.3505, 0.3489, 0.3478, 0.3470, 0.3463,\n", + " 0.3458, 0.3455, 0.3452, 0.3450, 0.3449, 0.3447, 0.3847])\n", + "finalReturns: tensor([3.6174, 3.6574, 3.6225, 3.5415, 3.4315, 3.3029, 3.1622, 3.0134, 2.8590,\n", + " 2.7009, 2.5400, 2.3772, 2.2131, 2.0479, 1.8820, 1.7156, 1.5488, 1.3817,\n", + " 1.2143, 1.0468, 0.8792, 0.7114, 0.5436, 0.3758, 0.2079])\n", + "0,[1e-05,1][1, 10000, 1, 1],1683019988 saved\n", + "[700369, 'tensor([0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])', 95926.91902269641, 83461.56370671562, 0.026398321613669395, 1e-05, 1, 0, 'tensor([20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\\n 20, 20, 20, 20, 20, 20, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1683019988', 25, 50, 166678.00013679263, 199440.72542558872, 81175.85726043607, 135011.53866666666, 132074.72800000003, 95926.91902269641, 95926.91902269641, 113529.90192566635, 113488.54729640356, 94070.91886744411, 95926.91902269641, 113529.90192566635]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335,\n", + " 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335,\n", + " 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335, 0.4335]) return= 123480.07884867929\n", + "probs of actions: tensor([0.8697, 0.8787, 0.8837, 0.8861, 0.9065, 0.8957, 0.9092, 0.9046, 0.0033,\n", + " 0.8968, 0.0717, 0.8905, 0.8930, 0.8939, 0.8652, 0.9085, 0.8924, 0.8947,\n", + " 0.8934, 0.8794, 0.8891, 0.8795, 0.8696, 0.8838, 0.9802],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334, 0.5406, 0.5460, 0.5501, 0.5532, 0.5555, 0.5548,\n", + " 0.5774, 0.5389, 0.5146, 0.4932, 0.4774, 0.4658, 0.4571, 0.4507, 0.4459,\n", + " 0.4423, 0.4396, 0.4376, 0.4361, 0.4350, 0.4342, 0.4335])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 2 stage 23 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 10, 11, 8, 9, 0, 0, 11, 10, 9, 0, 6, 0, 8, 6, 11, 9, 6,\n", + " 0, 4, 1, 6, 9, 12, 0])\n", + "loss= tensor(0.0690, grad_fn=) , base rewards= tensor([0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430,\n", + " 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430,\n", + " 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.8430, 0.4124]) return= 113897.17236003252\n", + "probs of actions: tensor([0.3751, 0.0684, 0.3539, 0.0686, 0.1139, 0.2947, 0.1850, 0.3508, 0.0738,\n", + " 0.1131, 0.1590, 0.0437, 0.2453, 0.0760, 0.0570, 0.3085, 0.1086, 0.0428,\n", + " 0.2804, 0.0067, 0.0272, 0.0505, 0.1165, 0.0645, 0.9907],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5544, 0.5332, 0.5284, 0.5081, 0.5061, 0.4672, 0.4270, 0.4449,\n", + " 0.4555, 0.4667, 0.4351, 0.4379, 0.4113, 0.4251, 0.4183, 0.4402, 0.4516,\n", + " 0.4502, 0.4251, 0.4223, 0.4059, 0.4079, 0.4162, 0.4518])\n", + "finalReturns: tensor([0.0250, 0.0394])\n", + "----------------------------------------\n", + "iter 2 stage 22 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0053, grad_fn=) , base rewards= tensor([1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927,\n", + " 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 1.3927,\n", + " 1.3927, 1.3927, 1.3927, 1.3927, 1.3927, 0.8954, 0.4345]) return= 124264.57333060534\n", + "probs of actions: tensor([0.9427, 0.9337, 0.9446, 0.9470, 0.9577, 0.9128, 0.9357, 0.9532, 0.9385,\n", + " 0.9313, 0.9501, 0.9403, 0.9314, 0.9393, 0.9421, 0.0346, 0.9357, 0.9234,\n", + " 0.9208, 0.9168, 0.9496, 0.9306, 0.9677, 0.9730, 0.9974],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.5051, 0.4545, 0.4637,\n", + " 0.4707, 0.4760, 0.4800, 0.4830, 0.4852, 0.4869, 0.5003])\n", + "finalReturns: tensor([0.0797, 0.0918, 0.0658])\n", + "----------------------------------------\n", + "iter 2 stage 21 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 12, 11, 11, 11, 0])\n", + "loss= tensor(0.0080, grad_fn=) , base rewards= tensor([1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357,\n", + " 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357, 1.8357,\n", + " 1.8357, 1.8357, 1.8357, 1.8357, 1.3278, 0.8593, 0.4193]) return= 125646.00419333146\n", + "probs of actions: tensor([0.9796, 0.9785, 0.9838, 0.9819, 0.9860, 0.9745, 0.9773, 0.9863, 0.9773,\n", + " 0.9804, 0.9844, 0.9810, 0.9799, 0.9795, 0.9794, 0.9820, 0.9782, 0.9743,\n", + " 0.9818, 0.9728, 0.0102, 0.9734, 0.9912, 0.9842, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4899, 0.4957, 0.4948, 0.4941, 0.5057])\n", + "finalReturns: tensor([0.1547, 0.1668, 0.1405, 0.0864])\n", + "----------------------------------------\n", + "iter 2 stage 20 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 11, 11, 11, 0])\n", + "loss= tensor(0.0292, grad_fn=) , base rewards= tensor([2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295,\n", + " 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295, 2.2295,\n", + " 2.2295, 2.2295, 2.2295, 1.7252, 1.2592, 0.8210, 0.4030]) return= 125571.79187222246\n", + "probs of actions: tensor([0.9680, 0.9685, 0.9766, 0.9720, 0.9780, 0.9648, 0.9629, 0.9802, 0.9639,\n", + " 0.9731, 0.9777, 0.9711, 0.9713, 0.9694, 0.9686, 0.9748, 0.9664, 0.9592,\n", + " 0.9771, 0.9606, 0.9766, 0.9474, 0.9886, 0.9610, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4923, 0.4922, 0.4922, 0.4921, 0.4921, 0.5042])\n", + "finalReturns: tensor([0.2433, 0.2554, 0.2292, 0.1753, 0.1011])\n", + "----------------------------------------\n", + "iter 2 stage 19 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 12, 12, 11, 11, 11, 0])\n", + "loss= tensor(1.7093, grad_fn=) , base rewards= tensor([2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218,\n", + " 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218, 2.6218,\n", + " 2.6218, 2.6218, 2.1174, 1.6514, 1.2131, 0.7951, 0.3921]) return= 125731.65338382448\n", + "probs of actions: tensor([0.8931, 0.8975, 0.9188, 0.9044, 0.9218, 0.8893, 0.8750, 0.9309, 0.8813,\n", + " 0.9124, 0.9239, 0.9041, 0.9058, 0.8980, 0.8968, 0.9130, 0.8879, 0.8648,\n", + " 0.9240, 0.1488, 0.0878, 0.8260, 0.9609, 0.8325, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5523, 0.5369, 0.5255, 0.5170, 0.5107, 0.5060, 0.5025, 0.4998,\n", + " 0.4979, 0.4964, 0.4953, 0.4945, 0.4939, 0.4934, 0.4930, 0.4928, 0.4926,\n", + " 0.4924, 0.4900, 0.4935, 0.4984, 0.4968, 0.4956, 0.5068])\n", + "finalReturns: tensor([0.3593, 0.3737, 0.3463, 0.2861, 0.2073, 0.1147])\n", + "----------------------------------------\n", + "iter 2 stage 18 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 11, 12, 11, 12, 12, 12, 12, 12, 12, 11, 11, 12, 12,\n", + " 12, 11, 12, 12, 12, 12, 0])\n", + "loss= tensor(1.3323, grad_fn=) , base rewards= tensor([2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592,\n", + " 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592, 2.8592,\n", + " 2.8592, 2.3724, 1.9258, 1.5082, 1.1117, 0.7307, 0.3611]) return= 121796.3805407076\n", + "probs of actions: tensor([0.7982, 0.7813, 0.7673, 0.7875, 0.7589, 0.2079, 0.8283, 0.2679, 0.8133,\n", + " 0.7479, 0.7430, 0.7761, 0.7679, 0.7932, 0.2071, 0.2261, 0.8062, 0.8390,\n", + " 0.7591, 0.1343, 0.8476, 0.8865, 0.7336, 0.9199, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.5020, 0.4901, 0.4887, 0.4802,\n", + " 0.4790, 0.4782, 0.4775, 0.4770, 0.4767, 0.4787, 0.4750, 0.4699, 0.4714,\n", + " 0.4724, 0.4755, 0.4703, 0.4716, 0.4726, 0.4734, 0.4883])\n", + "finalReturns: tensor([0.4650, 0.4794, 0.4505, 0.3978, 0.3226, 0.2310, 0.1272])\n", + "----------------------------------------\n", + "iter 2 stage 17 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0642, grad_fn=) , base rewards= tensor([3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258,\n", + " 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258, 3.2258,\n", + " 2.7355, 2.2864, 1.8670, 1.4692, 1.0872, 0.7169, 0.3553]) return= 122213.81800409526\n", + "probs of actions: tensor([0.9715, 0.9674, 0.9688, 0.9709, 0.9668, 0.9693, 0.9768, 0.9617, 0.9737,\n", + " 0.0387, 0.9627, 0.9676, 0.9658, 0.9710, 0.9709, 0.9687, 0.9726, 0.9801,\n", + " 0.9701, 0.9851, 0.9858, 0.9873, 0.9717, 0.9934, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4855, 0.4778, 0.4772, 0.4768, 0.4765, 0.4763, 0.4761, 0.4760, 0.4759,\n", + " 0.4758, 0.4758, 0.4757, 0.4757, 0.4757, 0.4757, 0.4900])\n", + "finalReturns: tensor([0.5944, 0.6088, 0.5821, 0.5258, 0.4478, 0.3541, 0.2487, 0.1348])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 16 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788,\n", + " 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.5788, 3.0878,\n", + " 2.6382, 2.2184, 1.8203, 1.4382, 1.0677, 0.7059, 0.3506]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9930, 0.9917, 0.9927, 0.9930, 0.9921, 0.9921, 0.9943, 0.9909, 0.9935,\n", + " 0.9904, 0.9909, 0.9920, 0.9915, 0.9928, 0.9930, 0.9926, 0.9944, 0.9954,\n", + " 0.9950, 0.9971, 0.9974, 0.9972, 0.9951, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([0.7197, 0.7341, 0.7074, 0.6510, 0.5731, 0.4793, 0.3739, 0.2599, 0.1395])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 99999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270,\n", + " 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.4356, 2.9858,\n", + " 2.5658, 2.1676, 1.7854, 1.4148, 1.0530, 0.6976, 0.3470]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9975, 0.9970, 0.9975, 0.9976, 0.9973, 0.9971, 0.9980, 0.9969, 0.9977,\n", + " 0.9966, 0.9968, 0.9972, 0.9970, 0.9974, 0.9976, 0.9985, 0.9987, 0.9989,\n", + " 0.9986, 0.9990, 0.9995, 0.9995, 0.9989, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([0.8485, 0.8629, 0.8361, 0.7797, 0.7018, 0.6080, 0.5026, 0.3886, 0.2682,\n", + " 0.1431])\n", + "----------------------------------------\n", + "iter 2 stage 15 ep 117999 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0040, grad_fn=) , base rewards= tensor([3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270,\n", + " 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.9270, 3.4356, 2.9858,\n", + " 2.5658, 2.1676, 1.7854, 1.4148, 1.0530, 0.6976, 0.3470]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9982, 0.9978, 0.9982, 0.9983, 0.9981, 0.9979, 0.9985, 0.9978, 0.9983,\n", + " 0.9975, 0.9977, 0.9980, 0.9978, 0.9981, 0.9983, 0.9990, 0.9990, 0.9992,\n", + " 0.9994, 0.9993, 0.9997, 0.9997, 0.9993, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([0.8485, 0.8629, 0.8361, 0.7797, 0.7018, 0.6080, 0.5026, 0.3886, 0.2682,\n", + " 0.1431])\n", + "----------------------------------------\n", + "iter 2 stage 14 ep 908 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0052, grad_fn=) , base rewards= tensor([4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.5483,\n", + " 4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.5483, 4.0289, 3.5520, 3.1059,\n", + " 2.6822, 2.2749, 1.8797, 1.4934, 1.1138, 0.7392, 0.3682]) return= 127915.76530179875\n", + "probs of actions: tensor([0.0017, 0.9979, 0.9983, 0.9983, 0.9982, 0.9980, 0.9986, 0.9979, 0.9985,\n", + " 0.9977, 0.9979, 0.9982, 0.9979, 0.9983, 0.9990, 0.9991, 0.9991, 0.9993,\n", + " 0.9994, 0.9993, 0.9997, 0.9997, 0.9994, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5500, 0.5383, 0.5296, 0.5232, 0.5183, 0.5147, 0.5120, 0.5100,\n", + " 0.5085, 0.5074, 0.5065, 0.5059, 0.5054, 0.5051, 0.5048, 0.5046, 0.5045,\n", + " 0.5043, 0.5043, 0.5042, 0.5041, 0.5041, 0.5041, 0.5185])\n", + "finalReturns: tensor([1.0141, 1.0285, 1.0006, 0.9421, 0.8614, 0.7644, 0.6553, 0.5374, 0.4128,\n", + " 0.2834, 0.1503])\n", + "----------------------------------------\n", + "iter 2 stage 13 ep 3619 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0067, grad_fn=) , base rewards= tensor([4.9158, 4.9158, 4.9158, 4.9158, 4.9158, 4.9158, 4.9158, 4.9158, 4.9158,\n", + " 4.9158, 4.9158, 4.9158, 4.9158, 4.9158, 4.3960, 3.9188, 3.4725, 3.0487,\n", + " 2.6413, 2.2460, 1.8597, 1.4800, 1.1054, 0.7344, 0.3662]) return= 127915.76530179875\n", + "probs of actions: tensor([0.0018, 0.9979, 0.9983, 0.9983, 0.9982, 0.9980, 0.9986, 0.9979, 0.9984,\n", + " 0.9977, 0.9979, 0.9982, 0.9979, 0.9990, 0.9990, 0.9991, 0.9991, 0.9993,\n", + " 0.9994, 0.9993, 0.9997, 0.9997, 0.9994, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4991, 0.5500, 0.5383, 0.5296, 0.5232, 0.5183, 0.5147, 0.5120, 0.5100,\n", + " 0.5085, 0.5074, 0.5065, 0.5059, 0.5054, 0.5051, 0.5048, 0.5046, 0.5045,\n", + " 0.5043, 0.5043, 0.5042, 0.5041, 0.5041, 0.5041, 0.5185])\n", + "finalReturns: tensor([1.1521, 1.1665, 1.1386, 1.0801, 0.9994, 0.9023, 0.7932, 0.6753, 0.5507,\n", + " 0.4213, 0.2882, 0.1523])\n", + "----------------------------------------\n", + "iter 2 stage 12 ep 18243 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0071, grad_fn=) , base rewards= tensor([4.9612, 4.9612, 4.9612, 4.9612, 4.9612, 4.9612, 4.9612, 4.9612, 4.9612,\n", + " 4.9612, 4.9612, 4.9612, 4.9612, 4.4680, 4.0168, 3.5959, 3.1970, 2.8143,\n", + " 2.4434, 2.0812, 1.7256, 1.3749, 1.0278, 0.6833, 0.3409]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9984, 0.9981, 0.9984, 0.9985, 0.9983, 0.9981, 0.9987, 0.9981, 0.9985,\n", + " 0.9978, 0.9980, 0.9983, 0.9990, 0.9992, 0.9991, 0.9992, 0.9991, 0.9993,\n", + " 0.9999, 0.9993, 0.9997, 0.9999, 0.9995, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.2484, 1.2628, 1.2360, 1.1795, 1.1015, 1.0077, 0.9022, 0.7882, 0.6677,\n", + " 0.5426, 0.4139, 0.2825, 0.1492])\n", + "----------------------------------------\n", + "iter 2 stage 11 ep 5010 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0066, grad_fn=) , base rewards= tensor([5.3049, 5.3049, 5.3049, 5.3049, 5.3049, 5.3049, 5.3049, 5.3049, 5.3049,\n", + " 5.3049, 5.3049, 5.3049, 4.8106, 4.3587, 3.9372, 3.5379, 3.1548, 2.7837,\n", + " 2.4214, 2.0657, 1.7149, 1.3677, 1.0232, 0.6807, 0.3398]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9988, 0.9985, 0.9988, 0.9988, 0.9987, 0.9986, 0.9990, 0.9986, 0.9989,\n", + " 0.9984, 0.9985, 0.9990, 0.9993, 0.9995, 0.9994, 0.9994, 0.9994, 0.9995,\n", + " 1.0000, 0.9995, 0.9998, 0.9999, 0.9997, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.3846, 1.3990, 1.3722, 1.3157, 1.2376, 1.1437, 1.0382, 0.9241, 0.8037,\n", + " 0.6785, 0.5498, 0.4184, 0.2851, 0.1503])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 10 ep 12616 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0071, grad_fn=) , base rewards= tensor([5.6490, 5.6490, 5.6490, 5.6490, 5.6490, 5.6490, 5.6490, 5.6490, 5.6490,\n", + " 5.6490, 5.6490, 5.1533, 4.7004, 4.2782, 3.8783, 3.4949, 3.1234, 2.7610,\n", + " 2.4051, 2.0541, 1.7068, 1.3623, 1.0198, 0.6788, 0.3390]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9989, 0.9987, 0.9989, 0.9990, 0.9989, 0.9987, 0.9991, 0.9987, 0.9990,\n", + " 0.9985, 0.9990, 0.9991, 0.9994, 0.9997, 0.9995, 0.9995, 0.9996, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.5217, 1.5361, 1.5093, 1.4527, 1.3745, 1.2806, 1.1751, 1.0610, 0.9405,\n", + " 0.8153, 0.6865, 0.5552, 0.4218, 0.2870, 0.1511])\n", + "----------------------------------------\n", + "iter 2 stage 9 ep 510 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0090, grad_fn=) , base rewards= tensor([5.9943, 5.9943, 5.9943, 5.9943, 5.9943, 5.9943, 5.9943, 5.9943, 5.9943,\n", + " 5.9943, 5.4967, 5.0424, 4.6192, 4.2186, 3.8346, 3.4628, 3.1001, 2.7440,\n", + " 2.3929, 2.0454, 1.7008, 1.3582, 1.0172, 0.6773, 0.3383]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9989, 0.9987, 0.9990, 0.9990, 0.9989, 0.9987, 0.9991, 0.9988, 0.9990,\n", + " 0.9990, 0.9990, 0.9991, 0.9994, 0.9997, 0.9995, 0.9996, 0.9996, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.6596, 1.6740, 1.6471, 1.5904, 1.5122, 1.4182, 1.3126, 1.1985, 1.0779,\n", + " 0.9527, 0.8240, 0.6926, 0.5592, 0.4244, 0.2885, 0.1518])\n", + "----------------------------------------\n", + "iter 2 stage 8 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0113, grad_fn=) , base rewards= tensor([6.3414, 6.3414, 6.3414, 6.3414, 6.3414, 6.3414, 6.3414, 6.3414, 6.3414,\n", + " 5.8413, 5.3852, 4.9607, 4.5592, 4.1745, 3.8022, 3.4390, 3.0826, 2.7313,\n", + " 2.3837, 2.0390, 1.6963, 1.3552, 1.0153, 0.6763, 0.3379]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9989, 0.9987, 0.9990, 0.9990, 0.9989, 0.9987, 0.9991, 0.9988, 0.9990,\n", + " 0.9990, 0.9990, 0.9991, 0.9994, 0.9997, 0.9995, 0.9996, 0.9996, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.7982, 1.8126, 1.7855, 1.7288, 1.6505, 1.5564, 1.4507, 1.3365, 1.2159,\n", + " 1.0906, 0.9619, 0.8304, 0.6971, 0.5623, 0.4263, 0.2896, 0.1522])\n", + "----------------------------------------\n", + "iter 2 stage 7 ep 179 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0132, grad_fn=) , base rewards= tensor([6.6914, 6.6914, 6.6914, 6.6914, 6.6914, 6.6914, 6.6914, 6.6914, 6.1879,\n", + " 5.7293, 5.3031, 4.9003, 4.5146, 4.1416, 3.7779, 3.4212, 3.0696, 2.7218,\n", + " 2.3769, 2.0341, 1.6929, 1.3529, 1.0139, 0.6754, 0.3375]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9989, 0.9987, 0.9990, 0.9990, 0.9989, 0.9987, 0.9991, 0.9990, 0.9991,\n", + " 0.9991, 0.9990, 0.9991, 0.9994, 0.9997, 0.9995, 0.9996, 0.9996, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([1.9373, 1.9517, 1.9246, 1.8677, 1.7892, 1.6950, 1.5892, 1.4749, 1.3543,\n", + " 1.2290, 1.1001, 0.9687, 0.8353, 0.7005, 0.5645, 0.4278, 0.2904, 0.1526])\n", + "----------------------------------------\n", + "iter 2 stage 6 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0154, grad_fn=) , base rewards= tensor([7.0453, 7.0453, 7.0453, 7.0453, 7.0453, 7.0453, 7.0453, 6.5372, 6.0754,\n", + " 5.6468, 5.2423, 4.8554, 4.4815, 4.1171, 3.7599, 3.4079, 3.0598, 2.7147,\n", + " 2.3717, 2.0305, 1.6904, 1.3512, 1.0128, 0.6748, 0.3373]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9989, 0.9987, 0.9990, 0.9990, 0.9989, 0.9987, 0.9991, 0.9990, 0.9991,\n", + " 0.9991, 0.9990, 0.9991, 0.9994, 0.9997, 0.9995, 0.9996, 0.9996, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.0770, 2.0914, 2.0642, 2.0071, 1.9284, 1.8340, 1.7281, 1.6137, 1.4930,\n", + " 1.3676, 1.2387, 1.1072, 0.9738, 0.8389, 0.7030, 0.5662, 0.4288, 0.2910,\n", + " 0.1528])\n", + "----------------------------------------\n", + "iter 2 stage 5 ep 179 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0167, grad_fn=) , base rewards= tensor([7.4046, 7.4046, 7.4046, 7.4046, 7.4046, 7.4046, 6.8905, 6.4243, 5.9926,\n", + " 5.5858, 5.1973, 4.8221, 4.4568, 4.0989, 3.7464, 3.3979, 3.0525, 2.7094,\n", + " 2.3679, 2.0277, 1.6885, 1.3500, 1.0120, 0.6744, 0.3371]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9991, 0.9991,\n", + " 0.9992, 0.9991, 0.9992, 0.9994, 0.9998, 0.9995, 0.9996, 0.9997, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.2174, 2.2318, 2.2043, 2.1470, 2.0681, 1.9735, 1.8674, 1.7528, 1.6320,\n", + " 1.5065, 1.3775, 1.2460, 1.1126, 0.9777, 0.8417, 0.7049, 0.5675, 0.4296,\n", + " 0.2915, 0.1530])\n", + "----------------------------------------\n", + "iter 2 stage 4 ep 42 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0198, grad_fn=) , base rewards= tensor([7.7714, 7.7714, 7.7714, 7.7714, 7.7714, 7.2491, 6.7771, 6.3412, 5.9313,\n", + " 5.5405, 5.1637, 4.7972, 4.4384, 4.0852, 3.7363, 3.3905, 3.0470, 2.7054,\n", + " 2.3650, 2.0257, 1.6871, 1.3490, 1.0114, 0.6740, 0.3369]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9991, 0.9991,\n", + " 0.9992, 0.9991, 0.9991, 0.9994, 0.9998, 0.9995, 0.9996, 0.9997, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.3585, 2.3729, 2.3452, 2.2875, 2.2082, 2.1134, 2.0070, 1.8922, 1.7713,\n", + " 1.6456, 1.5166, 1.3850, 1.2515, 1.1165, 0.9805, 0.8437, 0.7063, 0.5684,\n", + " 0.4303, 0.2918, 0.1532])\n", + "----------------------------------------\n", + "iter 2 stage 3 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0227, grad_fn=) , base rewards= tensor([8.1482, 8.1482, 8.1482, 8.1482, 7.6150, 7.1352, 6.6936, 6.2797, 5.8859,\n", + " 5.5069, 5.1387, 4.7787, 4.4246, 4.0750, 3.7287, 3.3849, 3.0429, 2.7024,\n", + " 2.3629, 2.0241, 1.6860, 1.3483, 1.0109, 0.6738, 0.3368]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9991, 0.9991,\n", + " 0.9992, 0.9991, 0.9991, 0.9994, 0.9998, 0.9995, 0.9996, 0.9997, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.5005, 2.5149, 2.4868, 2.4287, 2.3490, 2.2537, 2.1470, 2.0320, 1.9108,\n", + " 1.7850, 1.6559, 1.5242, 1.3906, 1.2556, 1.1195, 0.9827, 0.8452, 0.7074,\n", + " 0.5692, 0.4307, 0.2921, 0.1533])\n", + "----------------------------------------\n", + "iter 2 stage 2 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0259, grad_fn=) , base rewards= tensor([8.5388, 8.5388, 8.5388, 7.9907, 7.5004, 7.0513, 6.6318, 6.2340, 5.8521,\n", + " 5.4817, 5.1201, 4.7648, 4.4143, 4.0673, 3.7230, 3.3807, 3.0399, 2.7002,\n", + " 2.3613, 2.0230, 1.6852, 1.3478, 1.0106, 0.6736, 0.3367]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9988, 0.9990, 0.9990, 0.9990, 0.9990, 0.9993, 0.9991, 0.9991,\n", + " 0.9992, 0.9991, 0.9991, 0.9994, 0.9998, 0.9995, 0.9996, 0.9997, 0.9995,\n", + " 1.0000, 0.9996, 0.9998, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.6436, 2.6580, 2.6294, 2.5707, 2.4905, 2.3946, 2.2875, 2.1722, 2.0507,\n", + " 1.9247, 1.7953, 1.6635, 1.5298, 1.3948, 1.2586, 1.1218, 0.9843, 0.8464,\n", + " 0.7082, 0.5697, 0.4310, 0.2923, 0.1534])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 2 stage 1 ep 130 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0258, grad_fn=) , base rewards= tensor([8.9480, 8.9480, 8.3799, 7.8753, 7.4160, 6.9892, 6.5860, 6.2001, 5.8268,\n", + " 5.4630, 5.1061, 4.7544, 4.4066, 4.0616, 3.7188, 3.3776, 3.0376, 2.6985,\n", + " 2.3601, 2.0221, 1.6846, 1.3473, 1.0103, 0.6734, 0.3367]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9993, 0.9991,\n", + " 0.9993, 0.9991, 0.9992, 0.9995, 0.9998, 0.9995, 0.9996, 0.9997, 0.9996,\n", + " 1.0000, 0.9996, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.7881, 2.8025, 2.7734, 2.7139, 2.6328, 2.5363, 2.4286, 2.3128, 2.1909,\n", + " 2.0646, 1.9351, 1.8031, 1.6692, 1.5341, 1.3979, 1.2609, 1.1234, 0.9855,\n", + " 0.8473, 0.7088, 0.5701, 0.4313, 0.2924, 0.1534])\n", + "----------------------------------------\n", + "iter 2 stage 0 ep 0 adversary: AdversaryModes.fight_lb_132\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0291, grad_fn=) , base rewards= tensor([9.2984, 8.7872, 8.2633, 7.7903, 7.3535, 6.9431, 6.5519, 6.1747, 5.8080,\n", + " 5.4490, 5.0957, 4.7466, 4.4008, 4.0573, 3.7156, 3.3752, 3.0359, 2.6972,\n", + " 2.3591, 2.0215, 1.6842, 1.3470, 1.0101, 0.6733, 0.3366]) return= 122329.26544005591\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9993, 0.9991,\n", + " 0.9993, 0.9991, 0.9992, 0.9995, 0.9998, 0.9995, 0.9996, 0.9997, 0.9996,\n", + " 1.0000, 0.9996, 0.9999, 1.0000, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5537, 0.5337, 0.5188, 0.5079, 0.4997, 0.4936, 0.4891, 0.4857,\n", + " 0.4832, 0.4813, 0.4798, 0.4788, 0.4780, 0.4774, 0.4769, 0.4766, 0.4764,\n", + " 0.4762, 0.4760, 0.4759, 0.4758, 0.4758, 0.4757, 0.4901])\n", + "finalReturns: tensor([2.9345, 2.9489, 2.9190, 2.8584, 2.7763, 2.6789, 2.5704, 2.4539, 2.3316,\n", + " 2.2049, 2.0751, 1.9428, 1.8088, 1.6735, 1.5372, 1.4002, 1.2627, 1.1247,\n", + " 0.9864, 0.8479, 0.7092, 0.5704, 0.4315, 0.2925, 0.1535])\n", + "0,[1e-05,1][1, 10000, 1, 1],1683049303 saved\n", + "[1239451, 'tensor([0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])', 122329.26544005591, 95669.58206529099, 0.029126999899744987, 1e-05, 1, 0, 'tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\\n 12, 12, 12, 12, 12, 12, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1683049303', 25, 50, 157611.33342506486, 175538.2609849781, 68694.09895647192, 135313.23466666666, 132439.05866666668, 122329.26544005591, 122329.26544005591, 130254.64915679736, 130254.64915679736, 80045.82189636558, 122329.26544005591, 130254.64915679736]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 1, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671,\n", + " 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671,\n", + " 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671, 0.4671]) return= 118465.88424035063\n", + "probs of actions: tensor([0.9225, 0.9092, 0.0133, 0.9142, 0.9103, 0.9245, 0.9002, 0.9208, 0.9088,\n", + " 0.9158, 0.9157, 0.9228, 0.9095, 0.8977, 0.0451, 0.9123, 0.9046, 0.0062,\n", + " 0.9008, 0.9034, 0.9077, 0.0532, 0.9217, 0.8866, 0.9858],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4988, 0.4892, 0.4897, 0.4828, 0.4776, 0.4738, 0.4709, 0.4688,\n", + " 0.4672, 0.4660, 0.4651, 0.4644, 0.4639, 0.4634, 0.4667, 0.4656, 0.4632,\n", + " 0.4779, 0.4740, 0.4711, 0.4688, 0.4707, 0.4686, 0.4671])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([ 6, 0, 0, 9, 0, 0, 0, 9, 7, 0, 0, 12, 1, 13, 0, 0, 7, 8,\n", + " 0, 9, 0, 7, 9, 9, 0])\n", + "loss= tensor(0.0365, grad_fn=) , base rewards= tensor([1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671,\n", + " 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671,\n", + " 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 1.0671, 0.5230]) return= 128711.60607356537\n", + "probs of actions: tensor([0.0279, 0.3195, 0.2609, 0.3040, 0.4547, 0.4141, 0.3812, 0.2469, 0.0893,\n", + " 0.2782, 0.3144, 0.0407, 0.0230, 0.0346, 0.2974, 0.2232, 0.0981, 0.1333,\n", + " 0.3403, 0.2705, 0.3291, 0.1090, 0.2630, 0.2326, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.5202, 0.5054, 0.4864, 0.5183, 0.5040, 0.4934, 0.4775, 0.5065,\n", + " 0.5240, 0.5082, 0.4821, 0.5306, 0.4999, 0.5501, 0.5274, 0.5059, 0.5171,\n", + " 0.5368, 0.5095, 0.5360, 0.5122, 0.5202, 0.5360, 0.5561])\n", + "finalReturns: tensor([0.0250, 0.0331])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([17, 21, 21, 21, 21, 21, 14, 21, 7, 11, 21, 21, 13, 9, 21, 21, 13, 21,\n", + " 21, 21, 21, 21, 21, 17, 0])\n", + "loss= tensor(0.4933, grad_fn=) , base rewards= tensor([0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320,\n", + " 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.9320,\n", + " 0.9320, 0.9320, 0.9320, 0.9320, 0.9320, 0.5697, 0.2649]) return= 90665.36375873255\n", + "probs of actions: tensor([0.0206, 0.6746, 0.6706, 0.7113, 0.6599, 0.7061, 0.0543, 0.6362, 0.0054,\n", + " 0.0176, 0.6451, 0.6355, 0.1559, 0.0499, 0.6243, 0.6552, 0.1977, 0.5576,\n", + " 0.6014, 0.5997, 0.6143, 0.6144, 0.9103, 0.0191, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4823, 0.5165, 0.5707, 0.5052, 0.4586, 0.4250, 0.4250, 0.3600, 0.3919,\n", + " 0.3367, 0.2820, 0.2939, 0.3302, 0.3225, 0.2632, 0.2796, 0.3193, 0.2785,\n", + " 0.2913, 0.3010, 0.3084, 0.3140, 0.3182, 0.3366, 0.3559])\n", + "finalReturns: tensor([0.0787, 0.1228, 0.0910])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 13, 0])\n", + "loss= tensor(0.4876, grad_fn=) , base rewards= tensor([1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149,\n", + " 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149, 1.5149,\n", + " 1.5149, 1.5149, 1.5149, 1.5149, 1.0522, 0.6582, 0.3121]) return= 109929.65918662024\n", + "probs of actions: tensor([0.9783, 0.9750, 0.9743, 0.9797, 0.9723, 0.9814, 0.9655, 0.9731, 0.9711,\n", + " 0.9687, 0.9743, 0.9726, 0.9711, 0.9715, 0.9721, 0.9763, 0.9660, 0.9519,\n", + " 0.9693, 0.9662, 0.9683, 0.9910, 0.9983, 0.1137, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4457, 0.4357])\n", + "finalReturns: tensor([0.2037, 0.2478, 0.2232, 0.1236])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0092, grad_fn=) , base rewards= tensor([1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031,\n", + " 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031, 1.8031,\n", + " 1.8031, 1.8031, 1.8031, 1.3403, 0.9462, 0.6001, 0.2879]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9984, 0.9981, 0.9979, 0.9986, 0.9977, 0.9987, 0.9970, 0.9980, 0.9974,\n", + " 0.9973, 0.9981, 0.9979, 0.9977, 0.9978, 0.9978, 0.9981, 0.9972, 0.9956,\n", + " 0.9976, 0.9975, 0.9985, 0.9999, 1.0000, 0.9697, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([0.3339, 0.3780, 0.3534, 0.2810, 0.1747])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 956 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 13, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0114, grad_fn=) , base rewards= tensor([1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943,\n", + " 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943, 1.9943,\n", + " 1.9943, 1.9943, 1.5581, 1.1825, 0.8495, 0.5466, 0.2654]) return= 109311.80214161768\n", + "probs of actions: tensor([0.9987, 0.9985, 0.9984, 0.9989, 0.9982, 0.9989, 0.9977, 0.9984, 0.9980,\n", + " 0.9978, 0.9985, 0.9985, 0.9982, 0.9983, 0.9983, 0.9985, 0.9978, 0.9966,\n", + " 0.0010, 0.9990, 0.9989, 1.0000, 1.0000, 0.9682, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4463, 0.3921, 0.3986, 0.4035, 0.4071, 0.4099, 0.4561])\n", + "finalReturns: tensor([0.4730, 0.5171, 0.4941, 0.4237, 0.3194, 0.1907])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 722 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0127, grad_fn=) , base rewards= tensor([2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320,\n", + " 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320, 2.3320,\n", + " 2.3320, 1.8688, 1.4745, 1.1282, 0.8159, 0.5279, 0.2575]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9988, 0.9987, 0.9985, 0.9990, 0.9984, 0.9990, 0.9979, 0.9986, 0.9981,\n", + " 0.9980, 0.9986, 0.9986, 0.9984, 0.9984, 0.9984, 0.9987, 0.9980, 0.9969,\n", + " 0.9990, 0.9993, 0.9990, 1.0000, 1.0000, 0.9694, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([0.6430, 0.6871, 0.6625, 0.5900, 0.4837, 0.3531, 0.2050])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 50770 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0102, grad_fn=) , base rewards= tensor([2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810,\n", + " 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810, 2.5810,\n", + " 2.1175, 1.7230, 1.3766, 1.0642, 0.7761, 0.5057, 0.2481]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9989, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9761, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([0.8134, 0.8575, 0.8329, 0.7604, 0.6541, 0.5235, 0.3753, 0.2144])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 16 ep 39 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0118, grad_fn=) , base rewards= tensor([2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233,\n", + " 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.8233, 2.3595,\n", + " 1.9647, 1.6181, 1.3056, 1.0175, 0.7470, 0.4894, 0.2412]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([0.9908, 1.0349, 1.0103, 0.9377, 0.8314, 0.7007, 0.5526, 0.3917, 0.2213])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0134, grad_fn=) , base rewards= tensor([3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609,\n", + " 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 3.0609, 2.5966, 2.2016,\n", + " 1.8547, 1.5420, 1.2538, 0.9832, 0.7255, 0.4773, 0.2361]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([1.1734, 1.2175, 1.1928, 1.1203, 1.0138, 0.8832, 0.7350, 0.5741, 0.4037,\n", + " 0.2265])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0151, grad_fn=) , base rewards= tensor([3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 3.2953,\n", + " 3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 3.2953, 2.8304, 2.4348, 2.0877,\n", + " 1.7748, 1.4864, 1.2157, 0.9579, 0.7097, 0.4684, 0.2323]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([1.3598, 1.4039, 1.3793, 1.3067, 1.2002, 1.0695, 0.9213, 0.7603, 0.5899,\n", + " 0.4127, 0.2303])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0171, grad_fn=) , base rewards= tensor([3.5276, 3.5276, 3.5276, 3.5276, 3.5276, 3.5276, 3.5276, 3.5276, 3.5276,\n", + " 3.5276, 3.5276, 3.5276, 3.5276, 3.5276, 3.0618, 2.6657, 2.3181, 2.0049,\n", + " 1.7163, 1.4455, 1.1876, 0.9392, 0.6979, 0.4617, 0.2294]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([1.5493, 1.5934, 1.5686, 1.4960, 1.3894, 1.2587, 1.1104, 0.9494, 0.7790,\n", + " 0.6017, 0.4193, 0.2331])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0192, grad_fn=) , base rewards= tensor([3.7587, 3.7587, 3.7587, 3.7587, 3.7587, 3.7587, 3.7587, 3.7587, 3.7587,\n", + " 3.7587, 3.7587, 3.7587, 3.7587, 3.2918, 2.8949, 2.5468, 2.2332, 1.9443,\n", + " 1.6732, 1.4152, 1.1667, 0.9253, 0.6891, 0.4567, 0.2273]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([1.7410, 1.7851, 1.7603, 1.6875, 1.5809, 1.4501, 1.3018, 1.1407, 0.9703,\n", + " 0.7929, 0.6105, 0.4243, 0.2352])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0211, grad_fn=) , base rewards= tensor([3.9896, 3.9896, 3.9896, 3.9896, 3.9896, 3.9896, 3.9896, 3.9896, 3.9896,\n", + " 3.9896, 3.9896, 3.9896, 3.5211, 3.1232, 2.7744, 2.4602, 2.1710, 1.8996,\n", + " 1.6414, 1.3928, 1.1512, 0.9149, 0.6825, 0.4530, 0.2257]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([1.9345, 1.9786, 1.9537, 1.8808, 1.7741, 1.6431, 1.4947, 1.3336, 1.1631,\n", + " 0.9857, 0.8033, 0.6170, 0.4280, 0.2368])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0233, grad_fn=) , base rewards= tensor([4.2210, 4.2210, 4.2210, 4.2210, 4.2210, 4.2210, 4.2210, 4.2210, 4.2210,\n", + " 4.2210, 4.2210, 3.7505, 3.3512, 3.0014, 2.6866, 2.3968, 2.1251, 1.8666,\n", + " 1.6178, 1.3761, 1.1397, 0.9072, 0.6777, 0.4503, 0.2245]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9989, 0.9993, 0.9993, 0.9992, 0.9992, 0.9992, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([2.1294, 2.1735, 2.1485, 2.0755, 1.9686, 1.8375, 1.6890, 1.5278, 1.3572,\n", + " 1.1798, 0.9973, 0.8110, 0.6219, 0.4308, 0.2380])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 9 ep 40 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0255, grad_fn=) , base rewards= tensor([4.4539, 4.4539, 4.4539, 4.4539, 4.4539, 4.4539, 4.4539, 4.4539, 4.4539,\n", + " 4.4539, 3.9807, 3.5795, 3.2284, 2.9127, 2.6222, 2.3500, 2.0912, 1.8421,\n", + " 1.6002, 1.3637, 1.1311, 0.9014, 0.6740, 0.4482, 0.2236]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9990, 0.9994, 0.9994, 0.9992, 0.9993, 0.9993, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9760, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([2.3256, 2.3697, 2.3445, 2.2713, 2.1642, 2.0330, 1.8843, 1.7229, 1.5523,\n", + " 1.3748, 1.1922, 1.0059, 0.8168, 0.6256, 0.4328, 0.2389])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0287, grad_fn=) , base rewards= tensor([4.6893, 4.6893, 4.6893, 4.6893, 4.6893, 4.6893, 4.6893, 4.6893, 4.6893,\n", + " 4.2125, 3.8088, 3.4559, 3.1389, 2.8476, 2.5747, 2.3154, 2.0660, 1.8238,\n", + " 1.5871, 1.3544, 1.1246, 0.8971, 0.6713, 0.4467, 0.2230]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9990, 0.9994, 0.9994, 0.9992, 0.9993, 0.9993, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9759, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([2.5229, 2.5670, 2.5416, 2.4681, 2.3608, 2.2293, 2.0804, 1.9189, 1.7481,\n", + " 1.5705, 1.3879, 1.2015, 1.0123, 0.8211, 0.6283, 0.4344, 0.2396])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0314, grad_fn=) , base rewards= tensor([4.9285, 4.9285, 4.9285, 4.9285, 4.9285, 4.9285, 4.9285, 4.9285, 4.4468,\n", + " 4.0397, 3.6845, 3.3658, 3.0733, 2.7996, 2.5396, 2.2897, 2.0472, 1.8102,\n", + " 1.5773, 1.3474, 1.1198, 0.8939, 0.6692, 0.4455, 0.2225]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9994, 0.9993, 0.9992, 0.9995, 0.9991, 0.9995, 0.9989, 0.9993, 0.9990,\n", + " 0.9990, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9993, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9759, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([2.7213, 2.7654, 2.7398, 2.6659, 2.5582, 2.4264, 2.2773, 2.1155, 1.9446,\n", + " 1.7669, 1.5841, 1.3977, 1.2084, 1.0172, 0.8243, 0.6304, 0.4355, 0.2401])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 40 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0331, grad_fn=) , base rewards= tensor([5.1729, 5.1729, 5.1729, 5.1729, 5.1729, 5.1729, 5.1729, 4.6847, 4.2732,\n", + " 3.9148, 3.5939, 3.2997, 3.0249, 2.7641, 2.5135, 2.2706, 2.0333, 1.8001,\n", + " 1.5700, 1.3423, 1.1162, 0.8915, 0.6677, 0.4446, 0.2221]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9991, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9763, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([2.9210, 2.9651, 2.9390, 2.8647, 2.7565, 2.6243, 2.4748, 2.3128, 2.1416,\n", + " 1.9637, 1.7808, 1.5943, 1.4050, 1.2136, 1.0208, 0.8268, 0.6319, 0.4364,\n", + " 0.2404])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 13, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(12.9543, grad_fn=) , base rewards= tensor([5.4246, 5.4246, 5.4246, 5.4246, 5.4246, 5.4246, 4.9277, 4.5102, 4.1476,\n", + " 3.8237, 3.5274, 3.2510, 2.9890, 2.7377, 2.4941, 2.2563, 2.0228, 1.7925,\n", + " 1.5646, 1.3384, 1.1135, 0.8897, 0.6665, 0.4440, 0.2218]) return= 109226.96100827814\n", + "probs of actions: tensor([9.9946e-01, 9.9933e-01, 9.9919e-01, 9.9955e-01, 9.9913e-01, 9.9952e-01,\n", + " 9.9900e-01, 9.9935e-01, 9.9914e-01, 9.9909e-01, 9.9942e-01, 9.9944e-01,\n", + " 9.9932e-01, 9.9934e-01, 9.9934e-01, 9.9939e-01, 5.4956e-04, 9.9907e-01,\n", + " 9.9969e-01, 1.0000e+00, 9.9992e-01, 1.0000e+00, 1.0000e+00, 9.7597e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4469, 0.3925,\n", + " 0.3989, 0.4037, 0.4073, 0.4101, 0.4121, 0.4137, 0.4589])\n", + "finalReturns: tensor([3.0521, 3.0962, 3.0697, 2.9947, 2.8859, 2.7531, 2.6032, 2.4408, 2.2693,\n", + " 2.0912, 1.9081, 1.7214, 1.5048, 1.3402, 1.1675, 0.9886, 0.8051, 0.6182,\n", + " 0.4286, 0.2371])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0390, grad_fn=) , base rewards= tensor([5.6865, 5.6865, 5.6865, 5.6865, 5.6865, 5.1778, 4.7521, 4.3839, 4.0560,\n", + " 3.7569, 3.4784, 3.2149, 2.9624, 2.7181, 2.4797, 2.2457, 2.0150, 1.7868,\n", + " 1.5605, 1.3355, 1.1115, 0.8883, 0.6657, 0.4435, 0.2216]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9762, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([3.3248, 3.3689, 3.3417, 3.2659, 3.1562, 3.0226, 2.8720, 2.7091, 2.5373,\n", + " 2.3588, 2.1755, 1.9886, 1.7991, 1.6075, 1.4145, 1.2204, 1.0255, 0.8299,\n", + " 0.6339, 0.4375, 0.2409])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0413, grad_fn=) , base rewards= tensor([5.9621, 5.9621, 5.9621, 5.9621, 5.4375, 5.0009, 4.6251, 4.2918, 3.9888,\n", + " 3.7076, 3.4421, 3.1881, 2.9426, 2.7034, 2.4688, 2.2377, 2.0092, 1.7826,\n", + " 1.5574, 1.3333, 1.1100, 0.8873, 0.6650, 0.4431, 0.2215]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9761, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([3.5297, 3.5738, 3.5457, 3.4688, 3.3579, 3.2234, 3.0719, 2.9084, 2.7359,\n", + " 2.5571, 2.3734, 2.1863, 1.9966, 1.8049, 1.6118, 1.4176, 1.2226, 1.0270,\n", + " 0.8309, 0.6345, 0.4379, 0.2411])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0450, grad_fn=) , base rewards= tensor([6.2565, 6.2565, 6.2565, 5.7103, 5.2590, 4.8729, 4.5324, 4.2242, 3.9392,\n", + " 3.6710, 3.4151, 3.1681, 2.9278, 2.6925, 2.4608, 2.2318, 2.0048, 1.7794,\n", + " 1.5551, 1.3317, 1.1089, 0.8865, 0.6646, 0.4429, 0.2214]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9760, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([3.7373, 3.7814, 3.7523, 3.6737, 3.5614, 3.4255, 3.2730, 3.1085, 2.9353,\n", + " 2.7559, 2.5718, 2.3844, 2.1944, 2.0025, 1.8093, 1.6150, 1.4199, 1.2242,\n", + " 1.0281, 0.8317, 0.6350, 0.4382, 0.2412])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: AdversaryModes.fight_125\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0484, grad_fn=) , base rewards= tensor([6.5768, 6.5768, 6.0011, 5.5297, 5.1298, 4.7795, 4.4644, 4.1744, 3.9025,\n", + " 3.6439, 3.3950, 3.1533, 2.9168, 2.6843, 2.4547, 2.2273, 2.0016, 1.7770,\n", + " 1.5534, 1.3304, 1.1080, 0.8860, 0.6642, 0.4426, 0.2213]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9760, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([3.9487, 3.9928, 3.9620, 3.8815, 3.7671, 3.6294, 3.4754, 3.3097, 3.1356,\n", + " 2.9554, 2.7708, 2.5829, 2.3926, 2.2004, 2.0070, 1.8125, 1.6174, 1.4216,\n", + " 1.2254, 1.0290, 0.8323, 0.6354, 0.4384, 0.2413])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 0])\n", + "loss= tensor(0.0513, grad_fn=) , base rewards= tensor([6.8278, 6.3166, 5.8178, 5.3989, 5.0355, 4.7109, 4.4142, 4.1374, 3.8753,\n", + " 3.6237, 3.3800, 3.1421, 2.9086, 2.6782, 2.4502, 2.2240, 1.9991, 1.7752,\n", + " 1.5521, 1.3295, 1.1074, 0.8855, 0.6639, 0.4425, 0.2212]) return= 109925.7013290539\n", + "probs of actions: tensor([0.9995, 0.9993, 0.9992, 0.9996, 0.9991, 0.9995, 0.9990, 0.9993, 0.9991,\n", + " 0.9991, 0.9994, 0.9994, 0.9993, 0.9993, 0.9993, 0.9994, 0.9990, 0.9990,\n", + " 0.9997, 1.0000, 0.9999, 1.0000, 1.0000, 0.9759, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4671, 0.5316, 0.5021, 0.4805, 0.4646, 0.4528, 0.4441, 0.4376, 0.4327,\n", + " 0.4291, 0.4264, 0.4244, 0.4228, 0.4217, 0.4208, 0.4202, 0.4197, 0.4194,\n", + " 0.4191, 0.4189, 0.4188, 0.4186, 0.4186, 0.4185, 0.4625])\n", + "finalReturns: tensor([4.1648, 4.2089, 4.1760, 4.0928, 3.9758, 3.8357, 3.6796, 3.5123, 3.3370,\n", + " 3.1558, 2.9704, 2.7819, 2.5911, 2.3987, 2.2050, 2.0103, 1.8150, 1.6191,\n", + " 1.4229, 1.2264, 1.0296, 0.8327, 0.6357, 0.4385, 0.2413])\n", + "0,[1e-05,1][1, 10000, 1, 1],1683106228 saved\n", + "[652587, 'tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.])', 109925.7013290539, 84773.34866887607, 0.051301419734954834, 1e-05, 1, 0, 'tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\\n 21, 21, 21, 21, 21, 21, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1. 1. 1. 1. 1. 1. 1. 1. 1. 0.98 1. ]', '0,[1e-05,1][1, 10000, 1, 1],1683106228', 25, 50, 167645.58347602683, 202386.15908071544, 82634.78314716663, 134766.63466666665, 131821.99466666667, 92498.06441395788, 92568.85885052304, 109925.70132905389, 109925.70132905389, 95781.68158887929, 92498.7981199441, 109927.0996773476]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633,\n", + " 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633,\n", + " 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633, 0.4633]) return= 117778.10729910324\n", + "probs of actions: tensor([0.9298, 0.9438, 0.0328, 0.9247, 0.9325, 0.9293, 0.9304, 0.9386, 0.9360,\n", + " 0.9318, 0.8983, 0.9275, 0.9239, 0.9333, 0.9266, 0.9286, 0.9126, 0.9336,\n", + " 0.0313, 0.8994, 0.9284, 0.9285, 0.9281, 0.9292, 0.9939],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4988, 0.4895, 0.4862, 0.4802, 0.4757, 0.4724, 0.4699, 0.4680,\n", + " 0.4666, 0.4655, 0.4648, 0.4642, 0.4637, 0.4634, 0.4631, 0.4630, 0.4628,\n", + " 0.4626, 0.4660, 0.4651, 0.4644, 0.4639, 0.4636, 0.4633])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([17, 0, 0, 8, 1, 17, 9, 0, 6, 7, 9, 13, 3, 8, 10, 10, 8, 10,\n", + " 10, 8, 29, 8, 8, 10, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227,\n", + " 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227,\n", + " 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.8227, 0.3931]) return= 110886.5992611681\n", + "probs of actions: tensor([6.7410e-03, 3.9277e-01, 2.1554e-01, 1.2243e-01, 2.4300e-02, 4.6671e-03,\n", + " 1.0503e-01, 1.7088e-01, 4.1501e-02, 6.3581e-02, 9.4326e-02, 3.5382e-02,\n", + " 1.1196e-02, 1.0751e-01, 1.9669e-01, 2.2438e-01, 1.1883e-01, 2.5325e-01,\n", + " 2.4511e-01, 1.2646e-01, 7.9849e-05, 1.2561e-01, 1.2209e-01, 4.4844e-01,\n", + " 9.9323e-01], grad_fn=)\n", + "rewards: tensor([0.4823, 0.5606, 0.5352, 0.5101, 0.5313, 0.4884, 0.5573, 0.5210, 0.4544,\n", + " 0.4280, 0.4096, 0.3961, 0.4214, 0.3908, 0.3845, 0.3887, 0.3955, 0.3879,\n", + " 0.3913, 0.3975, 0.3153, 0.4585, 0.4382, 0.4196, 0.4251])\n", + "finalReturns: tensor([0.0220, 0.0320])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([12, 15, 15, 15, 15, 12, 15, 15, 12, 13, 15, 15, 15, 15, 13, 15, 15, 15,\n", + " 15, 15, 15, 13, 15, 13, 0])\n", + "loss= tensor(0.2627, grad_fn=) , base rewards= tensor([1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032,\n", + " 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 1.3032,\n", + " 1.3032, 1.3032, 1.3032, 1.3032, 1.3032, 0.8249, 0.3951]) return= 119446.69263091798\n", + "probs of actions: tensor([0.0268, 0.6716, 0.6783, 0.6497, 0.7063, 0.0258, 0.6930, 0.7128, 0.0190,\n", + " 0.1823, 0.6454, 0.6303, 0.6423, 0.5961, 0.1839, 0.6566, 0.6457, 0.6843,\n", + " 0.7225, 0.6714, 0.6469, 0.2010, 0.8696, 0.1107, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.5196, 0.5546, 0.5312, 0.5140, 0.5094, 0.4811, 0.4768, 0.4817,\n", + " 0.4663, 0.4546, 0.4569, 0.4587, 0.4600, 0.4666, 0.4548, 0.4571, 0.4588,\n", + " 0.4601, 0.4611, 0.4618, 0.4680, 0.4558, 0.4635, 0.4750])\n", + "finalReturns: tensor([0.0911, 0.1136, 0.0799])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0023, grad_fn=) , base rewards= tensor([1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186,\n", + " 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186, 1.6186,\n", + " 1.6186, 1.6186, 1.6186, 1.6186, 1.1523, 0.7359, 0.3551]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9903, 0.9901, 0.9906, 0.9895, 0.9921, 0.9890, 0.9906, 0.9925, 0.9923,\n", + " 0.9895, 0.9863, 0.9882, 0.9871, 0.9857, 0.9883, 0.9888, 0.9872, 0.9912,\n", + " 0.9917, 0.9882, 0.9884, 0.9916, 0.9985, 0.9974, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.1785, 0.2010, 0.1737, 0.1109])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 40198 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0006, grad_fn=) , base rewards= tensor([2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391,\n", + " 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391, 2.3391,\n", + " 2.3391, 2.3391, 2.3391, 1.7892, 1.2936, 0.8369, 0.4082]) return= 132803.10474323918\n", + "probs of actions: tensor([0.9989, 0.0011, 0.9989, 0.9988, 0.9992, 0.9988, 0.9990, 0.9993, 0.9992,\n", + " 0.9989, 0.9986, 0.9988, 0.9986, 0.9985, 0.9988, 0.9989, 0.9986, 0.9992,\n", + " 0.9991, 0.9987, 0.9991, 0.9995, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5363, 0.5556, 0.5413, 0.5436, 0.5394, 0.5364, 0.5341, 0.5323,\n", + " 0.5310, 0.5301, 0.5294, 0.5288, 0.5284, 0.5281, 0.5279, 0.5277, 0.5276,\n", + " 0.5275, 0.5274, 0.5273, 0.5273, 0.5273, 0.5273, 0.5497])\n", + "finalReturns: tensor([0.3198, 0.3423, 0.3106, 0.2401, 0.1415])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 19 ep 392 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790,\n", + " 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790, 2.2790,\n", + " 2.2790, 2.2790, 1.8123, 1.3957, 1.0148, 0.6595, 0.3229]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9989, 0.9992, 0.9988, 0.9990, 0.9992, 0.9992,\n", + " 0.9989, 0.9985, 0.9987, 0.9985, 0.9984, 0.9987, 0.9988, 0.9985, 0.9991,\n", + " 0.9991, 0.9990, 0.9990, 0.9994, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.4061, 0.4286, 0.4013, 0.3385, 0.2501, 0.1431])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0019, grad_fn=) , base rewards= tensor([2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927,\n", + " 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927, 2.5927,\n", + " 2.5927, 2.1258, 1.7090, 1.3279, 0.9725, 0.6358, 0.3129]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9989, 0.9992, 0.9988, 0.9990, 0.9992, 0.9992,\n", + " 0.9989, 0.9985, 0.9987, 0.9985, 0.9984, 0.9987, 0.9988, 0.9985, 0.9991,\n", + " 0.9991, 0.9990, 0.9990, 0.9994, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.5368, 0.5593, 0.5320, 0.4692, 0.3808, 0.2738, 0.1531])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994,\n", + " 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994, 2.8994,\n", + " 2.4321, 2.0150, 1.6337, 1.2782, 0.9414, 0.6184, 0.3054]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9990, 0.9990, 0.9990, 0.9989, 0.9992, 0.9988, 0.9990, 0.9992, 0.9992,\n", + " 0.9989, 0.9985, 0.9987, 0.9985, 0.9984, 0.9987, 0.9988, 0.9985, 0.9991,\n", + " 0.9991, 0.9990, 0.9990, 0.9994, 0.9999, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.6750, 0.6975, 0.6702, 0.6073, 0.5189, 0.4119, 0.2912, 0.1606])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 4983 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0028, grad_fn=) , base rewards= tensor([3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010,\n", + " 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 3.2010, 2.7332,\n", + " 2.3157, 1.9342, 1.5785, 1.2416, 0.9184, 0.6054, 0.2999]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9988, 0.9990, 0.9988, 0.9988, 0.9990, 0.9991, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9993, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.8187, 0.8412, 0.8139, 0.7510, 0.6625, 0.5555, 0.4348, 0.3041, 0.1661])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0041, grad_fn=) , base rewards= tensor([3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991,\n", + " 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.4991, 3.0306, 2.6127,\n", + " 2.2308, 1.8748, 1.5378, 1.2145, 0.9014, 0.5958, 0.2958]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9988, 0.9990, 0.9988, 0.9988, 0.9990, 0.9991, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9993, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([0.9666, 0.9891, 0.9617, 0.8988, 0.8103, 0.7032, 0.5825, 0.4518, 0.3138,\n", + " 0.1702])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 20 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0055, grad_fn=) , base rewards= tensor([3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.7950,\n", + " 3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.7950, 3.3256, 2.9070, 2.5247,\n", + " 2.1684, 1.8311, 1.5076, 1.1944, 0.8887, 0.5887, 0.2928]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9988, 0.9990, 0.9988, 0.9988, 0.9990, 0.9991, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9993, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([1.1176, 1.1401, 1.1127, 1.0497, 0.9612, 0.8541, 0.7333, 0.6026, 0.4645,\n", + " 0.3209, 0.1732])\n", + "----------------------------------------\n", + "iter 1 stage 13 ep 207 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0071, grad_fn=) , base rewards= tensor([4.0897, 4.0897, 4.0897, 4.0897, 4.0897, 4.0897, 4.0897, 4.0897, 4.0897,\n", + " 4.0897, 4.0897, 4.0897, 4.0897, 4.0897, 3.6191, 3.1997, 2.8167, 2.4600,\n", + " 2.1223, 1.7987, 1.4853, 1.1795, 0.8793, 0.5833, 0.2905]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9993, 0.9990, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9988, 0.9990, 0.9988, 0.9990, 0.9990, 0.9992, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9993, 0.9995, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([1.2710, 1.2935, 1.2661, 1.2030, 1.1144, 1.0072, 0.8865, 0.7557, 0.6176,\n", + " 0.4739, 0.3262, 0.1755])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 66 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 13, 15, 15, 15, 0])\n", + "loss= tensor(6.1737, grad_fn=) , base rewards= tensor([5.2969, 5.2969, 5.2969, 5.2969, 5.2969, 5.2969, 5.2969, 5.2969, 5.2969,\n", + " 5.2969, 5.2969, 5.2969, 5.2969, 4.7456, 4.2490, 3.7915, 3.3623, 2.9537,\n", + " 2.5602, 2.1779, 1.8039, 1.4360, 1.0727, 0.7128, 0.3554]) return= 132656.87375173956\n", + "probs of actions: tensor([9.9921e-01, 8.1956e-04, 9.9919e-01, 9.9913e-01, 9.9937e-01, 9.9911e-01,\n", + " 9.9927e-01, 9.9944e-01, 9.9943e-01, 9.9919e-01, 9.9892e-01, 9.9912e-01,\n", + " 9.9905e-01, 9.9916e-01, 9.9913e-01, 9.9935e-01, 9.9912e-01, 9.9982e-01,\n", + " 9.9947e-01, 9.9936e-01, 6.5138e-04, 9.9961e-01, 9.9997e-01, 9.9984e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4887, 0.5363, 0.5556, 0.5413, 0.5436, 0.5394, 0.5364, 0.5341, 0.5323,\n", + " 0.5310, 0.5301, 0.5294, 0.5288, 0.5284, 0.5281, 0.5279, 0.5277, 0.5276,\n", + " 0.5275, 0.5274, 0.5329, 0.5199, 0.5217, 0.5231, 0.5466])\n", + "finalReturns: tensor([1.5707, 1.5932, 1.5614, 1.4908, 1.3922, 1.2731, 1.1390, 0.9938, 0.8404,\n", + " 0.6753, 0.5187, 0.3569, 0.1912])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 11 ep 19 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0115, grad_fn=) , base rewards= tensor([4.6792, 4.6792, 4.6792, 4.6792, 4.6792, 4.6792, 4.6792, 4.6792, 4.6792,\n", + " 4.6792, 4.6792, 4.6792, 4.2048, 3.7828, 3.3979, 3.0398, 2.7012, 2.3768,\n", + " 2.0628, 1.7566, 1.4562, 1.1600, 0.8670, 0.5764, 0.2875]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9993, 0.9990, 0.9992, 0.9994, 0.9993,\n", + " 0.9991, 0.9987, 0.9990, 0.9989, 0.9990, 0.9990, 0.9992, 0.9990, 0.9998,\n", + " 0.9994, 0.9992, 0.9992, 0.9995, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([1.5830, 1.6055, 1.5779, 1.5147, 1.4259, 1.3185, 1.1976, 1.0667, 0.9285,\n", + " 0.7848, 0.6370, 0.4862, 0.3332, 0.1785])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 178 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0126, grad_fn=) , base rewards= tensor([4.9759, 4.9759, 4.9759, 4.9759, 4.9759, 4.9759, 4.9759, 4.9759, 4.9759,\n", + " 4.9759, 4.9759, 4.4987, 4.0746, 3.6883, 3.3292, 2.9898, 2.6648, 2.3505,\n", + " 2.0440, 1.7433, 1.4469, 1.1538, 0.8631, 0.5741, 0.2866]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([1.7410, 1.7635, 1.7358, 1.6724, 1.5834, 1.4759, 1.3549, 1.2239, 1.0856,\n", + " 0.9419, 0.7941, 0.6432, 0.4902, 0.3354, 0.1794])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0149, grad_fn=) , base rewards= tensor([5.2754, 5.2754, 5.2754, 5.2754, 5.2754, 5.2754, 5.2754, 5.2754, 5.2754,\n", + " 5.2754, 4.7944, 4.3676, 3.9793, 3.6188, 3.2784, 2.9527, 2.6378, 2.3308,\n", + " 2.0299, 1.7333, 1.4400, 1.1491, 0.8601, 0.5725, 0.2859]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([1.9000, 1.9225, 1.8946, 1.8310, 1.7419, 1.6342, 1.5130, 1.3820, 1.2435,\n", + " 1.0997, 0.9519, 0.8010, 0.6479, 0.4931, 0.3371, 0.1802])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0167, grad_fn=) , base rewards= tensor([5.5790, 5.5790, 5.5790, 5.5790, 5.5790, 5.5790, 5.5790, 5.5790, 5.5790,\n", + " 5.0929, 4.6624, 4.2716, 3.9092, 3.5674, 3.2407, 2.9251, 2.6176, 2.3162,\n", + " 2.0193, 1.7258, 1.4348, 1.1457, 0.8579, 0.5712, 0.2853]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([2.0601, 2.0826, 2.0545, 1.9906, 1.9012, 1.7933, 1.6719, 1.5406, 1.4021,\n", + " 1.2582, 1.1102, 0.9593, 0.8062, 0.6514, 0.4953, 0.3384, 0.1807])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 13, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(9.7105, grad_fn=) , base rewards= tensor([5.8884, 5.8884, 5.8884, 5.8884, 5.8884, 5.8884, 5.8884, 5.8884, 5.3954,\n", + " 4.9602, 4.5659, 4.2010, 3.8574, 3.5293, 3.2127, 2.9045, 2.6026, 2.3053,\n", + " 2.0115, 1.7202, 1.4309, 1.1430, 0.8563, 0.5703, 0.2849]) return= 116862.23949259547\n", + "probs of actions: tensor([9.9923e-01, 9.9920e-01, 9.9920e-01, 9.9914e-01, 9.9936e-01, 9.9906e-01,\n", + " 9.9921e-01, 9.9939e-01, 9.9938e-01, 9.9910e-01, 9.9900e-01, 9.9920e-01,\n", + " 9.9909e-01, 9.9916e-01, 9.9903e-01, 9.9927e-01, 9.7531e-04, 9.9980e-01,\n", + " 9.9940e-01, 9.9928e-01, 9.9924e-01, 9.9955e-01, 9.9997e-01, 9.9983e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4509, 0.4380,\n", + " 0.4393, 0.4403, 0.4411, 0.4416, 0.4420, 0.4424, 0.4651])\n", + "finalReturns: tensor([2.2022, 2.2247, 2.1963, 2.1321, 2.0423, 1.9341, 1.8124, 1.6810, 1.5423,\n", + " 1.3982, 1.2446, 1.1004, 0.9523, 0.8013, 0.6481, 0.4932, 0.3372, 0.1802])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0211, grad_fn=) , base rewards= tensor([6.2060, 6.2060, 6.2060, 6.2060, 6.2060, 6.2060, 6.2060, 5.7037, 5.2620,\n", + " 4.8630, 4.4948, 4.1487, 3.8189, 3.5010, 3.1918, 2.8891, 2.5913, 2.2971,\n", + " 2.0056, 1.7160, 1.4280, 1.1411, 0.8550, 0.5696, 0.2846]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([2.3834, 2.4059, 2.3771, 2.3124, 2.2221, 2.1135, 1.9915, 1.8597, 1.7208,\n", + " 1.5766, 1.4284, 1.2773, 1.1240, 0.9691, 0.8130, 0.6559, 0.4982, 0.3400,\n", + " 0.1814])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0240, grad_fn=) , base rewards= tensor([6.5346, 6.5346, 6.5346, 6.5346, 6.5346, 6.5346, 6.0199, 5.5694, 5.1642,\n", + " 4.7915, 4.4422, 4.1100, 3.7903, 3.4798, 3.1762, 2.8777, 2.5829, 2.2910,\n", + " 2.0012, 1.7129, 1.4258, 1.1396, 0.8541, 0.5691, 0.2844]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9994, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9996, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finalReturns: tensor([2.5469, 2.5694, 2.5402, 2.4748, 2.3839, 2.2747, 2.1522, 2.0201, 1.8809,\n", + " 1.7364, 1.5880, 1.4368, 1.2834, 1.1284, 0.9722, 0.8152, 0.6574, 0.4992,\n", + " 0.3405, 0.1816])\n", + "----------------------------------------\n", + "iter 1 stage 4 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0261, grad_fn=) , base rewards= tensor([8.1639, 8.1639, 8.1639, 8.1639, 8.1639, 7.5979, 7.0908, 6.6257, 6.1910,\n", + " 5.7784, 5.3820, 4.9976, 4.6219, 4.2528, 3.8886, 3.5281, 3.1702, 2.8144,\n", + " 2.4601, 2.1069, 1.7546, 1.4030, 1.0518, 0.7009, 0.3504]) return= 132803.10474323918\n", + "probs of actions: tensor([9.9923e-01, 8.0644e-04, 9.9920e-01, 9.9914e-01, 9.9938e-01, 9.9912e-01,\n", + " 9.9928e-01, 9.9945e-01, 9.9944e-01, 9.9920e-01, 9.9912e-01, 9.9930e-01,\n", + " 9.9920e-01, 9.9926e-01, 9.9915e-01, 9.9936e-01, 9.9914e-01, 9.9982e-01,\n", + " 9.9948e-01, 9.9937e-01, 9.9934e-01, 9.9961e-01, 9.9997e-01, 9.9985e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4887, 0.5363, 0.5556, 0.5413, 0.5436, 0.5394, 0.5364, 0.5341, 0.5323,\n", + " 0.5310, 0.5301, 0.5294, 0.5288, 0.5284, 0.5281, 0.5279, 0.5277, 0.5276,\n", + " 0.5275, 0.5274, 0.5273, 0.5273, 0.5273, 0.5273, 0.5497])\n", + "finalReturns: tensor([2.9945, 3.0170, 2.9847, 2.9134, 2.8140, 2.6943, 2.5596, 2.4140, 2.2603,\n", + " 2.1006, 1.9364, 1.7689, 1.5988, 1.4270, 1.2537, 1.0794, 0.9043, 0.7286,\n", + " 0.5525, 0.3761, 0.1994])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0295, grad_fn=) , base rewards= tensor([7.2430, 7.2430, 7.2430, 7.2430, 6.6886, 6.2103, 5.7855, 5.3986, 5.0391,\n", + " 4.6994, 4.3742, 4.0597, 3.7530, 3.4523, 3.1559, 2.8627, 2.5719, 2.2830,\n", + " 1.9954, 1.7088, 1.4230, 1.1377, 0.8529, 0.5684, 0.2841]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9993, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9995, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([2.8795, 2.9020, 2.8712, 2.8039, 2.7110, 2.6000, 2.4761, 2.3427, 2.2026,\n", + " 2.0573, 1.9084, 1.7567, 1.6030, 1.4478, 1.2914, 1.1342, 0.9763, 0.8180,\n", + " 0.6593, 0.5004, 0.3412, 0.1819])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0325, grad_fn=) , base rewards= tensor([7.6361, 7.6361, 7.6361, 7.0504, 6.5504, 6.1103, 5.7124, 5.3450, 4.9996,\n", + " 4.6702, 4.3525, 4.0436, 3.7411, 3.4435, 3.1493, 2.8579, 2.5684, 2.2804,\n", + " 1.9935, 1.7075, 1.4220, 1.1371, 0.8525, 0.5681, 0.2840]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9993, 0.9991, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9992, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9995, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([3.0496, 3.0721, 3.0402, 2.9713, 2.8769, 2.7646, 2.6395, 2.5053, 2.3644,\n", + " 2.2186, 2.0692, 1.9172, 1.7633, 1.6078, 1.4513, 1.2940, 1.1361, 0.9777,\n", + " 0.8189, 0.6599, 0.5008, 0.3414, 0.1820])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 13, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(9.9530, grad_fn=) , base rewards= tensor([7.9931, 7.9931, 7.4399, 6.9102, 6.4492, 6.0365, 5.6584, 5.3053, 4.9702,\n", + " 4.6484, 4.3364, 4.0316, 3.7322, 3.4369, 3.1444, 2.8543, 2.5657, 2.2785,\n", + " 1.9921, 1.7065, 1.4214, 1.1366, 0.8522, 0.5680, 0.2839]) return= 116862.23949259547\n", + "probs of actions: tensor([9.9922e-01, 9.9919e-01, 9.9919e-01, 9.9913e-01, 9.9935e-01, 9.9905e-01,\n", + " 9.9921e-01, 9.9939e-01, 9.9937e-01, 9.9910e-01, 9.9899e-01, 9.9919e-01,\n", + " 9.9908e-01, 9.9915e-01, 9.9902e-01, 9.9926e-01, 9.9577e-04, 9.9979e-01,\n", + " 9.9939e-01, 9.9927e-01, 9.9923e-01, 9.9955e-01, 9.9997e-01, 9.9982e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4509, 0.4380,\n", + " 0.4393, 0.4403, 0.4411, 0.4416, 0.4420, 0.4424, 0.4651])\n", + "finalReturns: tensor([3.2044, 3.2269, 3.1934, 3.1225, 3.0261, 2.9120, 2.7854, 2.6499, 2.5081,\n", + " 2.3616, 2.2116, 2.0592, 1.9049, 1.7492, 1.5925, 1.4350, 1.2714, 1.1197,\n", + " 0.9660, 0.8108, 0.6545, 0.4973, 0.3395, 0.1812])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: AdversaryModes.fight_125\n", + " actions: tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 15, 0])\n", + "loss= tensor(0.0391, grad_fn=) , base rewards= tensor([8.3070, 7.7957, 7.2969, 6.8074, 6.3746, 5.9820, 5.6184, 5.2757, 4.9483,\n", + " 4.6322, 4.3243, 4.0227, 3.7256, 3.4319, 3.1408, 2.8516, 2.5638, 2.2770,\n", + " 1.9911, 1.7057, 1.4208, 1.1363, 0.8520, 0.5679, 0.2839]) return= 117051.59338141434\n", + "probs of actions: tensor([0.9992, 0.9992, 0.9992, 0.9991, 0.9993, 0.9990, 0.9992, 0.9994, 0.9994,\n", + " 0.9991, 0.9990, 0.9992, 0.9991, 0.9991, 0.9990, 0.9993, 0.9990, 0.9998,\n", + " 0.9994, 0.9993, 0.9992, 0.9995, 1.0000, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.5307, 0.5632, 0.5319, 0.5091, 0.4922, 0.4798, 0.4705, 0.4636,\n", + " 0.4585, 0.4547, 0.4518, 0.4497, 0.4481, 0.4469, 0.4460, 0.4453, 0.4448,\n", + " 0.4444, 0.4442, 0.4439, 0.4438, 0.4437, 0.4436, 0.4660])\n", + "finalReturns: tensor([3.3982, 3.4207, 3.3888, 3.3152, 3.2161, 3.0996, 2.9710, 2.8339, 2.6908,\n", + " 2.5433, 2.3926, 2.2396, 2.0848, 1.9288, 1.7718, 1.6141, 1.4559, 1.2974,\n", + " 1.1385, 0.9794, 0.8201, 0.6607, 0.5013, 0.3417, 0.1821])\n", + "0,[1e-05,1][1, 10000, 1, 1],1683118086 saved\n", + "[526084, 'tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.])', 117051.59338141434, 92893.76204687786, 0.03911364823579788, 1e-05, 1, 0, 'tensor([15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\\n 15, 15, 15, 15, 15, 15, 0])', '[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.\\n 1.]', '0,[1e-05,1][1, 10000, 1, 1],1683118086', 25, 50, 161287.58344151574, 184572.3091501231, 73445.38232037451, 135545.41866666666, 132647.75466666667, 112524.66365021843, 112524.66365021843, 117051.59338141435, 117034.7937498715, 85375.85726043607, 112524.66365021843, 117051.59338141435]\n", + "policy reset\n", + "----------------------------------------\n", + "iter 2 stage 24 ep 99999 adversary: AdversaryModes.fight_125\n", + " actions: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,\n", + " 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645,\n", + " 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645,\n", + " 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645, 0.4645]) return= 118139.09703589762\n", + "probs of actions: tensor([0.9190, 0.8833, 0.9029, 0.8854, 0.9188, 0.9049, 0.8844, 0.9179, 0.8879,\n", + " 0.9124, 0.8865, 0.0176, 0.8999, 0.9145, 0.9051, 0.8961, 0.8862, 0.0062,\n", + " 0.8904, 0.8916, 0.9037, 0.8957, 0.9033, 0.8869, 0.9912],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.4988, 0.4896, 0.4827, 0.4776, 0.4738, 0.4709, 0.4688, 0.4672,\n", + " 0.4660, 0.4651, 0.4640, 0.4707, 0.4687, 0.4671, 0.4659, 0.4650, 0.4635,\n", + " 0.4742, 0.4712, 0.4690, 0.4673, 0.4661, 0.4652, 0.4645])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [3]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 7\u001b[0m neuralNet\u001b[38;5;241m=\u001b[39mNNBase(num_input\u001b[38;5;241m=\u001b[39mgame\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m+\u001b[39mgame\u001b[38;5;241m.\u001b[39madvHistoryNum, lr\u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m0\u001b[39m],num_actions\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m50\u001b[39m)\n\u001b[0;32m 8\u001b[0m algorithm \u001b[38;5;241m=\u001b[39m ReinforceAlgorithm(game, neuralNet, numberIterations\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, numberEpisodes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3_000_000\u001b[39m, discountFactor \u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m---> 11\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolver\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m,\u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:136\u001b[0m, in \u001b[0;36mReinforceAlgorithm.solver\u001b[1;34m(self, print_step, options, converge_break)\u001b[0m\n\u001b[0;32m 133\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss\u001b[38;5;241m.\u001b[39mappend([])\n\u001b[0;32m 135\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m--> 136\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearn_stage_onwards\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43miter\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepisodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnumberEpisodes\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprint_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 137\u001b[0m \u001b[43m \u001b[49m\u001b[43mprob_break_limit_ln\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprobBreakLn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwrite_save\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mstage\u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m 139\u001b[0m axs[\u001b[38;5;28miter\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])\n\u001b[0;32m 140\u001b[0m axs[\u001b[38;5;28miter\u001b[39m][\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:200\u001b[0m, in \u001b[0;36mReinforceAlgorithm.learn_stage_onwards\u001b[1;34m(self, iter, stage, episodes, print_step, prob_break_limit_ln, options, lr, just_stage, write_save)\u001b[0m\n\u001b[0;32m 198\u001b[0m actionsLogProbs \u001b[38;5;241m=\u001b[39m action_logprobs[stage:]\n\u001b[0;32m 199\u001b[0m discRewards \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturnsComputation(rewards\u001b[38;5;241m=\u001b[39mrewards)\n\u001b[1;32m--> 200\u001b[0m baseRewards \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcomputeBase\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprices\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minitDemand\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdemandPotential\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[43mstage\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstartStage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstage\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m/\u001b[39moptions[\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m 202\u001b[0m baseDiscReturns \u001b[38;5;241m=\u001b[39m discRewards\u001b[38;5;241m-\u001b[39mbaseRewards\n\u001b[0;32m 203\u001b[0m finalReturns \u001b[38;5;241m=\u001b[39m baseDiscReturns[stage:]\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:299\u001b[0m, in \u001b[0;36mReinforceAlgorithm.computeBase\u001b[1;34m(self, advPrices, startStage, initDemand)\u001b[0m\n\u001b[0;32m 297\u001b[0m profit[i] \u001b[38;5;241m=\u001b[39m (demand\u001b[38;5;241m-\u001b[39mprice)\u001b[38;5;241m*\u001b[39m(price\u001b[38;5;241m-\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mcosts[\u001b[38;5;241m0\u001b[39m])\n\u001b[0;32m 298\u001b[0m demand \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m (advPrices[i]\u001b[38;5;241m-\u001b[39mprice)\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[1;32m--> 299\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreturnsComputation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrewards\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprofit\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:84\u001b[0m, in \u001b[0;36mReinforceAlgorithm.returnsComputation\u001b[1;34m(self, rewards, episodeMemory)\u001b[0m\n\u001b[0;32m 82\u001b[0m discRewards[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m=\u001b[39m rewards[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m 83\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(rewards)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m---> 84\u001b[0m discRewards[i] \u001b[38;5;241m=\u001b[39m rewards[i] \u001b[38;5;241m+\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgamma\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdiscRewards\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[0;32m 85\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m discRewards\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "for adv in range(len(AdversaryModes)):\n", + " adversaryProbs=torch.zeros(len(AdversaryModes))\n", + " adversaryProbs[adv]=1\n", + " game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + " neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=50)\n", + " algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=3, numberEpisodes=3_000_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + " algorithm.solver(print_step=100_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/results - Copy.xlsx b/learningAgents/naive_policy_gradient/PGM_base/previous files/results - Copy.xlsx new file mode 100644 index 0000000..ff4cae4 Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/previous files/results - Copy.xlsx differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/results - old.xlsx b/learningAgents/naive_policy_gradient/PGM_base/previous files/results - old.xlsx new file mode 100644 index 0000000..5f7fdfd Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/previous files/results - old.xlsx differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/small multi adv.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/small multi adv.ipynb new file mode 100644 index 0000000..409ff2f --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/small multi adv.ipynb @@ -0,0 +1,889 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "from environmentModelBase import Model, AdversaryModes\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/2\n", + "adversaryProbs[2]=1/2\n", + "\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.00001, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n", + "\n", + "lr=hyperParams[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 9999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 1, 1])\n", + "loss= tensor(-0.0001, grad_fn=) , base rewards= tensor([0.3260, 0.3260, 0.3260]) return= 12354.7119140625\n", + "probs of actions: tensor([0.4312, 0.3480, 0.3538], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3984, 0.3259])\n", + "finalReturns: tensor([-0.0001])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 19999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([1, 1, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.3281, 0.3281, 0.3281]) return= 12407.7822265625\n", + "probs of actions: tensor([0.1827, 0.1950, 0.8738], grad_fn=)\n", + "rewards: tensor([0.5111, 0.4015, 0.3281])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.8737, 0.8941, 0.9824], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.9231, 0.9410, 0.9942], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 3, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5606, 0.5606, 0.5606]) return= 16075.078125\n", + "probs of actions: tensor([0.9459, 0.0040, 0.9973], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5357, 0.5606])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 9999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 4, 0])\n", + "loss= tensor(0.0257, grad_fn=) , base rewards= tensor([0.7216, 0.7216, 0.3231]) return= 12426.9150390625\n", + "probs of actions: tensor([0.5012, 0.0809, 0.9227], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3969, 0.3346])\n", + "finalReturns: tensor([0.0099, 0.0115])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 19999 adversary: AdversaryModes.myopic\n", + " actions: tensor([8, 5, 0])\n", + "loss= tensor(0.0393, grad_fn=) , base rewards= tensor([1.1306, 1.1306, 0.5644]) return= 16518.953125\n", + "probs of actions: tensor([0.1130, 0.0987, 0.9373], grad_fn=)\n", + "rewards: tensor([0.5048, 0.5638, 0.5833])\n", + "finalReturns: tensor([0.0164, 0.0189])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([2, 9, 0])\n", + "loss= tensor(0.0159, grad_fn=) , base rewards= tensor([1.0971, 1.0971, 0.5532]) return= 16337.703125\n", + "probs of actions: tensor([0.0202, 0.5644, 0.9682], grad_fn=)\n", + "rewards: tensor([0.5108, 0.5358, 0.5871])\n", + "finalReturns: tensor([0.0259, 0.0340])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 39999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0045, grad_fn=) , base rewards= tensor([0.7700, 0.7700, 0.3426]) return= 12918.5009765625\n", + "probs of actions: tensor([0.4570, 0.8130, 0.9789], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3694])\n", + "finalReturns: tensor([0.0187, 0.0268])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 49999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([6, 9, 0])\n", + "loss= tensor(0.0023, grad_fn=) , base rewards= tensor([0.7537, 0.7537, 0.3360]) return= 12797.9384765625\n", + "probs of actions: tensor([0.0705, 0.9034, 0.9839], grad_fn=)\n", + "rewards: tensor([0.5076, 0.4095, 0.3626])\n", + "finalReturns: tensor([0.0185, 0.0266])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 9999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 8, 0])\n", + "loss= tensor(0.2364, grad_fn=) , base rewards= tensor([1.2328, 0.7216, 0.3231]) return= 12905.1728515625\n", + "probs of actions: tensor([0.8431, 0.0327, 0.9667], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4210, 0.3664])\n", + "finalReturns: tensor([0.0577, 0.0658, 0.0433])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 19999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0090, grad_fn=) , base rewards= tensor([1.2328, 0.7216, 0.3231]) return= 12918.5009765625\n", + "probs of actions: tensor([0.9103, 0.9682, 0.9728], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3694])\n", + "finalReturns: tensor([0.0590, 0.0671, 0.0463])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9522, 0.9842, 0.9783], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0044, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9683, 0.9880, 0.9846], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 49999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([1.2328, 0.7216, 0.3231]) return= 12918.5009765625\n", + "probs of actions: tensor([0.9775, 0.9878, 0.9851], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3694])\n", + "finalReturns: tensor([0.0590, 0.0671, 0.0463])\n", + "3,[1e-05,1][1, 10000, 1, 1],1682430557 saved\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 9999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 2, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.3288, 0.3288, 0.3288]) return= 12381.3212890625\n", + "probs of actions: tensor([0.4092, 0.0917, 0.5332], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3981, 0.3288])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 19999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.3231, 0.3231, 0.3231]) return= 12328.2275390625\n", + "probs of actions: tensor([0.6796, 0.6960, 0.8569], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3985, 0.3231])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 29999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.3231, 0.3231, 0.3231]) return= 12328.2275390625\n", + "probs of actions: tensor([0.8423, 0.8602, 0.9684], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3985, 0.3231])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.9076, 0.9351, 0.9926], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 49999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.3231, 0.3231, 0.3231]) return= 12328.2275390625\n", + "probs of actions: tensor([0.9375, 0.9496, 0.9953], grad_fn=)\n", + "rewards: tensor([0.5112, 0.3985, 0.3231])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 1 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 7, 0])\n", + "loss= tensor(0.0535, grad_fn=) , base rewards= tensor([1.1363, 1.1363, 0.5663]) return= 16611.5\n", + "probs of actions: tensor([0.0487, 0.0918, 0.9427], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5651, 0.5929])\n", + "finalReturns: tensor([0.0217, 0.0266])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 19999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([8, 9, 0])\n", + "loss= tensor(0.0352, grad_fn=) , base rewards= tensor([0.7645, 0.7645, 0.3404]) return= 12880.1181640625\n", + "probs of actions: tensor([0.1875, 0.1643, 0.9460], grad_fn=)\n", + "rewards: tensor([0.5048, 0.4160, 0.3672])\n", + "finalReturns: tensor([0.0187, 0.0268])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 29999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 8, 3])\n", + "loss= tensor(0.1520, grad_fn=) , base rewards= tensor([0.7375, 0.7375, 0.3295]) return= 12639.3681640625\n", + "probs of actions: tensor([0.0321, 0.4571, 0.0020], grad_fn=)\n", + "rewards: tensor([0.5103, 0.4016, 0.3520])\n", + "finalReturns: tensor([0.0161, 0.0225])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 39999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([8, 8, 0])\n", + "loss= tensor(0.0164, grad_fn=) , base rewards= tensor([0.7645, 0.7645, 0.3404]) return= 12866.8837890625\n", + "probs of actions: tensor([0.2901, 0.4005, 0.9794], grad_fn=)\n", + "rewards: tensor([0.5048, 0.4177, 0.3641])\n", + "finalReturns: tensor([0.0173, 0.0237])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([7, 8, 0])\n", + "loss= tensor(0.0285, grad_fn=) , base rewards= tensor([1.1250, 1.1250, 0.5625]) return= 16553.25\n", + "probs of actions: tensor([0.0991, 0.3093, 0.9892], grad_fn=)\n", + "rewards: tensor([0.5063, 0.5561, 0.5929])\n", + "finalReturns: tensor([0.0240, 0.0304])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 9999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([3, 9, 0])\n", + "loss= tensor(0.1945, grad_fn=) , base rewards= tensor([1.2328, 0.7216, 0.3231]) return= 12661.1337890625\n", + "probs of actions: tensor([0.0040, 0.7494, 0.9714], grad_fn=)\n", + "rewards: tensor([0.5103, 0.3999, 0.3559])\n", + "finalReturns: tensor([0.0333, 0.0342, 0.0328])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 19999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0242, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.8578, 0.8770, 0.9793], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 29999 adversary: AdversaryModes.constant_95\n", + " actions: tensor([9, 7, 0])\n", + "loss= tensor(0.2428, grad_fn=) , base rewards= tensor([1.2328, 0.7216, 0.3231]) return= 12889.9697265625\n", + "probs of actions: tensor([0.8909, 0.0256, 0.9833], grad_fn=)\n", + "rewards: tensor([0.5031, 0.4225, 0.3634])\n", + "finalReturns: tensor([0.0562, 0.0643, 0.0403])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0141, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9236, 0.9197, 0.9851], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0112, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9393, 0.9334, 0.9907], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "3,[1e-05,1][1, 10000, 1, 1],1682431321 saved\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.advHistoryNum, lr=hyperParams[0],num_actions=10)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=150_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm.solver(print_step=10_000,options=codeParams,converge_break=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.5012, 0.5468, 0.6858], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 19999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5334, 0.5334, 0.5334]) return= 15683.9541015625\n", + "probs of actions: tensor([0.7822, 0.8259, 0.9408], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.8947, 0.9259, 0.9873], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.9347, 0.9573, 0.9952], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.9524, 0.9703, 0.9974], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 9999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 1, 0])\n", + "loss= tensor(0.0080, grad_fn=) , base rewards= tensor([1.0572, 1.0572, 0.5334]) return= 15719.5322265625\n", + "probs of actions: tensor([0.4593, 0.1153, 0.9152], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5237, 0.5370])\n", + "finalReturns: tensor([0.0036, 0.0037])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 19999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 3, 0])\n", + "loss= tensor(0.0385, grad_fn=) , base rewards= tensor([1.1152, 1.1152, 0.5583]) return= 16286.6728515625\n", + "probs of actions: tensor([0.1943, 0.0262, 0.9343], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5560, 0.5696])\n", + "finalReturns: tensor([0.0104, 0.0113])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 29999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 9, 0])\n", + "loss= tensor(0.0058, grad_fn=) , base rewards= tensor([1.0572, 1.0572, 0.5334]) return= 15936.6572265625\n", + "probs of actions: tensor([0.2008, 0.8603, 0.9428], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5157, 0.5667])\n", + "finalReturns: tensor([0.0253, 0.0334])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 39999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 9, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([1.0572, 1.0572, 0.5334]) return= 15936.6572265625\n", + "probs of actions: tensor([0.1800, 0.9407, 0.9603], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5157, 0.5667])\n", + "finalReturns: tensor([0.0253, 0.0334])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 3, 0])\n", + "loss= tensor(0.0783, grad_fn=) , base rewards= tensor([1.1152, 1.1152, 0.5583]) return= 16286.6728515625\n", + "probs of actions: tensor([5.4211e-01, 5.3763e-04, 9.7907e-01], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5560, 0.5696])\n", + "finalReturns: tensor([0.0104, 0.0113])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 9999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 9, 9])\n", + "loss= tensor(0.1725, grad_fn=) , base rewards= tensor([1.5684, 1.0572, 0.5334]) return= 16362.3291015625\n", + "probs of actions: tensor([0.9020, 0.9887, 0.0395], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5843])\n", + "finalReturns: tensor([0.0678, 0.0759, 0.0510])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 19999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0069, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9444, 0.9937, 0.9673], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0042, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9739, 0.9968, 0.9685], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9804, 0.9970, 0.9791], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 49999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9885, 0.9982, 0.9892], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "3,[1e-05,1][1, 10000, 1, 1],1682432060 saved\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5513, 0.5513, 0.5513]) return= 16026.5625\n", + "probs of actions: tensor([0.2764, 0.5342, 0.6582], grad_fn=)\n", + "rewards: tensor([0.5111, 0.5402, 0.5513])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 19999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.7370, 0.8142, 0.9320], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.8712, 0.9219, 0.9864], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 39999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5334, 0.5334, 0.5334]) return= 15683.9541015625\n", + "probs of actions: tensor([0.9177, 0.9533, 0.9946], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5334])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 1, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5370, 0.5370, 0.5370]) return= 15719.5322265625\n", + "probs of actions: tensor([0.9417, 0.0113, 0.9974], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5237, 0.5370])\n", + "finalReturns: tensor([0.])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 1 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 4])\n", + "loss= tensor(-0.0119, grad_fn=) , base rewards= tensor([1.0860, 1.0860, 0.5495]) return= 15956.328125\n", + "probs of actions: tensor([0.4298, 0.1621, 0.0036], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5479])\n", + "finalReturns: tensor([-0.0016, -0.0016])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 19999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([0, 5, 0])\n", + "loss= tensor(0.0419, grad_fn=) , base rewards= tensor([1.0572, 1.0572, 0.5334]) return= 15843.0947265625\n", + "probs of actions: tensor([0.1945, 0.0772, 0.9427], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5213, 0.5518])\n", + "finalReturns: tensor([0.0159, 0.0184])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 29999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 5, 0])\n", + "loss= tensor(0.0559, grad_fn=) , base rewards= tensor([1.1152, 1.1152, 0.5583]) return= 16346.3916015625\n", + "probs of actions: tensor([0.2148, 0.0340, 0.9656], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5544, 0.5771])\n", + "finalReturns: tensor([0.0163, 0.0188])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 8, 0])\n", + "loss= tensor(0.0256, grad_fn=) , base rewards= tensor([1.1363, 1.1363, 0.5663]) return= 16635.0625\n", + "probs of actions: tensor([0.3481, 0.3534, 0.9820], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5636, 0.5968])\n", + "finalReturns: tensor([0.0241, 0.0305])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 8, 0])\n", + "loss= tensor(0.0345, grad_fn=) , base rewards= tensor([1.1152, 1.1152, 0.5583]) return= 16421.9072265625\n", + "probs of actions: tensor([0.4824, 0.2395, 0.9868], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5505, 0.5886])\n", + "finalReturns: tensor([0.0239, 0.0303])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0475, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.6903, 0.8076, 0.9842], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 19999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0276, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.8101, 0.8834, 0.9851], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0170, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.8880, 0.9222, 0.9834], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 39999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0130, grad_fn=) , base rewards= tensor([1.5684, 1.0572, 0.5334]) return= 16443.3291015625\n", + "probs of actions: tensor([0.9170, 0.9332, 0.9897], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5924])\n", + "finalReturns: tensor([0.0759, 0.0840, 0.0591])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 49999 adversary: AdversaryModes.guess_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0073, grad_fn=) , base rewards= tensor([1.5684, 1.0572, 0.5334]) return= 16443.3291015625\n", + "probs of actions: tensor([0.9562, 0.9609, 0.9917], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5924])\n", + "finalReturns: tensor([0.0759, 0.0840, 0.0591])\n", + "3,[1e-05,1][1, 10000, 1, 1],1682432800 saved\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/2\n", + "adversaryProbs[10]=1/2\n", + "\n", + "game2 = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=3)\n", + "neuralNet2=NNBase(num_input=game2.T+2+game2.advHistoryNum, lr=hyperParams[0],num_actions=10)\n", + "algorithm2 = ReinforceAlgorithm(game2, neuralNet2, numberIterations=2, numberEpisodes=150_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm2.solver(print_step=10_000,options=codeParams,converge_break=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 4999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 9, 1])\n", + "loss= tensor(-9.9287e-05, grad_fn=) , base rewards= tensor([0.5833, 0.5833, 0.5833]) return= 16228.953125\n", + "probs of actions: tensor([0.2623, 0.0413, 0.3706], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5285, 0.5832])\n", + "finalReturns: tensor([-0.0001])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([1, 1, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5550, 0.5550, 0.5550]) return= 16062.75\n", + "probs of actions: tensor([0.3145, 0.3380, 0.4951], grad_fn=)\n", + "rewards: tensor([0.5111, 0.5401, 0.5550])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 14999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([2, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5189, 0.5189, 0.5189]) return= 15607.5166015625\n", + "probs of actions: tensor([0.0528, 0.5551, 0.6944], grad_fn=)\n", + "rewards: tensor([0.5108, 0.5311, 0.5189])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 19999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5207, 0.5207, 0.5207]) return= 15556.9150390625\n", + "probs of actions: tensor([0.7058, 0.6916, 0.8564], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5207])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 24999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.8063, 0.8006, 0.9439], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 29999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([1, 1, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5234, 0.5234, 0.5234]) return= 15618.2587890625\n", + "probs of actions: tensor([0.0701, 0.0750, 0.9747], grad_fn=)\n", + "rewards: tensor([0.5111, 0.5273, 0.5234])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 34999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.8996, 0.9000, 0.9876], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5495, 0.5495, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.9206, 0.9219, 0.9927], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 44999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5207, 0.5207, 0.5207]) return= 15556.9150390625\n", + "probs of actions: tensor([0.9360, 0.9369, 0.9953], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5207])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 2 ep 49999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.5207, 0.5207, 0.5207]) return= 15556.9150390625\n", + "probs of actions: tensor([0.9462, 0.9477, 0.9968], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5238, 0.5207])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 4999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([0, 4, 0])\n", + "loss= tensor(0.0426, grad_fn=) , base rewards= tensor([1.0445, 1.0445, 0.5207]) return= 15686.2275390625\n", + "probs of actions: tensor([0.7717, 0.0379, 0.9776], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5222, 0.5352])\n", + "finalReturns: tensor([0.0129, 0.0145])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 9999 adversary: AdversaryModes.myopic\n", + " actions: tensor([0, 0, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([1.0860, 1.0860, 0.5495]) return= 15972.328125\n", + "probs of actions: tensor([0.4679, 0.1240, 0.9332], grad_fn=)\n", + "rewards: tensor([0.5112, 0.5366, 0.5495])\n", + "finalReturns: tensor([0., 0.])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 14999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([7, 5, 0])\n", + "loss= tensor(0.0403, grad_fn=) , base rewards= tensor([1.0638, 1.0638, 0.5144]) return= 15857.2041015625\n", + "probs of actions: tensor([0.0647, 0.0819, 0.9311], grad_fn=)\n", + "rewards: tensor([0.5063, 0.5470, 0.5324])\n", + "finalReturns: tensor([0.0156, 0.0181])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 19999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0288, grad_fn=) , base rewards= tensor([1.0695, 1.0695, 0.5126]) return= 15972.0400390625\n", + "probs of actions: tensor([0.1795, 0.3327, 0.9484], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5453])\n", + "finalReturns: tensor([0.0246, 0.0327])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 24999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([2, 9, 0])\n", + "loss= tensor(0.0168, grad_fn=) , base rewards= tensor([1.0499, 1.0499, 0.5189]) return= 15855.7197265625\n", + "probs of actions: tensor([0.0339, 0.5428, 0.9522], grad_fn=)\n", + "rewards: tensor([0.5108, 0.5230, 0.5518])\n", + "finalReturns: tensor([0.0248, 0.0329])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0104, grad_fn=) , base rewards= tensor([1.1363, 1.1363, 0.5663]) return= 16656.75\n", + "probs of actions: tensor([0.4170, 0.7119, 0.9591], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0263, 0.0344])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 34999 adversary: AdversaryModes.myopic\n", + " actions: tensor([7, 7, 0])\n", + "loss= tensor(0.0648, grad_fn=) , base rewards= tensor([1.1250, 1.1250, 0.5625]) return= 16529.8125\n", + "probs of actions: tensor([0.0619, 0.0525, 0.9628], grad_fn=)\n", + "rewards: tensor([0.5063, 0.5576, 0.5891])\n", + "finalReturns: tensor([0.0217, 0.0266])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 39999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0045, grad_fn=) , base rewards= tensor([1.0695, 1.0695, 0.5126]) return= 15972.0400390625\n", + "probs of actions: tensor([0.5592, 0.8670, 0.9698], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5453])\n", + "finalReturns: tensor([0.0246, 0.0327])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 44999 adversary: AdversaryModes.myopic\n", + " actions: tensor([8, 9, 0])\n", + "loss= tensor(0.0031, grad_fn=) , base rewards= tensor([1.1306, 1.1306, 0.5644]) return= 16616.703125\n", + "probs of actions: tensor([0.1021, 0.9133, 0.9802], grad_fn=)\n", + "rewards: tensor([0.5048, 0.5582, 0.5987])\n", + "finalReturns: tensor([0.0262, 0.0343])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 49999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 7, 0])\n", + "loss= tensor(0.0893, grad_fn=) , base rewards= tensor([1.0695, 1.0695, 0.5126]) return= 15930.4462890625\n", + "probs of actions: tensor([0.6918, 0.0129, 0.9857], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5520, 0.5379])\n", + "finalReturns: tensor([0.0205, 0.0254])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 0 ep 4999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([1.5237, 1.0125, 0.4887]) return= 15972.0400390625\n", + "probs of actions: tensor([0.8788, 0.9730, 0.9722], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5453])\n", + "finalReturns: tensor([0.0735, 0.0816, 0.0566])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 9999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0094, grad_fn=) , base rewards= tensor([1.5237, 1.0125, 0.4887]) return= 15972.0400390625\n", + "probs of actions: tensor([0.9196, 0.9793, 0.9740], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5453])\n", + "finalReturns: tensor([0.0735, 0.0816, 0.0566])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 14999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0073, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9445, 0.9845, 0.9731], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 19999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([2, 9, 0])\n", + "loss= tensor(0.2577, grad_fn=) , base rewards= tensor([1.5485, 1.0373, 0.5135]) return= 15855.7197265625\n", + "probs of actions: tensor([0.0010, 0.9870, 0.9723], grad_fn=)\n", + "rewards: tensor([0.5108, 0.5230, 0.5518])\n", + "finalReturns: tensor([0.0371, 0.0375, 0.0383])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 24999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0046, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9676, 0.9889, 0.9817], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 29999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9767, 0.9914, 0.9822], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 34999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0029, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9817, 0.9931, 0.9846], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 39999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0024, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9843, 0.9944, 0.9879], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 44999 adversary: AdversaryModes.myopic\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([1.5889, 1.0777, 0.5411]) return= 16656.75\n", + "probs of actions: tensor([0.9862, 0.9954, 0.9894], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5619, 0.6006])\n", + "finalReturns: tensor([0.0767, 0.0848, 0.0595])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 49999 adversary: AdversaryModes.imitation_132\n", + " actions: tensor([9, 9, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([1.5237, 1.0125, 0.4887]) return= 15972.0400390625\n", + "probs of actions: tensor([0.9887, 0.9962, 0.9923], grad_fn=)\n", + "rewards: tensor([0.5031, 0.5488, 0.5453])\n", + "finalReturns: tensor([0.0735, 0.0816, 0.0566])\n", + "3,[1e-05,1][1, 10000, 1, 1],1682433760 saved\n" + ] + }, + { + "ename": "TypeError", + "evalue": "'AxesSubplot' object is not subscriptable", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [6]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 8\u001b[0m neuralNet3\u001b[38;5;241m=\u001b[39mNNBase(num_input\u001b[38;5;241m=\u001b[39mgame3\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m+\u001b[39mgame3\u001b[38;5;241m.\u001b[39madvHistoryNum, lr\u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m0\u001b[39m],num_actions\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m)\n\u001b[0;32m 9\u001b[0m algorithm3 \u001b[38;5;241m=\u001b[39m ReinforceAlgorithm(game3, neuralNet2, numberIterations\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, numberEpisodes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m150_000\u001b[39m, discountFactor \u001b[38;5;241m=\u001b[39mhyperParams[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m---> 12\u001b[0m \u001b[43malgorithm3\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolver\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprint_step\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5_000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcodeParams\u001b[49m\u001b[43m,\u001b[49m\u001b[43mconverge_break\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:107\u001b[0m, in \u001b[0;36mReinforceAlgorithm.solver\u001b[1;34m(self, print_step, options, converge_break)\u001b[0m\n\u001b[0;32m 103\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m stage \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mT\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[0;32m 104\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlearn_stage_onwards(\u001b[38;5;28miter\u001b[39m,stage\u001b[38;5;241m=\u001b[39mstage, episodes\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnumberEpisodes\u001b[38;5;241m/\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mT), print_step\u001b[38;5;241m=\u001b[39mprint_step, options\u001b[38;5;241m=\u001b[39moptions,\n\u001b[0;32m 105\u001b[0m prob_break_limit_ln\u001b[38;5;241m=\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprobBreakLn \u001b[38;5;28;01mif\u001b[39;00m converge_break \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m), write_save\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m stage\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m--> 107\u001b[0m \u001b[43maxs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43miter\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturns[\u001b[38;5;28miter\u001b[39m])\n\u001b[0;32m 108\u001b[0m axs[\u001b[38;5;28miter\u001b[39m][\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mscatter(\u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss[\u001b[38;5;28miter\u001b[39m])\n\u001b[0;32m 110\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mTypeError\u001b[0m: 'AxesSubplot' object is not subscriptable" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1/2\n", + "adversaryProbs[3]=1/2\n", + "\n", + "game3 = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=3)\n", + "neuralNet3=NNBase(num_input=game3.T+2+game3.advHistoryNum, lr=hyperParams[0],num_actions=10)\n", + "algorithm3 = ReinforceAlgorithm(game3, neuralNet2, numberIterations=1, numberEpisodes=150_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "algorithm3.solver(print_step=5_000,options=codeParams,converge_break=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD4CAYAAADsKpHdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1b0lEQVR4nO2dfZRU5Zngf09VF1hNErrRTlYaEDURNohC7ASyTHaE7IRsHGNrNMjoxt1x14wzyRk10zOwcUacY0aUJHrc7DpjopM4OKT9mo4jOmR28CRzGMG0AUQysoGoQONEDDRJ7Baqu979o+7tvnX7flXVra++z++cgqr33ve9b1Xfe5/7Pp9ijEFRFEVRUvWegKIoitIYqEBQFEVRABUIiqIoioUKBEVRFAVQgaAoiqJYtNR7AuVyxhlnmLlz59Z7GoqiKE3Fiy+++JYxpsNrW9MKhLlz59Lf31/vaSiKojQVIvK63zZVGSmKoiiACgRFURTFQgWCoiiKAqhAUBRFUSxUICiKoihAE3sZxcGtfXvYtOMQo8aQFmH1ktl0nTWDDVv2cWRwmJltWXpWzqN7cafv/nd0L5wwbt/OATZs2cfA4DBpEUaNodM1llI6Yb/rrX172Lj9YL2nqSg15bX1l8Q2ljRrttOuri5Tidup380jnRJG8+O/STaT5s4rFtL/+jHP/adNSTN0anRMeACsfXIPw7nRCfvaY6lQKJ2+nQOBv+uH5kxn24FjdZiZotSfUoSCiLxojOny2pbYFcKmHYc8253CAGA4N8qGLfv4txPveO7/9qnCDWpgcJi1T+7htEzK86blHEsFQuls2LIv8HdVYaAolZMogWCrHI4MDlPKuijq/sO5Ud+blnMspXT0d1OU6pMYgRCkcggjTqXa9Gym6LNTSLltFso4M9uyDKhQUJSqkhgvoyCVQ5y0ZTNkM2nf7W+fGqFv5wAwLqQGrBWIrXaytyvj9KycF/i7KopSOYkRCHGrHISCAdpJNpNm3acXcOcVC+lsy3r2y40aNmzZB3gLKdvOoBTTvbgz8HdVlKQSp5dRYgTCzJhvJDPbsqz+yGw627II0NmWHfMg6l7cybY1KxCfvrZw8hNSqi/3xv5dFSXppASuXTonVmEACRIIPSvn+d6gy2FgcJiN2w8yEKD79xNCdnvYdmUit/btqfcUFKXu5A1s3H4w9ushMQKhe3FnrMZhJ366fy+9dzaTHotXCNuuTMTPXVhRkkjc10OoQBCRh0TkTRF52dX+RRHZJyJ7ReRuR/sFIvK81b5HRE6z2i+yPu8XkftERKz2qSLSa7XvEJG5sX5DB9XUP3vp/p16b7daKcp2ZSKjTRpIqSjVIO7rIYrb6beBbwAP2w0ishy4DLjAGHNSRN5rtbcAG4H/YozZLSKnAzmr2/3ADcB24Bngk8CzwPXAcWPM+0XkauAuYFUM320Cy+d3VDW1gZfu37Yp+BG2XSnGTlmhKErheoiT0BWCMeaHgDsM9EZgvTHmpLXPm1b7J4CXjDG7rfZfGGNGReRM4D3GmOdNIVfGw0C31ecy4DvW+8eBj9urh7j5ux9X153TAMvWb1W30Sqyesnsek9BURqGuK+Hcm0I5wEfs1Q8PxCRDzvajYhsEZEfi8gfW+2dwGFH/8NWm73tEIAxZgQ4AZzudVARuUFE+kWk/+jRoyVP2k4zUU00lkBRlFrhlVyzEsoVCC1AO7AU6AEetZ7qW4DfAK6x/r9cRD4Ong4+9ro/aFtxozEPGGO6jDFdHR2eNaIbAo0lqB5qVFaU6lGuQDgMPGkKvADkgTOs9h8YY94yxgxRsBV8yGqf5eg/CzjiGGs2jNkgpjNRRdV0aCxBdVD7gaKMs+Qr/xjreOUKhD5gBYCInAdMAd4CtgAXiEirdXP/TeAnxpg3gF+JyFJrJfE54HvWWE8B11nvrwS2mmbNye3AjiXo2znAsvVbOXvNZrUvxEDcRjRFaWZ+/qtTsY4Xxe10E/A8ME9EDovI9cBDwDmWK+p3geus1cJx4OvAj4BdwI+NMZutoW4EvgXsBw5Q8DACeBA4XUT2A7cAa+L6cvXCjiXQXEXxo0ZlRakeoW6nxpjVPpuu9dl/IwXXU3d7P3C+R/s7wFVh82gWUgIfmjN9rLKXG62JUBm2EU0roylK/CQmUrlW5A1sO3AsMFWz2hcqo+usGbGmIVGUZuV9754S63iJEQiNpKbRXEWVsWHLvqqlIVGUZuF9757Cji//VqxjJqZATqO4gWquotJxFxHSQjlKrWjNpJiaSTM4lCtKYtm3c4B1T+1lcDhXtH9aYNT1tNLpkfyyb+cAPY/tIpcf3+8D753G0Km8b7Esr2JacZMYgdAIapq0SFGMgtoRwnFXulNhoNSSoVyeIeuuPTA4TM9ju+l//Ri9Lxwil5+4TnULA7vf2icLWUltYXJT764J+/30zbcD+7ivA+f2uEiMyqieappMSsikx3PwqLdRdGpV6U5RopDLGx7ZcdBTGAThfBCMqq1w96lFMa3ECIR6qWnSIrzrtBZyrkcHjWaORiOs7BTFSblRUmGFscrpE/f1kRiBUC/1TN4YBodyntv0ZhdOW2um3lNQlFgIK4xVTp+4NR+JEQj1Yno2o5XRyqRv5wC/fmek3tNQlCJaMykyqdIcn92FscrpU4tiWioQqszbp0ZYPr9jwh8TYOjUiNoRAtiwZV/JulpFqSaZtPAXV1zAhqsupC07cfWa9pATXoWx7l21iIzr7vuB906rezEtada0QV1dXaa/v7+kPnPXbA7fqQJEvPWLttuZl5taNpNu2CppXm5utZzn2Ws2a7xBk3Dt0jk898rRyOfKsvVby/IYs68XoKJzM+q5Xe9roBqIyIvGmC7PbSoQqo8Ar66/xPci6GzLsm3NitpPzIH7xF8+v4MnXhwo8myotfDy+70En/zoSkPR3prhjHdNKXKnrAZTW1Lc9ZkLgHEhMT2bQYSi+AHndr+be7kCoNR+9RQ0QQIhMXEI9cS2Ffg9EdXbuOzl4/zI9oMTbrq1zsPUs3Je0bygIJTUDbU5OD6U47iPQ0WcnBzJc1PvLjJpGfPmc67E7fgBhLHtXn785fr6l9qvVjEF5aA2hCrjzHzqZ4aqt3HZy8fZ7wm8lsLLT2+qKF64XbuLtuVNqOt3ub7+pfarVUxBOegKoYoIheynN/fuAvG/ybo9BUpZTsax9CzlJl9r4dW9uLPoCa4RLhpl8uA898v19S+1X61iCsohMQLh1r49NT+mwVHHOaLSO2g5CQTq+ctdevrlB3Lr6uuZh8n9uyhKHDgfcPyug7CHoFL7lXucWpAYldEjDZw/P8qydd1TeycU23lk+8FYlp5+Ps7XLJ1TdTe3qGgKCyWMjJfPp73NSh/jxP2AU66vf6n9ahVTUA6JWSE0sldKlGWr210V4tPz2zf5RvaSaITltFIarZkU7+Ty5MN3LcJWtXqZBDIpYTRvisaMy8uonOugnH7lHqcWJMbttF4up1Fwup2W65/tN1418FLfVNslNY7fRSnQGZJC/N5VizyzcboR4J5VizxTMvvF3JyWSfl6HnmdQ5MxDqDeqNtpA+O1bC1FV14PPX+Ql0Q1Lta+nQO8fVJTWMRFmGCNIgygcN459x0YHA7sO5wbDTyvh3Oj3Ny7i5t7d/nm++9//dgEYdPemuG2SxeUdO7d2reHTTsOjWUghkIiylFjaPNYXXQv7uSabz7PtgPHisbxqnXgpNkEmq4QGggBrlk6h66zZng+YbnJZtJ85qJOnnvlKAODw2MndKkn6fL5Hb5Rpl4n9M29uzzVVXYAXpz07Ryg5/HdgS6FyuQkk5Ki2IHAfdPChisvjHSzvbVvT0k1ubOZNLPaT/MNsPNbHddjJR0FjVSmOQSCzbJzZ/DjgydCVwn3rlrkWTwDSjtJ3TjTA3iN67fsT4uQNybWJ6HFf/79mgQ3Kc1PVFXpuWufKVoZVOvYjZqZQFVGTYZ7WepFZ1u2yDgVVYUTxVvH6ankNe7UlpRnxLC7ABCMV3sqd9mswkCJSlTHg7iFgd+xGznewI/EuJ1OJtx2glJOvKgn45HBYd99TwzniiKI0zLR3c8WKvaKxOkuq9XilGoQ1Y/f63ytxrGbMe29CoQmwyseoJQTL2rBmZlt2cBxuxd3sm3NCl5dfwl5nyeuI4PDFYXpB6X7UCY/KYJjC5xk0hLZmWL1ktklzSObSfOB904L3O517EaON/AjVCCIyEMi8qaIvOxq/6KI7BORvSJyt2vbHBH5tYj8kaPtIhHZIyL7ReQ+kYKYFpGpItJrte8QkbkxfbciSqxn0bBsW7Nigrol6okXteCM3TfquEGCo9xls72yaE4Ll+Ik6NLLpPyvzXRaWPXh2UXBkdcunTOhDkF7ayayQRngju6FXLt0zoSVgv25LZuhvTVTFJD5j7dczLJzZ0wYKyhgs1Y1DOIk1KgsIv8R+DXwsDHmfKttOfBl4BJjzEkRea8x5k1HnyeAPLDDGPNVq+0F4A+B7cAzwH3GmGdF5PeBC4wxvyciVwOXG2NWhU18MhuV60FKIG8KF8XqJbPpOmsGG7bs83VRnNqSYs6MrK/nRViK6mwmxdSWdKgnldI4tGUzTJva4msLqsSI2qgG2MlIRUZlY8wPPZ7abwTWG2NOWvs4hUE38DPgbUfbmcB7jDHPW58fBrqBZ4HLgHXWro8D3xARMTG7P7W3ZtRAGYBdmGzUGHpfOETvjw4FuvudHMkH5rkP++MN5/IM50qNYVXqyeBwbkyA2zEHt//9Xi654Mwx12cv7NWg7VzgdpFePr8jltTwpSaFdLp2lxPLENdcGolybQjnAR+zVDw/EJEPA4jINOBPgNtd+3cChx2fD1tt9rZDAMaYEeAEcLrXQUXkBhHpF5H+o0ePljThJvWurQteqYIVxYvjQzk2bj8YGOw2sy1b5FwAxR5pQTEB0z3KVHpRivNC384Beh7bXbQ6PT6Uo+fx3bE4OzSzI0W5AqEFaAeWAj3Ao5ZN4HbgHmPMr137e2kJTYRtxY3GPGCM6TLGdHV0dJQ04ROqmlCUmmPbnMpNThjVIagU5wW/Wt25URNLevVGrncQRrkC4TDwpCnwAgV7wRnAEuBuEXkNuAn4nyLyBWv/WY7+s4AjjrFmA4hICzAdCHfEL5Go3jWKosSD04haru/9YEQ1b1yu13HECDRj/IFNuQKhD1gBICLnAVOAt4wxHzPGzDXGzAXuBf7CGPMNY8wbwK9EZKm1kvgc8D1rrKeA66z3VwJb47YfgKqMSsErVbCilIJtDLb15uX63kftV4rrddCYccQINGP8gU0Ut9NNwPPAPBE5LCLXAw8B51iuqN8FrotwE78R+BawHzhAwaAM8CBwuojsB24B1pT1TUJQlZE/AkVudhuuupANV1445i6X8ThLprakPH2z/cSIs729NePpPqhMDrxck71cmMsZx49SfP57Vs4r5ElyUUosQ1xzaTQSk8to0e3fVxfHEGzPD/v/MNfR1kyKqZl0UVbI/teP8cj2g7793GOmrdKiTpVuJgXqgNQctLdmxryMwjxqgryMSk3Q6IV6GUVDk9sBC/7sH8bLWSpVIZMqXMwe9jqlQXFnqA2K13kt5ky2Sn3Q5HagwqAGeHluKI1NM+i1ldqRGIGgKMpEBgaHI0fxVyvav9UyUg259IS2Gge8y01WW+2TRFQgKIpSV9yCwOb4UI5bHt1FOiVjgZJ2kFf/68fofeFQ0arUDi4DVCiUiWY7VWIjk5JJk0RQaQzyZmLFtOHcKJt2HKpqcFlSScwKIcxjRplIOV5G4F1g3W9MLy8jRQkjqMhNMwSANSqJWSFcs3ROvafQdBgKetll587wjC8YyuU5PpSjrTUzptftXtzJuk8vKIoxaG/NcO+qRby2/hLuWbWIrCOwYdQUfLQ1LkEphaAiN2ooL5/EuJ327Rzgpt5d1ZuQAhRSJP/yndyEJ/6Mldv+b7cfREMMlKikhCIbAhQeID5zUecEGwIUzrNSaiMkEXU7BW7/+731nkIi8FMV5UYNm3YcUmGgTKBcL6Ous2aol1HMJEYgaC2E+lON4uZK6WQzKU6NmNC/R6nFaaoZnetXkUxv/vGSGIGg1B87LYFSX6IUJio1945dA8BO+2y7h4K6gDYTibEh/Ps/fVYrdNURtSFMHtpbM5zxrimBFfNsbNOvO6DMuZJYPr+Dp3e/4av6CcuB1Ij5ghoZzWWE1lQul/bWDB888938y4FjFbnt3rtq0djNYO2TLxUJ52lT0lz+oc7AyllK82Mbg594cSC0WI5tHAaKVh5h4zd6EftGQI3KStkcH8qx7UDl9YqcwUJTW9JFAuHtU6MqDBKAHVAWRW3oDDCLWmnNrkqmAqF8VCAoNWFgcJiex3ZrNtSEU4oNqZwAMw1Kq4zEBKYp9SeXV2GQdIICytzMbMuWHGSmQWmVoQJBUZSakM2kWb1kdqTKaXb1slIqrTVLVbJGJjEqo5RovhxFqTXTpqQZOjU6IaCsFC8jQL2MaoR6GSk1QyuqNSadlpplIED/bgepnb1ms6+3WamBbEp9CPIySozKqBTdpRI/7a0ZNlx1IV//bHFyO6W+RFHNOFUxfjp6AVXXTAISs0K45pvPx+I+qZSHph9XwnCql+aeni2KfbHPH6fKyBZAtjrJjXufI4PDnJZJTYiB+crlwbELfik5yk3V4Rdo5+5frVQgGpgGLLr9+76J1xRFaT4yKQGZWECn1H3SKeFrV3lnSHWn5AD/ALsogXFe43n19ztuHIF3qjLCPwunoijNSS5vAm/0UfcZzftXWduwZd+Em7cdYOfVHlatzWs8r/5+x612NbjECARFURQ//ALa/Nr9AuzCAuOibi91PnGRGIEwbUo0X2ZFUZKHn7Hcr93PSSUsMC7q9lLnExehAkFEHhKRN0XkZVf7F0Vkn4jsFZG7rbbfEpEXRWSP9f8Kx/4XWe37ReQ+kcIvKiJTRaTXat8hInNj/o4AZNKJkX2KkggyKSGTDvYejLJPOiW+HlJe3ld+AXZRAuOienP5HbfanlxRAtO+DXwDeNhuEJHlwGXABcaYkyLyXmvTW8ClxpgjInI+sAWwLSD3AzcA24FngE8CzwLXA8eNMe8XkauBu4BVlX4xNyfUhqAoDU0jehnZ7X4V20r1AnKOF+RlFHTcahLJy8h6an/aGHO+9flR4AFjzP8N6CMUBMRMYAbwnDFmvrVtNXCxMebzIrIFWGeMeV5EWoB/AzpMyMTUy0hRaosGnk0OquFldB7wMUvF8wMR+bDHPp8BdhpjTlJYJRx2bDvM+MqhEzgEYIwZAU4Ap3sdVERuEJF+Eek/evRoSRPOjWpZFkUpFzuATZnclCsQWoB2YCnQAzxq2wQARGQBBdXP5+0mjzFMhG3FjcY8YIzpMsZ0dXR0lDTht09Fy6muKEox7a0ZNlzp7aevTC7KFQiHgSdNgReAPHAGgIjMAv4O+Jwx5oBj/1mO/rOAI45ts62+LcB0QEOKFaXOCAU1kTvRnDJ5KVcg9AErAETkPGAK8JaItAGbgbXGmG32zsaYN4BfichSayXxOeB71uangOus91cCW8PsB4qiVB9DIeHdTb27uLVvT9G2vp0DLFu/lbPXbGbZ+q307RyozySVWInidroJeB6YJyKHReR64CHgHMsV9bvAddZN/AvA+4E/FZFd1sv2QLoR+BawHzhAwcMI4EHgdBHZD9wCrInv6ymKEgcbtx8cu+nbaRUGBofHhMbaJ/eoUJgEJCaXkaa/VpSJiMA1S+ZErnXc2ZZl6NQIx4cmeuypF1JzoLmMFEXxxsAd3Qsj1zoeGBz2FAag9YwnA4kRCO2tmXpPQVEaDjsVQhz1QrSecfOTGIHwwTPfXe8pKEpD4YwtiLpC8EPrGU8OEiMQ/kWL4yjKGO7Ygs4ynu7bWzNjrqlx5OlX6k+UXEaTguY0nStK/HgZf3tWzqPnsd3kXAWvU4JvDezWKS3s/LNPVGuaSh1IzApBUZJCmL3My/jbvbiTDVddSFt2vG97a4avf3ZRSeMozU1iVgiKMplxP/UvW7/VMwMo+Bt/uxd3eqp9/LKJqhF58qErBEVpcoSCO6gzYrhn5bxCPWEXKYGhUyNjEca39u0JjTiuV25+pfYkZoVg51NXlMmGfV7bEcMwnk9/3VN7x9K+t2ZS5PJmLI5gYHCYjdsPjo3j1d/5vta5+ZXak5hI5Vv79hSd/IoyWfGLGA5SI0Xpr0wONFKZQjSmoiSBSgu0q7E4uSRGIChKUqi0QLsai5NLYmwImolRaWZSFIqOhLVlUjJmNJ7pUXc4zJZmG4v7dg6ozSCBJEYgbNiyr95TUJRItLdmOD6UGyvA3pbN8PapEfKjxbdy8Ygay0OR0bjnsd0gkLP6GsYdLDrbsiyf38FzrxwtuvEDrH1yD8O50bFxvIzNyuQjMQJB9aJKs/DL4RHuXbVo7Oa7bP3WMU8hJ6MeIcTuNnfkMYwLAz/D8bL1W8eEgc1wbpQNW/apQJjkJMaGoHpRpVkYNaao4Ew1HmaCxqzUKK00L4kRCBpEozQT9hM5VOdhJmjMSo3SSvOSGIGgS12lHlRygdlP5F6RwpmUkElLaJsXYVHGGpmcXBJjQ1CUWtOaSfHOSN7Xrac1UxAXQzm3r1AB+4ncL1I4qM3Po6i9NcNtly4IfEDSyOTkkhiBoG6nSq05OWJ8U0c7jbp20XqnIdf9RO6XeM6vzS8quXVKS6Qbu9/xlMlNYgTCuqf21nsKSsIIqkLmNNBW44lcDcNKOSRGIHi57SlKNbHjCLxwG2jjfiKf2ZbVlNVKySTGqKwotSSdElYvme2ZgtpZy7haqGFYKYfECISwKlKKEiejecPG7QfJ5Q1Ox5/WTIp3TW3h5t5dvvUH4qB7cSd3XrGQzras1j1WIhMqEETkIRF5U0RedrV/UUT2icheEbnb0b5WRPZb21Y62i8SkT3WtvtERKz2qSLSa7XvEJG5MX6/MW67dEE1hlUSSkrg3lWLeG39Jdy7atGEp3EnowaWnTuDe1ctwiAcH8phGE8JUU2hsG3NCl5dfwnb1qxQYaCEEmWF8G3gk84GEVkOXAZcYIxZAHzVav8gcDWwwOrzf0TEvlLuB24APmC97DGvB44bY94P3APcVcH38UUvBiVO8mY8P9aGLfsmpHpws+3AMc/9nAFocdG3cyC0CpqieBEqEIwxPwSOuZpvBNYbY05a+7xptV8GfNcYc9IY8yqwH/iIiJwJvMcY87wpVOR5GOh29PmO9f5x4OP26iFObu3bE/eQSsKxPXYqrTMQp+eP7cI6MDhck1WIMrko14ZwHvAxS8XzAxH5sNXeCRxy7HfYauu03rvbi/oYY0aAE8DpXgcVkRtEpF9E+o8ePVrShDftOBS+k6KUgO2xU2mdgTg9f2q1ClEmJ+UKhBagHVgK9ACPWk/1Xk/2JqCdkG3FjcY8YIzpMsZ0dXR0lDThIJ9wRSmVlIznx/Ly6HGz7NwZNfH80fgDpRLKjUM4DDxpqX9eEJE8cIbVPtux3yzgiNU+y6MdR5/DItICTGeiiqpignzCFaVU8gZu6t3FTb27Iu2/7cAxth2YeFoP50ZLGqdcDDB3zeaqHkOpD6+tvyS2scpdIfQBKwBE5DxgCvAW8BRwteU5dDYF4/ELxpg3gF+JyFJrJfE54HvWWE8B11nvrwS2WoImVlYvmR2+k6IoSpMRp6APXSGIyCbgYuAMETkM3AY8BDxkuaKeAq6zbuJ7ReRR4CfACPAHxhhboXkjBY+lLPCs9QJ4EPgbEdlPYWVwdTxfTVEURSmFUIFgjFnts+lan/2/AnzFo70fON+j/R3gqrB5VIoalRVFUYJJTKSy2g8URVGCSYxASMcf2qAoijKpSIxAUKOyoiiTkc4Y41gSk/6666wZbNx+sN7TqCp+1bD6dg6EujVmM2nuvGIh4J2XP8oYTuxqXZ0Rc/v37RwoOu7y+R2T/u+lKJXijIeJg8QIhNv/vvkL5LRlM6z79ALWPbXXs77D8aEca58spOhw3oCjRKkO50ZZ99ReTo7kxyJd7bQH9nh2acYo2BYb9xhu3ILgnlWLxvZ7ZPtBv+qTiqIAxsSbpy0xKqPjQ81dICedEtZ9upCx9eSIdw1e8E5TEDVKdXA4F5j2IEpEbtQ5QXDenb6dAyoMFCWEuK+RxKwQmplpU9J85fKFY7VywzJrugWAX/WsqNjjuUs9Ts9mEIkmbL2EkubdUZTKiNtZJjECwdZpNwuZtLDhygsnLAejPO27k6X1rJw3oYi7GwFap6R5+9TEfaZnx4sLeZV6jGJf8ErgVm7enZTgW7xeUZJE3M4yiVEZNdP9Y9qUtKcwgGiZMZfPL07851U9a9m5M4qyChrg1Egej4qPvH1qJDB9cvfizsCKdH4J3IKyfwZ9z3LUVooymUgJXLt0Dnd0L4x33FhHU2KhrXWKr6Eoih7/6d1vTCiQ4q6e9dovhicIyVzeeArO3KgJVePcdukCz3m1t2Z8SzcGZf/sWTnPMw0u4LmKURSlchKjMspmUgzn/I2xjUSQysSpx/ezCwwO58a8kPy8fPyO4RfQHabGcdsXZkZwNw3rU+0MoIrSrOQNY27Zca4SEiMQTsukm0YghKmFbD3+OWs3R9Kl24Za583Zz9DslyY8iqrKy75QSZ9Onzk2mz1IUarFph2HYhUIiVEZDTaJ26lQeKoPq4Xbt3OgJMOq+wnfT12zesnsqhdxiYrXHFUYKMo4cedoS8wKwc+DpubzyKTI5Q250fE/pH2Tc97swgK6SnXNdD/hB6lrus6aUZLqp1q41WMqDBSlGHU7LZN6C4N0SvjaVReOpYFw33C9bAJeqh6bUksiej3h+6lrylH9VAt7LsvWb60olkJRJiNxu50mRiDUm9G8GSuVaPvRd1o5e4IMxAODw2NeQk5KCTZry2Z8b/BO4TQ9m+HUyChDlq3FLzdSnHgJxzgEoKJMJtyr47QIq5fMjt3tVAVCHbB1/wODw5ESuN3Uu4vH+g/yyP/46Fhbz8p53Ny7K1SFks2kx1JeuLFTR9gBa+78SMeHcvQ8vhuIN1+K3/FtNVn/68d47pWjRUKiUVR+SnOTzaT5zEWdPPHiQGjEv72/023afc56IcA9qxYBwd6ApcYR9O0cGMtjNmoMm196g66zZsR6bUoVyhfXhK6uLtPf3x95/8lQYNx9At3at2dCArhMSnjXaS0MDuVC9f9R1TCdbVm2rVlR6fQjH9/9NJQCmsM/TGkG/Dzp/HCe/1GvmbZspihRZNi4YfTtHKDnsd3kXJ4kfhkNghCRF40xXV7bdIXQRGzcfrDoieCO7oUVGYCjqmGqpa7xjYVwfVZhoMRJqZ45zvO0lESRpYwbxoYt+yYIAxgPGo1rlaACocmw7RA2QTUQwgRFKXYIe4UVp12h0qR7ilIOpa4QnB56cZ6zUWJ7bIKER5wPbImJQ5is2Hp+Z8xCUFppJ+6cR344L53jQzm+9NjuwBiJqPjFGShKtfCLtfEjk5YiD70oqWOymXRgbi97n1Jie4KERymCJQwVCJMAd66hqGmln3vlaOC4XonuoOAxVUnBob6dAyxbv5Wbe3cxtSVFe2tmLOneNUvnaPI6pSqkRbjzioXc0b2wKNljWzbj+yAybUpL0WrYK1HktUvnFH2+84qFnrm97GPY+5Syyu5ZOY+MxwXpFliVoiqjSUIUPae73W8/AV5dfwlnBxjiyy045OXZlM2kiyqlOe0izenyoETFaVg9e83mkv7etutl1Mp6eWPGzjF3rI3fuX7CwxZQSpxOXAGedj9ntcRquIWrQJhEnL1mMzPbsrS1Zjxv2O6lpZ8+1N4vqr40aixB384BvvTo7gn6W3cAnn3B9e0ciORaqzQvzoeSqOeb2zvnuVeORuoXpnYJuhbKIe4Az1oEjCbG7TRqIjglPkp1F7126Ryto6wE4o74X/vkS5GSVoa5Z97at8czJiiTglFTiB1yFpGyDdOdZTz5O+MJYPxJH8JXFFEfvoIIcjsNtSGIyEMi8qaIvOxoWyciAyKyy3p9ymrPiMh3RGSPiPyriKx19LnIat8vIveJFJJwiMhUEem12neIyNySvl1EPnrOjGoMqwRQqrvoRhUGSgj2A2zfzgFu6d3lKQympGWi/SvgxOrbOUDvC4c8t+Xy44GkhvEUOPYq189hI+hYPY/tLnJLPT6U45ZHd9Hz+O5AR5CoziKVEMWo/G3gkx7t9xhjFlmvZ6y2q4CpxpiFwEXA5x03+PuBG4APWC97zOuB48aY9wP3AHeV80XCeO0X6t6oKM1O3hSeojds2ef7wHFq1EzQBuTy/kWe/Hz8o1JKHXC/Y+UNRQkvvcatRQ3yUIFgjPkhcCzieAaYJiItQBY4BfxSRM4E3mOMed4URPzDQLfV5zLgO9b7x4GP26uHONFcOIoyOTgyOFzW9VxuDe9Kxq70WOU4i1RCJW6nXxCRlyyVUrvV9jjwNvAGcBD4qjHmGNAJHHb0PWy1Yf1/CMAYMwKcAE73OqCI3CAi/SLSf/RosMukmzh9dRVFqR9hNbeD+pXSHsfYlR7LHRQXx5hBlCsQ7gfOBRZRuPl/zWr/CDAKzATOBr4kIufgHW9kr4+CthU3GvOAMabLGNPV0REtqMpmZFQToylKs2P73fesnOd781p27oySijz5+fhHpZQgM79jpaTw3YLGDapBHhdluZ0aY35uvxeRbwJPWx9/B/gHY0wOeFNEtgFdwD8DsxxDzAKOWO8PA7OBw5aqaTrRVVSR+fmvTsU9pKIoVUQo3CRPWbp1L797p5dRSuB3lhQSQJbijePl42+nqM9mUpwcycfmZRQUTwDBXkbl1C0vlUhup5Zh+GljzPnW5zONMW9Y728GlhhjrhaRPwHmA78LtAI/Aq42xrwkIj8CvgjsAJ4B/pcx5hkR+QNgoTHm90TkauAKY8xnw+aUxGynitJoOGMCguJGqpUx1z5uI1T4axYqdTvdBDwPzBORwyJyPXC35UL6ErAcuNna/X8D7wJepiAM/toY85K17UbgW8B+4ADwrNX+IHC6iOwHbgHWlPEdFUWpMW51RffiTl/vzmo5ddTCFTNJhKqMjDGrPZof9Nn31xRcT7229QPne7S/49dHUZTGIi1C3hjfJ/HOKkT8BhHkiqmrhNLR1BWKokQmbwyvrr/Ed3vPynkTKorFbfh0UgtXzCShAkFRlMjMbMsG6uxrYfh0z6eWK5JSaTb7hgoERVEikc2kWT6/w7MONjAhOWEtqPWKpBT8aoZDdWqUx4HWQ1AUJZS0CJ+5qJPnXjla9fQJpeBVn6DUWgPVohapJuJGVwiKooQyagxPvDjgWzS+njr7Wq5ISqEZ7Ru6QlAUJRLDuUJAlheNorNvJGqRaiJuVCAoihKZUWOqnj5hslCLVBNxowJBURKGSKEYUTnYOvpG1Nk3Go1s3/BDbQiKkjBaUkLXWTM8K4QFYT/dNqrOvhFptt9KVwiK0sAsO3dG0RPmtCnp0D5h5EYLxWI6fXTZbdnM2DbbZtAMT7dK5SRmhSAEVtFTlIZk+8+O87XPXggU3BjtEo5eZFICMrHylhdHBoe5Z9UiTx/+dZ9eoDf+hJIYgaDCQGlGRo2h57HdoTf6tAgbrrqQ/teP8UiE2tQz27I1jypWGp/ECARdISiNigBtrRmOD+U8t4fV+xXga5+9kO7FnWzYsi/0PHd6ujSbjlupLomxIagwUBoVA9x26YIJLoql9Ldv6kFBT83i6aLUj8SsEBSlUel0qG++9OhuRiMUrXL3t/FL9lbNAjXK5CExKwRFaURSAkOnRjh7zWY2bNnH6iWzJ9TcTTGx3q5NNeru9u0cYNn6rZy9ZjPL1m/VYjMJQgWCotQREeH4UG6s2lfvC4fIu/ZJp4VVH54dyRW00mAorUCWbBKjMlKjstKIjLoMxl4G5Nyo4blXjkZW+VRiKNYKZMkmMSuE1hgCehSlXtQqQ2YzZuhU4iMxAiEooEdRGp1aZchsxgydSnwkRmWUFinZe0NRqk06JRPURl4MnRqhb+dAoNqmknKNdt+BweEJ6tVGz9CpxEdiBIIKA6URyecN7QFBaTbHh3KB5RcrKdfo7msYt7l1avRyokiMysgvkZeiVBtvh9ECBmid0sK9qxaFBqYFlV+spFyjV19bGGxbs0KFQYJIjEDQJa9SL8LWpkcGh4vcRcP2jaM9rr7K5CJUIIjIQyLypoi87GhbJyIDIrLLen3Kse0CEXleRPaKyB4ROc1qv8j6vF9E7hMpOFOLyFQR6bXad4jI3Cp8T33KURoW22DbvbjTM7DMa99K2+Pqq0wuoqwQvg180qP9HmPMIuv1DICItAAbgd8zxiwALgZs5ej9wA3AB6yXPeb1wHFjzPuBe4C7yvsqwdzat6cawypKIJm00N6aCdxn+fyOsfde6hubIONuJRHKzVjqUakOoQLBGPND4FjE8T4BvGSM2W31/YUxZlREzgTeY4x53hhjgIeBbqvPZcB3rPePAx+3Vw9xsmnHobiHVJQi0gKtmfFLqr01w4YrLwxNXPfEiwNjkcBBapqgiONKIpSbsdSjUh0q8TL6goh8DugHvmSMOQ6cBxgR2QJ0AN81xtwNdAKHHX0PW21Y/x8CMMaMiMgJ4HTgLfcBReQGCqsM5swprSasehkp1WLcpVkYyuV9PXNst043zkjgoOR0YTfoSiKUNQ22AuUble8HzgUWAW8AX7PaW4DfAK6x/r9cRD6Ot6OFfYcO2lbcaMwDxpguY0xXR0eH1y6+pONfdCgKMP6wYf/vlf+ne3En29as8PU4slcG1VbfaOI6JYiyBIIx5ufGmFFjTB74JvARa9Nh4AfGmLeMMUPAM8CHrPZZjiFmAUccfWbDmA1iOtFVVJFZvWR23EMqii9+Lp9hBtxqqm80cZ0SRlkCwbIJ2FwO2B5IW4ALRKTVurn/JvATY8wbwK9EZKllH/gc8D2rz1PAddb7K4Gtlp0hVu7oXhj3kIoSiJc9IMoKwF5NvLr+kljjACqJVVCSQagNQUQ2UfAWOkNEDgO3AReLyCIKqp3XgM8DGGOOi8jXgR9Z254xxmy2hrqRgsdSFnjWegE8CPyNiOynsDK4OobvpSh1JyXCrX17eO6Vo2PpJJbP72BqS2rsxtzemuG2S8OL2leSlsJG4w2UMEIFgjFmtUfzgwH7b6Tgeupu7wfO92h/B7gqbB6K0mhkMymGc+7qBeOMGsPG7QfHPg8MDhd9BngnoL9NJWkpnPgZrDXeQLFJTKSyosRJNpPmtDJrIDuJorKJS9Wj8QZKGIkRCGo4U+LkzisWMhiSkC4qYSqbuFQ9Gm+ghJGYbKfrntpb7ykok4S0CN2LO33jCkolTGUTp6pH4w2UIBKzQhgcjudpTlFsF+awvENRiKKyUVWPUisSIxAUJYz3vXtK4PaUwLVL54y5MHupYK5dOqekz1FUNqrqUWpFYlRGUYqQKNXDXYXLTu8AcPOju6hGZpFsJsXJkTx5U1DzrF4ym+deOeqbGiJqEXsntVLBqKpHqQWJEQi3XbqAm3p31XsakbH904Ex//Pp2QxvnxohNzp+98xm0tx5xcKy9Nl2X68bzbL1Wz3HS4uQN6ZsX3gvbo7x75IW4WufvdB3Xm4XTlD1i6LYJEYgdC/ubAqBIMA1S+fQddaMokCke1Ytontxp2+AUqk31bCAKD8PlrwxvLr+khK/VTBBCd2Wz+9g045DjBozYZXhN78gIWVvqzTIS1EmI4kRCM2CAXpfOETvjw6NrQTcgUheN6/p2UxJhvOwgKhaBjH1rJzn+9TevbiTO7oXej7Z+807DFW/KIo3iRIIzWJHyOUnPgc7UyR7UWoy17Dxgm7S5eJe3Syf3zGW1mF6NsNpmRSDQznPp/agwjE2mZQwdGqEs9ds1id/RSmDRAmEZrMjuAkKRConSCpovLhVK17pF5xpHAaHc2Qz6THVmJsw+4hY/9gCv9z0DoqSZBIlEJrFjuBHkDokSA8P3jfUMPVKnKqVKE/4QauW8SI0EymkkUhNWP2FrYIURSlG4xCqQKWleDIpIZOeOMrxt0+y+M+/71ncJCh4qRECm6KmWRgYHPasfx1U8e4zF3X6rpC8jqtFYhTFm0StECA8Q2UcFIopFv7PpKCUwzn989c9tbfIUDyUyzNkDeZnaA5S8dTTs8ZvBeOFrUpy1rDoDOj/xIsDtPnYh9yroLgyhyrKZESqUIumJnR1dZn+/v6S+52zdjMeNtuq0NmW5d9OvBOpnrNXTIBfLID7GOUEVNWaqF5CNmkRDtz5qcj927IZTo7kJxjBo/6mzfI7KkqliMiLxpgur22JUxnVShhAQV0RJgyCUhFEUbM0S3ETvzQPfrh/N7u/HyeGc5HSO2iRGEXxJ3EqoyDjpBf2k2PQkyX4G22DVghhT6VR1CzNVNzEy0htB525SXv40QZlGJ3Zlo1kBNciMYriT+JWCHamSjfLzp0RaHgt12jrd7x0SsrKcuk3v2bF7/fxa6/UQN4IBnZFaVQSt0KwDZX2k6md9MyOhvUzvJZrtLW3P7L94FjahWlT0nzl8mhZLp3jTs9mEME3eKsZCfp7eFFpfISmrlAUfxJnVFYURUkyalRWFEVRQlGBoCiKogAqEBRFURQLFQiKoigKoAJBURRFsWhaLyMROQq8Xmb3M4C3YpxONWj0OTb6/EDnGAeNPj9o/Dk22vzOMsZ0eG1oWoFQCSLS7+d21Sg0+hwbfX6gc4yDRp8fNP4cG31+TlRlpCiKogAqEBRFURSLpAqEB+o9gQg0+hwbfX6gc4yDRp8fNP4cG31+YyTShqAoiqJMJKkrBEVRFMWFCgRFURQFSKBAEJFPisg+EdkvImuqfKzZIvKciPyriOwVkT+02meIyD+KyE+t/9sdfdZac9snIisd7ReJyB5r230ihQoyIjJVRHqt9h0iMreMeaZFZKeIPN2g82sTkcdF5BXrt/xoI81RRG62/r4vi8gmETmt3vMTkYdE5E0RednRVpM5ich11jF+KiLXlTjHDdbf+SUR+TsRaavXHL3m59j2RyJiROSMev6GsWOMScwLSAMHgHOAKcBu4INVPN6ZwIes9+8G/h/wQeBuYI3Vvga4y3r/QWtOU4GzrbmmrW0vAB+lUHXzWeA/W+2/D/yl9f5qoLeMed4C/C3wtPW50eb3HeC/W++nAG2NMkegE3gVyFqfHwX+a73nB/xH4EPAy462qs8JmAH8zPq/3XrfXsIcPwG0WO/vquccveZntc8GtlAIjD2jnr9h7PesWhykUV7WH2WL4/NaYG0Nj/894LeAfcCZVtuZwD6v+Vgn3UetfV5xtK8G/sq5j/W+hUJEpJQwp1nAPwErGBcIjTS/91C44YqrvSHmSEEgHLIu3hbgaQo3tbrPD5hL8c226nNy7mNt+ytgddQ5urZdDjxSzzl6zQ94HLgQeI1xgVC33zDOV9JURvbFa3PYaqs61nJwMbADeJ8x5g0A6//3hsyv03rvbi/qY4wZAU4Ap5cwtXuBPwbyjrZGmt85wFHgr6Wg1vqWiExrlDkaYwaArwIHgTeAE8aY7zfK/FzUYk5xXmO/S+GJumHmKCKfBgaMMbtdmxpifpWSNIEwsXI7Y5Utq3dQkXcBTwA3GWN+GbSrR5sJaA/qE2Vevw28aYx5Mcr+AceqyvwsWigs2+83xiwG3qag7miIOVp6+MsoqAlmAtNE5NpGmV9E4pxTLHMVkS8DI8AjjTJHEWkFvgz8mdfmes8vDpImEA5T0P/ZzAKOVPOAIpKhIAweMcY8aTX/XETOtLafCbwZMr/D1nuveY/1EZEWYDpwLOL0lgGfFpHXgO8CK0RkYwPNz+5/2Bizw/r8OAUB0Shz/E/Aq8aYo8aYHPAk8B8aaH5OajGniq8xy4j628A1xtKZNMgcz6Ug+Hdb18ws4Mci8u8aZH6VUwu9VKO8KDxt/ozCH9U2Ki+o4vEEeBi419W+gWLj3t3W+wUUG6Z+xrhh6kfAUsYNU5+y2v+AYsPUo2XO9WLGbQgNNT/gn4F51vt11vwaYo7AEmAv0GqN+x3gi40wPybaEKo+Jwq2lFcpGEPbrfczSpjjJ4GfAB2u/eoyR/f8XNteY9yGULffMM5X1Q/QaC/gUxS8fQ4AX67ysX6DwlLvJWCX9foUBT3hPwE/tf6f4ejzZWtu+7C8Eaz2LuBla9s3GI8yPw14DNhPwZvhnDLnejHjAqGh5gcsAvqt37HPukgaZo7A7cAr1th/Y90U6jo/YBMFm0aOwhPn9bWaEwXd/37r9d9KnON+CvrzXdbrL+s1R6/5uba/hiUQ6vUbxv3S1BWKoigKkDwbgqIoiuKDCgRFURQFUIGgKIqiWKhAUBRFUQAVCIqiKIqFCgRFURQFUIGgKIqiWPx/GO0mK4VRTgMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(range(len(algorithm3.returns[0])),algorithm3.returns[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/small.ipynb b/learningAgents/naive_policy_gradient/PGM_base/previous files/small.ipynb new file mode 100644 index 0000000..bffa53b --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/small.ipynb @@ -0,0 +1,1963 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningBase import ReinforceAlgorithm\n", + "import environmentModelBase as model\n", + "from neuralNetworkSimple import NNBase\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "const95= model.Strategy(model.StrategyType.static, model.const,name=\"const95\", firstPrice=95 )\n", + "actionStep=3\n", + "adv= model.Adversary()\n", + "adv._strategies.append(const95)\n", + "adv._strategyProbs=torch.ones(1)\n", + "game = model.Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversary=adv, stateAdvHistory=1, actionStep=actionStep)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hyperParams=[0.000005, 1, 0]\n", + "codeParams=[1, 10000, 1, 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "----------------------------------------\n", + "iter 0 stage 24 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 3, 42, 3, 12, 0, 0, 0, 6, 6, 36, 6, 15, 6, 30, 9, 0, 3, 6,\n", + " 3, 42, 3, 6, 6, 3, 0])\n", + "loss= tensor(-0., grad_fn=) , base rewards= tensor([0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113,\n", + " 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113,\n", + " 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113, 0.2113]) return= 62979.42909757305\n", + "probs of actions: tensor([0.2569, 0.0078, 0.2615, 0.0434, 0.2830, 0.2847, 0.2901, 0.1838, 0.1792,\n", + " 0.0102, 0.1705, 0.0234, 0.1853, 0.0105, 0.0954, 0.2553, 0.2298, 0.2041,\n", + " 0.2421, 0.0096, 0.2458, 0.1886, 0.1877, 0.2351, 0.3951],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.2316, 0.4602, 0.3599, 0.3409, 0.2840, 0.2447, 0.2136, 0.2075,\n", + " 0.0771, 0.2730, 0.2320, 0.2574, 0.1532, 0.2833, 0.2729, 0.2361, 0.2150,\n", + " 0.2113, 0.0243, 0.2864, 0.2509, 0.2349, 0.2260, 0.2113])\n", + "finalReturns: tensor([0.])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([3, 0, 0, 3, 0, 0, 9, 0, 6, 3, 0, 0, 0, 6, 0, 0, 3, 6, 3, 0, 3, 6, 3, 3,\n", + " 3])\n", + "loss= tensor(0.0080, grad_fn=) , base rewards= tensor([0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337,\n", + " 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337,\n", + " 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.3337, 0.1635]) return= 52462.04122834946\n", + "probs of actions: tensor([0.4363, 0.2692, 0.2836, 0.4190, 0.2666, 0.2884, 0.0413, 0.2971, 0.2062,\n", + " 0.4231, 0.2851, 0.2973, 0.2680, 0.2101, 0.2771, 0.2523, 0.4025, 0.2236,\n", + " 0.4208, 0.2826, 0.4316, 0.2136, 0.4160, 0.4585, 0.4117],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.4080, 0.3295, 0.2753, 0.2467, 0.2186, 0.1905, 0.2040, 0.1846,\n", + " 0.1886, 0.1840, 0.1737, 0.1661, 0.1569, 0.1685, 0.1623, 0.1568, 0.1567,\n", + " 0.1674, 0.1683, 0.1612, 0.1600, 0.1700, 0.1693, 0.1688])\n", + "finalReturns: tensor([0.0043, 0.0052])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([ 6, 6, 0, 6, 6, 3, 0, 3, 27, 0, 6, 3, 0, 3, 3, 6, 3, 3,\n", + " 0, 6, 3, 3, 6, 3, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451,\n", + " 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451,\n", + " 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.3451, 0.1684]) return= 55844.69544871044\n", + "probs of actions: tensor([0.3940, 0.4652, 0.2322, 0.4760, 0.4480, 0.2834, 0.1864, 0.2675, 0.0010,\n", + " 0.1776, 0.4118, 0.2668, 0.1869, 0.2454, 0.2470, 0.4796, 0.2581, 0.2561,\n", + " 0.2266, 0.4460, 0.2829, 0.2552, 0.4303, 0.1324, 0.6613],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.4140, 0.3537, 0.2891, 0.2624, 0.2459, 0.2257, 0.2028, 0.1216,\n", + " 0.2433, 0.2126, 0.2095, 0.1994, 0.1839, 0.1797, 0.1738, 0.1805, 0.1771,\n", + " 0.1755, 0.1638, 0.1729, 0.1715, 0.1677, 0.1758, 0.1746])\n", + "finalReturns: tensor([0.0053, 0.0062])\n", + "----------------------------------------\n", + "iter 0 stage 23 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([6, 6, 9, 6, 6, 6, 6, 3, 6, 6, 9, 9, 6, 6, 6, 6, 9, 6, 6, 6, 6, 6, 0, 9,\n", + " 0])\n", + "loss= tensor(0.0300, grad_fn=) , base rewards= tensor([0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550,\n", + " 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550,\n", + " 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.3550, 0.1725]) return= 59413.20879318385\n", + "probs of actions: tensor([0.4593, 0.5525, 0.0732, 0.5638, 0.5460, 0.4904, 0.5642, 0.1712, 0.5676,\n", + " 0.5611, 0.0841, 0.0820, 0.5512, 0.5398, 0.5214, 0.5633, 0.0787, 0.5516,\n", + " 0.4780, 0.5224, 0.4695, 0.5310, 0.2116, 0.0809, 0.8957],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.4140, 0.3456, 0.3139, 0.2801, 0.2560, 0.2386, 0.2286, 0.2097,\n", + " 0.2047, 0.1964, 0.2005, 0.2080, 0.2034, 0.2000, 0.1975, 0.1911, 0.2009,\n", + " 0.1982, 0.1961, 0.1946, 0.1934, 0.1962, 0.1744, 0.1917])\n", + "finalReturns: tensor([0.0111, 0.0192])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([15, 9, 6, 6, 0, 6, 9, 6, 6, 9, 9, 9, 6, 6, 9, 6, 6, 9,\n", + " 12, 6, 9, 6, 9, 6, 0])\n", + "loss= tensor(0.0575, grad_fn=) , base rewards= tensor([0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794,\n", + " 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.5794,\n", + " 0.5794, 0.5794, 0.5794, 0.5794, 0.5794, 0.3707, 0.1791]) return= 61352.37296508392\n", + "probs of actions: tensor([0.0049, 0.2886, 0.5194, 0.5667, 0.0384, 0.5416, 0.2841, 0.5163, 0.5702,\n", + " 0.3191, 0.3114, 0.2961, 0.5570, 0.5329, 0.3011, 0.5474, 0.5238, 0.2829,\n", + " 0.0357, 0.5463, 0.2982, 0.5444, 0.3465, 0.6957, 0.9113],\n", + " grad_fn=)\n", + "rewards: tensor([0.4887, 0.4391, 0.3796, 0.3262, 0.2924, 0.2469, 0.2275, 0.2283, 0.2184,\n", + " 0.2066, 0.2082, 0.2093, 0.2147, 0.2084, 0.1992, 0.2071, 0.2027, 0.1950,\n", + " 0.1931, 0.2141, 0.2035, 0.2103, 0.2006, 0.2081, 0.2071])\n", + "finalReturns: tensor([0.0365, 0.0446, 0.0280])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 12, 3, 9, 9, 9, 6, 12, 9, 6, 9, 3, 6, 12, 9, 9, 9, 6,\n", + " 9, 6, 9, 12, 9, 9, 0])\n", + "loss= tensor(0.0352, grad_fn=) , base rewards= tensor([0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075,\n", + " 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.6075,\n", + " 0.6075, 0.6075, 0.6075, 0.6075, 0.6075, 0.3862, 0.1857]) return= 62546.458717917136\n", + "probs of actions: tensor([0.5353, 0.0431, 0.0359, 0.5870, 0.6315, 0.5678, 0.2807, 0.0454, 0.5922,\n", + " 0.2558, 0.6168, 0.0411, 0.2766, 0.0482, 0.5834, 0.6188, 0.5877, 0.2788,\n", + " 0.5710, 0.2691, 0.5920, 0.0468, 0.7153, 0.6523, 0.9644],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4130, 0.3777, 0.3100, 0.2840, 0.2653, 0.2561, 0.2279, 0.2361,\n", + " 0.2347, 0.2186, 0.2243, 0.2066, 0.1916, 0.2085, 0.2095, 0.2104, 0.2155,\n", + " 0.2045, 0.2110, 0.2012, 0.1977, 0.2132, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.0399, 0.0480, 0.0355])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([ 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 6, 9, 9,\n", + " 12, 9, 9, 9, 6, 9, 0])\n", + "loss= tensor(0.0937, grad_fn=) , base rewards= tensor([0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155,\n", + " 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.6155,\n", + " 0.6155, 0.6155, 0.6155, 0.6155, 0.6155, 0.3906, 0.1875]) return= 63514.70077728213\n", + "probs of actions: tensor([0.0296, 0.7851, 0.7652, 0.7515, 0.7909, 0.7315, 0.7606, 0.7464, 0.7608,\n", + " 0.7813, 0.7735, 0.7258, 0.7492, 0.7762, 0.0049, 0.1191, 0.7491, 0.7561,\n", + " 0.0529, 0.7435, 0.7497, 0.7477, 0.0676, 0.8504, 0.9806],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.3999, 0.3478, 0.3110, 0.2848, 0.2658, 0.2520, 0.2419, 0.2345,\n", + " 0.2290, 0.2249, 0.2218, 0.2196, 0.2179, 0.2022, 0.2346, 0.2185, 0.2171,\n", + " 0.2097, 0.2223, 0.2199, 0.2181, 0.2213, 0.2088, 0.2179])\n", + "finalReturns: tensor([0.0324, 0.0360, 0.0304])\n", + "----------------------------------------\n", + "iter 0 stage 22 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 12, 9, 6, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 3, 9, 9, 0])\n", + "loss= tensor(0.0097, grad_fn=) , base rewards= tensor([0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764,\n", + " 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.5764,\n", + " 0.5764, 0.5764, 0.5764, 0.5764, 0.5764, 0.3690, 0.1784]) return= 63600.55185293454\n", + "probs of actions: tensor([0.7547, 0.8389, 0.8221, 0.8118, 0.0509, 0.7931, 0.0775, 0.8037, 0.8180,\n", + " 0.8343, 0.8274, 0.7840, 0.8068, 0.8295, 0.8006, 0.8319, 0.8038, 0.8153,\n", + " 0.7895, 0.8013, 0.8043, 0.0150, 0.8904, 0.9033, 0.9875],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2854, 0.2788, 0.2660, 0.2413, 0.2340,\n", + " 0.2286, 0.2246, 0.2216, 0.2194, 0.2177, 0.2165, 0.2156, 0.2149, 0.2144,\n", + " 0.2140, 0.2137, 0.2135, 0.2205, 0.1993, 0.2026, 0.2132])\n", + "finalReturns: tensor([0.0388, 0.0469, 0.0348])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 22 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 12, 9, 9, 9, 9, 6, 12, 9, 9, 9, 0, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 0])\n", + "loss= tensor(0.0138, grad_fn=) , base rewards= tensor([0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015,\n", + " 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015,\n", + " 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.3829, 0.1843]) return= 63367.220552996965\n", + "probs of actions: tensor([0.7048, 0.7939, 0.7766, 0.7712, 0.0921, 0.7481, 0.7808, 0.7570, 0.7766,\n", + " 0.0626, 0.0909, 0.7358, 0.7653, 0.7887, 0.0541, 0.7934, 0.7553, 0.7736,\n", + " 0.7408, 0.7540, 0.7546, 0.7588, 0.8251, 0.8820, 0.9942],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2854, 0.2788, 0.2615, 0.2489, 0.2396,\n", + " 0.2373, 0.2142, 0.2257, 0.2225, 0.2200, 0.2263, 0.1960, 0.2001, 0.2033,\n", + " 0.2056, 0.2074, 0.2088, 0.2098, 0.2105, 0.2111, 0.2196])\n", + "finalReturns: tensor([0.0397, 0.0478, 0.0354])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 6, 9, 9, 12, 9, 12, 9, 9, 9, 9, 9, 9, 9, 6, 9, 6, 9,\n", + " 9, 12, 12, 9, 9, 9, 0])\n", + "loss= tensor(0.0525, grad_fn=) , base rewards= tensor([0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064,\n", + " 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064, 0.8064,\n", + " 0.8064, 0.8064, 0.8064, 0.8064, 0.5759, 0.3687, 0.1783]) return= 63900.06666813643\n", + "probs of actions: tensor([0.7450, 0.0332, 0.8032, 0.7765, 0.1419, 0.7829, 0.1524, 0.7768, 0.7725,\n", + " 0.7943, 0.7975, 0.7758, 0.7730, 0.7909, 0.0445, 0.7913, 0.0394, 0.7892,\n", + " 0.7642, 0.1584, 0.1688, 0.7797, 0.7790, 0.8710, 0.9861],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4238, 0.3523, 0.3142, 0.2808, 0.2754, 0.2527, 0.2547, 0.2439,\n", + " 0.2359, 0.2300, 0.2257, 0.2224, 0.2200, 0.2227, 0.2098, 0.2150, 0.2041,\n", + " 0.2063, 0.2016, 0.2099, 0.2225, 0.2200, 0.2182, 0.2250])\n", + "finalReturns: tensor([0.0792, 0.0873, 0.0745, 0.0466])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 12, 9, 12, 9, 12, 9, 9, 9, 9, 12, 9, 9, 9, 3, 9,\n", + " 9, 12, 9, 9, 12, 9, 0])\n", + "loss= tensor(0.1608, grad_fn=) , base rewards= tensor([0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875,\n", + " 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875, 0.7875,\n", + " 0.7875, 0.7875, 0.7875, 0.7875, 0.5642, 0.3623, 0.1756]) return= 64562.60586840481\n", + "probs of actions: tensor([0.5976, 0.6168, 0.6466, 0.3209, 0.6422, 0.2996, 0.6183, 0.3199, 0.6098,\n", + " 0.6397, 0.6462, 0.6327, 0.3156, 0.6326, 0.6199, 0.6341, 0.0044, 0.6398,\n", + " 0.6093, 0.3274, 0.5959, 0.5767, 0.3889, 0.7362, 0.9915],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3143, 0.2999, 0.2705, 0.2679, 0.2472, 0.2506,\n", + " 0.2409, 0.2337, 0.2284, 0.2181, 0.2287, 0.2247, 0.2217, 0.2267, 0.2038,\n", + " 0.2060, 0.2014, 0.2160, 0.2152, 0.2083, 0.2213, 0.2272])\n", + "finalReturns: tensor([0.0845, 0.0926, 0.0862, 0.0516])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 12, 12, 12, 9, 12, 6, 9, 9, 9, 9, 9, 12, 12, 12, 12, 12,\n", + " 9, 9, 12, 12, 12, 9, 0])\n", + "loss= tensor(0.1576, grad_fn=) , base rewards= tensor([0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257,\n", + " 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257, 0.8257,\n", + " 0.8257, 0.8257, 0.8257, 0.8257, 0.5877, 0.3752, 0.1811]) return= 65901.80171251376\n", + "probs of actions: tensor([0.3774, 0.3514, 0.5611, 0.5640, 0.5644, 0.3992, 0.5829, 0.0208, 0.3723,\n", + " 0.4031, 0.4069, 0.4050, 0.3920, 0.5676, 0.5599, 0.5592, 0.5817, 0.5480,\n", + " 0.3768, 0.3752, 0.5988, 0.6690, 0.6565, 0.4812, 0.9943],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3550, 0.3230, 0.2999, 0.2895, 0.2629, 0.2668, 0.2419,\n", + " 0.2344, 0.2289, 0.2248, 0.2218, 0.2132, 0.2187, 0.2229, 0.2260, 0.2284,\n", + " 0.2365, 0.2305, 0.2197, 0.2236, 0.2266, 0.2351, 0.2375])\n", + "finalReturns: tensor([0.0972, 0.1116, 0.0974, 0.0565])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 9, 9, 9, 12, 12, 12, 6, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0851, grad_fn=) , base rewards= tensor([0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567,\n", + " 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567, 0.8567,\n", + " 0.8567, 0.8567, 0.8567, 0.8567, 0.6066, 0.3857, 0.1854]) return= 67404.68062374518\n", + "probs of actions: tensor([0.7116, 0.2010, 0.2402, 0.2483, 0.7271, 0.7151, 0.7406, 0.0122, 0.7393,\n", + " 0.7099, 0.7133, 0.7056, 0.7096, 0.7272, 0.7157, 0.7208, 0.7393, 0.7119,\n", + " 0.7350, 0.7298, 0.7515, 0.8319, 0.8060, 0.6590, 0.9953],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4292, 0.3682, 0.3255, 0.2889, 0.2751, 0.2649, 0.2682, 0.2366,\n", + " 0.2364, 0.2362, 0.2360, 0.2359, 0.2358, 0.2358, 0.2357, 0.2357, 0.2357,\n", + " 0.2357, 0.2356, 0.2356, 0.2356, 0.2356, 0.2356, 0.2500])\n", + "finalReturns: tensor([0.1002, 0.1146, 0.0999, 0.0646])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 9, 12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 9, 12, 12, 12, 0])\n", + "loss= tensor(0.0369, grad_fn=) , base rewards= tensor([0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380,\n", + " 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380, 0.8380,\n", + " 0.8380, 0.8380, 0.8380, 0.8380, 0.5952, 0.3794, 0.1828]) return= 68049.04485884288\n", + "probs of actions: tensor([0.8436, 0.8976, 0.1146, 0.8559, 0.8613, 0.8556, 0.8694, 0.8624, 0.1145,\n", + " 0.8490, 0.8528, 0.8457, 0.8438, 0.8603, 0.8480, 0.8552, 0.8680, 0.8512,\n", + " 0.8645, 0.8594, 0.1076, 0.9306, 0.9117, 0.8245, 0.9968],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3775, 0.3257, 0.3019, 0.2846, 0.2719, 0.2626, 0.2620,\n", + " 0.2430, 0.2411, 0.2397, 0.2387, 0.2379, 0.2373, 0.2369, 0.2366, 0.2363,\n", + " 0.2361, 0.2360, 0.2422, 0.2284, 0.2302, 0.2315, 0.2469])\n", + "finalReturns: tensor([0.0990, 0.1134, 0.0991, 0.0641])\n", + "----------------------------------------\n", + "iter 0 stage 21 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 9, 12, 9, 12, 12, 12, 12, 9,\n", + " 12, 12, 9, 12, 12, 12, 0])\n", + "loss= tensor(0.0208, grad_fn=) , base rewards= tensor([0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275,\n", + " 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275, 0.8275,\n", + " 0.8275, 0.8275, 0.8275, 0.8275, 0.5888, 0.3759, 0.1813]) return= 67652.69436488167\n", + "probs of actions: tensor([0.9003, 0.9414, 0.9204, 0.9110, 0.9162, 0.0734, 0.9213, 0.9156, 0.9173,\n", + " 0.9058, 0.0760, 0.9050, 0.0810, 0.9148, 0.9034, 0.9105, 0.9194, 0.0766,\n", + " 0.9171, 0.9125, 0.0652, 0.9634, 0.9505, 0.8924, 0.9977],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2955, 0.2673, 0.2592, 0.2532,\n", + " 0.2487, 0.2517, 0.2354, 0.2418, 0.2280, 0.2299, 0.2313, 0.2324, 0.2395,\n", + " 0.2264, 0.2287, 0.2367, 0.2243, 0.2271, 0.2292, 0.2452])\n", + "finalReturns: tensor([0.0983, 0.1127, 0.0986, 0.0639])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0203, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9466, 0.9715, 0.9604, 0.9532, 0.9564, 0.9554, 0.9586, 0.9567, 0.9564,\n", + " 0.9497, 0.9536, 0.9498, 0.9472, 0.9553, 0.9484, 0.9530, 0.9583, 0.9523,\n", + " 0.9568, 0.9543, 0.9625, 0.9825, 0.9769, 0.9455, 0.9969],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 20 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0137, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9620, 0.9807, 0.9729, 0.9670, 0.9694, 0.9691, 0.9710, 0.9699, 0.9693,\n", + " 0.9641, 0.9674, 0.9646, 0.9624, 0.9685, 0.9634, 0.9670, 0.9707, 0.9663,\n", + " 0.9698, 0.9678, 0.9753, 0.9893, 0.9836, 0.9615, 0.9975],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0081, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9754, 0.9882, 0.9832, 0.9790, 0.9807, 0.9806, 0.9816, 0.9810, 0.9803,\n", + " 0.9769, 0.9792, 0.9774, 0.9758, 0.9799, 0.9765, 0.9789, 0.9813, 0.9785,\n", + " 0.9809, 0.9793, 0.9857, 0.9934, 0.9898, 0.9773, 0.9982],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0072, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9778, 0.9895, 0.9850, 0.9812, 0.9826, 0.9827, 0.9834, 0.9828, 0.9822,\n", + " 0.9793, 0.9814, 0.9798, 0.9781, 0.9820, 0.9790, 0.9810, 0.9832, 0.9807,\n", + " 0.9829, 0.9813, 0.9868, 0.9942, 0.9910, 0.9807, 0.9991],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0048, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9843, 0.9929, 0.9897, 0.9868, 0.9879, 0.9880, 0.9884, 0.9880, 0.9875,\n", + " 0.9853, 0.9870, 0.9858, 0.9845, 0.9873, 0.9851, 0.9867, 0.9882, 0.9864,\n", + " 0.9880, 0.9869, 0.9912, 0.9964, 0.9940, 0.9866, 0.9994],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9895, 0.9955, 0.9934, 0.9913, 0.9921, 0.9922, 0.9924, 0.9922, 0.9918,\n", + " 0.9902, 0.9915, 0.9906, 0.9896, 0.9916, 0.9901, 0.9913, 0.9923, 0.9911,\n", + " 0.9922, 0.9914, 0.9946, 0.9980, 0.9964, 0.9908, 0.9998],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 209999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0035, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9880, 0.9947, 0.9924, 0.9900, 0.9908, 0.9909, 0.9912, 0.9910, 0.9905,\n", + " 0.9885, 0.9903, 0.9891, 0.9878, 0.9903, 0.9884, 0.9900, 0.9912, 0.9897,\n", + " 0.9910, 0.9901, 0.9938, 0.9978, 0.9962, 0.9878, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 20 ep 239999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0035, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9881, 0.9948, 0.9924, 0.9900, 0.9908, 0.9911, 0.9913, 0.9911, 0.9906,\n", + " 0.9887, 0.9903, 0.9892, 0.9880, 0.9903, 0.9886, 0.9900, 0.9913, 0.9897,\n", + " 0.9911, 0.9902, 0.9942, 0.9978, 0.9961, 0.9881, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0048, grad_fn=) , base rewards= tensor([1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986,\n", + " 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986, 1.1986,\n", + " 1.1986, 1.1986, 0.9485, 0.7275, 0.5271, 0.3416, 0.1669]) return= 68460.61730250808\n", + "probs of actions: tensor([0.9910, 0.9962, 0.9944, 0.9924, 0.9931, 0.9932, 0.9934, 0.9933, 0.9929,\n", + " 0.9913, 0.0065, 0.9918, 0.9906, 0.9926, 0.9912, 0.9925, 0.9934, 0.9922,\n", + " 0.9933, 0.9931, 0.9957, 0.9986, 0.9976, 0.9906, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2542, 0.2372, 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359,\n", + " 0.2358, 0.2358, 0.2357, 0.2357, 0.2357, 0.2357, 0.2500])\n", + "finalReturns: tensor([0.2299, 0.2443, 0.2296, 0.1942, 0.1441, 0.0832])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 19 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999,\n", + " 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999, 1.1999,\n", + " 1.1999, 1.1999, 0.9493, 0.7280, 0.5275, 0.3418, 0.1670]) return= 68453.26034712071\n", + "probs of actions: tensor([0.9926, 0.9969, 0.9955, 0.9938, 0.9944, 0.9945, 0.9947, 0.0049, 0.9943,\n", + " 0.9929, 0.9941, 0.9932, 0.9924, 0.9940, 0.9928, 0.9939, 0.9947, 0.9937,\n", + " 0.9946, 0.9948, 0.9966, 0.9989, 0.9982, 0.9924, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2714, 0.2498,\n", + " 0.2462, 0.2436, 0.2416, 0.2401, 0.2389, 0.2381, 0.2375, 0.2370, 0.2367,\n", + " 0.2364, 0.2362, 0.2360, 0.2359, 0.2358, 0.2358, 0.2501])\n", + "finalReturns: tensor([0.2300, 0.2444, 0.2297, 0.1943, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0027, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9943, 0.9977, 0.9966, 0.9953, 0.9958, 0.9958, 0.9960, 0.9959, 0.9956,\n", + " 0.9946, 0.9956, 0.9948, 0.9942, 0.9954, 0.9945, 0.9954, 0.9960, 0.9952,\n", + " 0.9959, 0.9963, 0.9976, 0.9993, 0.9987, 0.9942, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0022, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9951, 0.9981, 0.9971, 0.9959, 0.9964, 0.9964, 0.9965, 0.9965, 0.9963,\n", + " 0.9953, 0.9962, 0.9956, 0.9949, 0.9961, 0.9952, 0.9961, 0.9966, 0.9959,\n", + " 0.9965, 0.9970, 0.9980, 0.9995, 0.9990, 0.9948, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0020, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9956, 0.9982, 0.9974, 0.9963, 0.9966, 0.9967, 0.9968, 0.9969, 0.9966,\n", + " 0.9957, 0.9966, 0.9959, 0.9954, 0.9963, 0.9956, 0.9964, 0.9969, 0.9963,\n", + " 0.9968, 0.9974, 0.9982, 0.9997, 0.9993, 0.9946, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9953, 0.9981, 0.9972, 0.9960, 0.9964, 0.9965, 0.9966, 0.9967, 0.9964,\n", + " 0.9954, 0.9964, 0.9956, 0.9951, 0.9961, 0.9953, 0.9962, 0.9967, 0.9960,\n", + " 0.9966, 0.9973, 0.9982, 0.9997, 0.9992, 0.9942, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 209999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0016, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9963, 0.9985, 0.9978, 0.9969, 0.9972, 0.9973, 0.9974, 0.9974, 0.9972,\n", + " 0.9964, 0.9972, 0.9966, 0.9961, 0.9969, 0.9963, 0.9970, 0.9974, 0.9969,\n", + " 0.9973, 0.9979, 0.9987, 1.0000, 0.9994, 0.9957, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 239999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0015, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9963, 0.9985, 0.9978, 0.9969, 0.9972, 0.9973, 0.9973, 0.9974, 0.9971,\n", + " 0.9964, 0.9972, 0.9966, 0.9960, 0.9969, 0.9962, 0.9970, 0.9974, 0.9968,\n", + " 0.9973, 0.9978, 0.9986, 1.0000, 0.9995, 0.9958, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 19 ep 269999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0010, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9975, 0.9990, 0.9986, 0.9979, 0.9981, 0.9982, 0.9982, 0.9983, 0.9981,\n", + " 0.9975, 0.9981, 0.9977, 0.9973, 0.9979, 0.9975, 0.9980, 0.9983, 0.9979,\n", + " 0.9982, 0.9987, 0.9993, 1.0000, 0.9997, 0.9971, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 19 ep 280092 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0007, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9981, 0.9993, 0.9989, 0.9984, 0.9986, 0.9987, 0.9987, 0.9987, 0.9985,\n", + " 0.9981, 0.9986, 0.9982, 0.9979, 0.9984, 0.9981, 0.9985, 0.9987, 0.9984,\n", + " 0.9987, 0.9990, 0.9995, 1.0000, 0.9998, 0.9979, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 0 stage 18 ep 607 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9982, 0.9994, 0.9990, 0.9985, 0.9987, 0.9988, 0.9988, 0.9988, 0.9986,\n", + " 0.9983, 0.9987, 0.9984, 0.9981, 0.9986, 0.9982, 0.9986, 0.9988, 0.9985,\n", + " 0.9990, 0.9991, 0.9995, 1.0000, 0.9998, 0.9981, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 0 stage 17 ep 4304 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0015, grad_fn=) , base rewards= tensor([1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969,\n", + " 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969, 1.4969,\n", + " 1.2527, 1.0359, 0.8386, 0.6553, 0.4822, 0.3165, 0.1562]) return= 68487.85710629346\n", + "probs of actions: tensor([0.9984, 0.9994, 0.9991, 0.9987, 0.9989, 0.9989, 0.9989, 0.9990, 0.9988,\n", + " 0.9985, 0.9989, 0.9986, 0.9983, 0.9988, 0.9984, 0.9988, 0.0010, 0.9990,\n", + " 0.9992, 0.9992, 0.9996, 1.0000, 0.9999, 0.9983, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2441, 0.2298,\n", + " 0.2312, 0.2323, 0.2331, 0.2337, 0.2342, 0.2346, 0.2492])\n", + "finalReturns: tensor([0.3812, 0.3956, 0.3812, 0.3462, 0.2964, 0.2358, 0.1673, 0.0930])\n", + "----------------------------------------\n", + "iter 0 stage 16 ep 30 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770,\n", + " 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.4248,\n", + " 1.2024, 1.0011, 0.8148, 0.6396, 0.4723, 0.3109, 0.1538]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9984, 0.9995, 0.9991, 0.9987, 0.9989, 0.9989, 0.9989, 0.9990, 0.9988,\n", + " 0.9985, 0.9989, 0.9986, 0.9983, 0.9988, 0.9984, 0.9988, 0.9990, 0.9990,\n", + " 0.9992, 0.9992, 0.9996, 1.0000, 0.9999, 0.9983, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.4658, 0.4802, 0.4654, 0.4299, 0.3796, 0.3186, 0.2498, 0.1752, 0.0964])\n", + "----------------------------------------\n", + "iter 0 stage 15 ep 10043 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0026, grad_fn=) , base rewards= tensor([1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309,\n", + " 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.5780, 1.3551,\n", + " 1.1534, 0.9669, 0.7914, 0.6240, 0.4625, 0.3054, 0.1515]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9986, 0.9995, 0.9992, 0.9989, 0.9990, 0.9990, 0.9990, 0.9991, 0.9989,\n", + " 0.9986, 0.9990, 0.9987, 0.9985, 0.9989, 0.9986, 0.9990, 0.9992, 0.9991,\n", + " 0.9993, 0.9993, 0.9997, 1.0000, 0.9999, 0.9984, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.5504, 0.5648, 0.5499, 0.5144, 0.4641, 0.4030, 0.3342, 0.2596, 0.1807,\n", + " 0.0987])\n", + "----------------------------------------\n", + "iter 0 stage 14 ep 968 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0032, grad_fn=) , base rewards= tensor([1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839,\n", + " 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.7301, 1.5065, 1.3043,\n", + " 1.1175, 0.9417, 0.7741, 0.6125, 0.4553, 0.3013, 0.1497]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9987, 0.9995, 0.9993, 0.9989, 0.9991, 0.9991, 0.9991, 0.9991, 0.9990,\n", + " 0.9987, 0.9991, 0.9988, 0.9986, 0.9990, 0.9990, 0.9991, 0.9993, 0.9992,\n", + " 0.9994, 0.9994, 0.9997, 1.0000, 0.9999, 0.9986, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.6368, 0.6512, 0.6363, 0.6007, 0.5503, 0.4892, 0.4203, 0.3457, 0.2668,\n", + " 0.1848, 0.1005])\n", + "----------------------------------------\n", + "iter 0 stage 13 ep 36 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(4.9667, grad_fn=) , base rewards= tensor([2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368,\n", + " 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 1.8817, 1.6572, 1.4543, 1.2670,\n", + " 1.0910, 0.9231, 0.7613, 0.6040, 0.4499, 0.2982, 0.1484]) return= 68474.29269380601\n", + "probs of actions: tensor([9.9870e-01, 9.9955e-01, 9.9930e-01, 9.9896e-01, 9.9907e-01, 9.9912e-01,\n", + " 9.9911e-01, 9.9914e-01, 9.9902e-01, 9.9874e-01, 9.9907e-01, 9.9884e-01,\n", + " 9.9861e-01, 9.9900e-01, 9.8588e-04, 9.9909e-01, 9.9929e-01, 9.9916e-01,\n", + " 9.9939e-01, 9.9939e-01, 9.9970e-01, 1.0000e+00, 9.9995e-01, 9.9856e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2457, 0.2310, 0.2321, 0.2330,\n", + " 0.2337, 0.2341, 0.2345, 0.2348, 0.2350, 0.2351, 0.2497])\n", + "finalReturns: tensor([0.7026, 0.7170, 0.6958, 0.6677, 0.6228, 0.5659, 0.5001, 0.4277, 0.3506,\n", + " 0.2699, 0.1865, 0.1012])\n", + "----------------------------------------\n", + "iter 0 stage 12 ep 7589 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0042, grad_fn=) , base rewards= tensor([2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903,\n", + " 2.2903, 2.2903, 2.2903, 2.2903, 2.0334, 1.8077, 1.6040, 1.4161, 1.2396,\n", + " 1.0714, 0.9093, 0.7518, 0.5976, 0.4458, 0.2960, 0.1475]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9990, 0.9996, 0.9994, 0.9992, 0.9993, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.8136, 0.8280, 0.8130, 0.7773, 0.7267, 0.6655, 0.5964, 0.5217, 0.4427,\n", + " 0.3606, 0.2762, 0.1901, 0.1027])\n", + "----------------------------------------\n", + "iter 0 stage 11 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(6.1888, grad_fn=) , base rewards= tensor([2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451,\n", + " 2.4451, 2.4451, 2.4451, 2.1859, 1.9586, 1.7537, 1.5650, 1.3879, 1.2192,\n", + " 1.0569, 0.8991, 0.7447, 0.5928, 0.4428, 0.2943, 0.1467]) return= 68466.13679373146\n", + "probs of actions: tensor([9.9895e-01, 9.9965e-01, 9.9944e-01, 9.9917e-01, 9.9926e-01, 9.9930e-01,\n", + " 9.9929e-01, 9.9931e-01, 9.9921e-01, 9.9899e-01, 9.9926e-01, 9.9907e-01,\n", + " 9.9921e-04, 9.9925e-01, 9.9920e-01, 9.9927e-01, 9.9947e-01, 9.9932e-01,\n", + " 9.9959e-01, 9.9959e-01, 9.9979e-01, 1.0000e+00, 9.9997e-01, 9.9888e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2488, 0.2332, 0.2338, 0.2343, 0.2346, 0.2348,\n", + " 0.2350, 0.2352, 0.2353, 0.2354, 0.2354, 0.2355, 0.2499])\n", + "finalReturns: tensor([0.8808, 0.8952, 0.8738, 0.8454, 0.8004, 0.7432, 0.6772, 0.6048, 0.5275,\n", + " 0.4468, 0.3633, 0.2779, 0.1911, 0.1032])\n", + "----------------------------------------\n", + "iter 0 stage 10 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021,\n", + " 2.6021, 2.6021, 2.3399, 2.1104, 1.9040, 1.7141, 1.5362, 1.3670, 1.2041,\n", + " 1.0460, 0.8914, 0.7394, 0.5893, 0.4406, 0.2930, 0.1462]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9990, 0.9996, 0.9994, 0.9992, 0.9993, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.9944, 1.0088, 0.9935, 0.9575, 0.9066, 0.8451, 0.7758, 0.7009, 0.6218,\n", + " 0.5396, 0.4551, 0.3689, 0.2815, 0.1931, 0.1040])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 0 stage 9 ep 22 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0078, grad_fn=) , base rewards= tensor([2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625, 2.7625,\n", + " 2.7625, 2.4961, 2.2637, 2.0552, 1.8638, 1.6848, 1.5149, 1.3514, 1.1929,\n", + " 1.0380, 0.8857, 0.7354, 0.5866, 0.4389, 0.2920, 0.1458]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.0860, 1.1004, 1.0850, 1.0487, 0.9976, 0.9359, 0.8664, 0.7913, 0.7121,\n", + " 0.6298, 0.5453, 0.4591, 0.3716, 0.2832, 0.1941, 0.1044])\n", + "----------------------------------------\n", + "iter 0 stage 8 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0091, grad_fn=) , base rewards= tensor([2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276,\n", + " 2.6556, 2.4193, 2.2080, 2.0147, 1.8342, 1.6632, 1.4990, 1.3399, 1.1845,\n", + " 1.0319, 0.8814, 0.7324, 0.5846, 0.4376, 0.2913, 0.1455]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.1785, 1.1929, 1.1773, 1.1406, 1.0892, 1.0272, 0.9575, 0.8823, 0.8029,\n", + " 0.7205, 0.6359, 0.5496, 0.4620, 0.3736, 0.2844, 0.1948, 0.1047])\n", + "----------------------------------------\n", + "iter 0 stage 7 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0103, grad_fn=) , base rewards= tensor([3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 2.8197,\n", + " 2.5781, 2.3632, 2.1671, 1.9848, 1.8123, 1.6471, 1.4872, 1.3313, 1.1783,\n", + " 1.0274, 0.8782, 0.7302, 0.5831, 0.4367, 0.2908, 0.1453]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.2720, 1.2864, 1.2704, 1.2334, 1.1815, 1.1191, 1.0491, 0.9736, 0.8941,\n", + " 0.8115, 0.7268, 0.6404, 0.5528, 0.4643, 0.3751, 0.2854, 0.1953, 0.1050])\n", + "----------------------------------------\n", + "iter 0 stage 6 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0116, grad_fn=) , base rewards= tensor([3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 2.9902, 2.7415,\n", + " 2.5215, 2.3219, 2.1370, 1.9626, 1.7960, 1.6351, 1.4784, 1.3248, 1.1736,\n", + " 1.0241, 0.8758, 0.7286, 0.5820, 0.4360, 0.2904, 0.1451]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.3666, 1.3810, 1.3646, 1.3270, 1.2746, 1.2117, 1.1413, 1.0654, 0.9856,\n", + " 0.9029, 0.8179, 0.7314, 0.6437, 0.5552, 0.4659, 0.3762, 0.2861, 0.1957,\n", + " 0.1051])\n", + "----------------------------------------\n", + "iter 0 stage 5 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0129, grad_fn=) , base rewards= tensor([3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.1695, 2.9111, 2.6844,\n", + " 2.4799, 2.2915, 2.1146, 1.9461, 1.7839, 1.6262, 1.4718, 1.3200, 1.1701,\n", + " 1.0215, 0.8740, 0.7273, 0.5812, 0.4355, 0.2901, 0.1450]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.4627, 1.4771, 1.4601, 1.4217, 1.3686, 1.3050, 1.2341, 1.1578, 1.0776,\n", + " 0.9945, 0.9094, 0.8228, 0.7349, 0.6463, 0.5570, 0.4672, 0.3770, 0.2866,\n", + " 0.1960, 0.1053])\n", + "----------------------------------------\n", + "iter 0 stage 4 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0144, grad_fn=) , base rewards= tensor([3.6835, 3.6835, 3.6835, 3.6835, 3.6835, 3.3608, 3.0893, 2.8534, 2.6424,\n", + " 2.4492, 2.2689, 2.0980, 1.9339, 1.7748, 1.6195, 1.4669, 1.3164, 1.1675,\n", + " 1.0197, 0.8727, 0.7264, 0.5805, 0.4351, 0.2899, 0.1449]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.5606, 1.5750, 1.5572, 1.5179, 1.4637, 1.3993, 1.3276, 1.2507, 1.1700,\n", + " 1.0866, 1.0012, 0.9143, 0.8264, 0.7376, 0.6482, 0.5583, 0.4681, 0.3777,\n", + " 0.2870, 0.1962, 0.1054])\n", + "----------------------------------------\n", + "iter 0 stage 3 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0161, grad_fn=) , base rewards= tensor([3.9177, 3.9177, 3.9177, 3.9177, 3.5687, 3.2793, 3.0307, 2.8109, 2.6114,\n", + " 2.4265, 2.2522, 2.0856, 1.9247, 1.7680, 1.6145, 1.4632, 1.3137, 1.1655,\n", + " 1.0182, 0.8717, 0.7257, 0.5801, 0.4348, 0.2897, 0.1448]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.6609, 1.6753, 1.6565, 1.6158, 1.5603, 1.4947, 1.4220, 1.3444, 1.2631,\n", + " 1.1792, 1.0934, 1.0062, 0.9180, 0.8291, 0.7395, 0.6496, 0.5593, 0.4688,\n", + " 0.3781, 0.2873, 0.1964, 0.1054])\n", + "----------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter 0 stage 2 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0174, grad_fn=) , base rewards= tensor([4.1854, 4.1854, 4.1854, 3.7998, 3.4854, 3.2196, 2.9877, 2.7795, 2.5884,\n", + " 2.4096, 2.2397, 2.0764, 1.9179, 1.7630, 1.6108, 1.4605, 1.3117, 1.1640,\n", + " 1.0172, 0.8709, 0.7252, 0.5797, 0.4345, 0.2896, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.7644, 1.7788, 1.7586, 1.7161, 1.6589, 1.5917, 1.5177, 1.4390, 1.3568,\n", + " 1.2723, 1.1860, 1.0985, 1.0100, 0.9208, 0.8311, 0.7410, 0.6506, 0.5601,\n", + " 0.4693, 0.3785, 0.2875, 0.1965, 0.1055])\n", + "----------------------------------------\n", + "iter 0 stage 1 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0184, grad_fn=) , base rewards= tensor([4.5005, 4.5005, 4.0633, 3.7141, 3.4244, 3.1758, 2.9558, 2.7562, 2.5713,\n", + " 2.3970, 2.2304, 2.0695, 1.9128, 1.7592, 1.6080, 1.4584, 1.3102, 1.1629,\n", + " 1.0164, 0.8704, 0.7248, 0.5795, 0.4344, 0.2895, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9996, 0.9994, 0.9992, 0.9992, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9990, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.8720, 1.8864, 1.8645, 1.8196, 1.7600, 1.6907, 1.6150, 1.5348, 1.4516,\n", + " 1.3662, 1.2792, 1.1911, 1.1022, 1.0128, 0.9228, 0.8326, 0.7421, 0.6514,\n", + " 0.5606, 0.4697, 0.3787, 0.2877, 0.1966, 0.1055])\n", + "----------------------------------------\n", + "iter 0 stage 0 ep 88 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0200, grad_fn=) , base rewards= tensor([4.8841, 4.3729, 3.9744, 3.6513, 3.3795, 3.1433, 2.9322, 2.7389, 2.5586,\n", + " 2.3875, 2.2234, 2.0643, 1.9089, 1.7564, 1.6059, 1.4569, 1.3091, 1.1621,\n", + " 1.0158, 0.8699, 0.7245, 0.5793, 0.4343, 0.2894, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9990, 0.9997, 0.9995, 0.9992, 0.9993, 0.9993, 0.9993, 0.9993, 0.9992,\n", + " 0.9991, 0.9993, 0.9991, 0.9990, 0.9992, 0.9992, 0.9993, 0.9995, 0.9993,\n", + " 0.9996, 0.9996, 0.9998, 1.0000, 1.0000, 0.9989, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.9853, 1.9997, 1.9753, 1.9272, 1.8645, 1.7924, 1.7143, 1.6323, 1.5475,\n", + " 1.4610, 1.3731, 1.2844, 1.1950, 1.1051, 1.0148, 0.9244, 0.8337, 0.7429,\n", + " 0.6520, 0.5610, 0.4700, 0.3789, 0.2878, 0.1967, 0.1056])\n", + "policy saved!\n", + "1,3,[5e-06,1][1, 10000, 1, 1],1683165834 saved\n", + "policy reset\n", + "----------------------------------------\n", + "iter 1 stage 24 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([42, 3, 3, 45, 18, 0, 3, 0, 3, 24, 3, 9, 3, 3, 0, 6, 3, 12,\n", + " 3, 6, 3, 45, 12, 3, 6])\n", + "loss= tensor(-0.0060, grad_fn=) , base rewards= tensor([0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448,\n", + " 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448,\n", + " 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448, 0.2448]) return= 62536.791981005576\n", + "probs of actions: tensor([0.0082, 0.2535, 0.2494, 0.0080, 0.0216, 0.2569, 0.2423, 0.2699, 0.2563,\n", + " 0.0137, 0.2403, 0.1029, 0.2541, 0.2374, 0.2605, 0.1688, 0.2393, 0.0449,\n", + " 0.2451, 0.1836, 0.2257, 0.0110, 0.0487, 0.2466, 0.1903],\n", + " grad_fn=)\n", + "rewards: tensor([ 0.3348, 0.5412, 0.4277, 0.1498, 0.3935, 0.3962, 0.3207, 0.2786,\n", + " 0.2401, 0.1639, 0.2572, 0.2257, 0.2296, 0.2131, 0.2020, 0.1831,\n", + " 0.1875, 0.1688, 0.1980, 0.1874, 0.1907, -0.0169, 0.2672, 0.2726,\n", + " 0.2412])\n", + "finalReturns: tensor([-0.0036])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 3, 0, 0, 24, 3, 0, 6, 0, 3, 9, 0, 3, 3, 3, 3, 3, 3, 6,\n", + " 3, 3, 3, 0, 3, 6, 3])\n", + "loss= tensor(0.0199, grad_fn=) , base rewards= tensor([0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255,\n", + " 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255,\n", + " 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.3255, 0.1601]) return= 54781.59028774685\n", + "probs of actions: tensor([0.4734, 0.2537, 0.2662, 0.0015, 0.4600, 0.2560, 0.1655, 0.2745, 0.4745,\n", + " 0.0526, 0.2590, 0.4529, 0.4598, 0.4480, 0.4363, 0.4599, 0.4514, 0.1761,\n", + " 0.4566, 0.4411, 0.4323, 0.2937, 0.4565, 0.2538, 0.4391],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.4080, 0.3295, 0.2186, 0.3007, 0.2646, 0.2275, 0.2214, 0.1997,\n", + " 0.1841, 0.1992, 0.1838, 0.1796, 0.1764, 0.1741, 0.1724, 0.1711, 0.1674,\n", + " 0.1756, 0.1735, 0.1719, 0.1716, 0.1637, 0.1619, 0.1714])\n", + "finalReturns: tensor([0.0077, 0.0113])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([ 0, 6, 6, 3, 3, 6, 6, 6, 6, 9, 3, 0, 12, 3, 6, 3, 0, 6,\n", + " 6, 0, 3, 9, 0, 6, 0])\n", + "loss= tensor(0.0099, grad_fn=) , base rewards= tensor([0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391,\n", + " 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391,\n", + " 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.3391, 0.1658]) return= 56244.87614304111\n", + "probs of actions: tensor([0.1596, 0.4525, 0.4438, 0.3103, 0.3243, 0.4194, 0.3663, 0.4225, 0.4123,\n", + " 0.0672, 0.3033, 0.1854, 0.0129, 0.2958, 0.4512, 0.3226, 0.1837, 0.3981,\n", + " 0.3993, 0.1956, 0.2979, 0.0727, 0.1676, 0.7251, 0.5688],\n", + " grad_fn=)\n", + "rewards: tensor([0.5112, 0.3949, 0.3368, 0.2989, 0.2625, 0.2339, 0.2225, 0.2142, 0.2080,\n", + " 0.1989, 0.2095, 0.1994, 0.1704, 0.1993, 0.1883, 0.1914, 0.1861, 0.1716,\n", + " 0.1761, 0.1831, 0.1721, 0.1637, 0.1835, 0.1697, 0.1783])\n", + "finalReturns: tensor([0.0088, 0.0124])\n", + "----------------------------------------\n", + "iter 1 stage 23 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([3, 6, 6, 6, 6, 0, 0, 6, 6, 3, 3, 0, 3, 3, 3, 9, 6, 0, 6, 6, 6, 6, 6, 6,\n", + " 0])\n", + "loss= tensor(0.0037, grad_fn=) , base rewards= tensor([0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663,\n", + " 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663,\n", + " 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.3663, 0.1773]) return= 55808.994116578215\n", + "probs of actions: tensor([0.1982, 0.5378, 0.5276, 0.4819, 0.4884, 0.1662, 0.2449, 0.5050, 0.4959,\n", + " 0.2201, 0.1924, 0.2021, 0.2375, 0.1857, 0.1872, 0.1046, 0.4413, 0.2141,\n", + " 0.4682, 0.4636, 0.5007, 0.4585, 0.4863, 0.8265, 0.8623],\n", + " grad_fn=)\n", + "rewards: tensor([0.5103, 0.4044, 0.3434, 0.3009, 0.2708, 0.2529, 0.2229, 0.1981, 0.1961,\n", + " 0.1972, 0.1895, 0.1847, 0.1733, 0.1717, 0.1706, 0.1625, 0.1790, 0.1853,\n", + " 0.1710, 0.1757, 0.1792, 0.1819, 0.1839, 0.1854, 0.1901])\n", + "finalReturns: tensor([0.0093, 0.0129])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 22 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 6, 9, 6, 6, 6, 9, 0, 9, 6, 9, 9, 9, 3, 6, 6, 9, 0, 12,\n", + " 6, 6, 6, 9, 6, 6, 0])\n", + "loss= tensor(0.0535, grad_fn=) , base rewards= tensor([0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674,\n", + " 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.5674,\n", + " 0.5674, 0.5674, 0.5674, 0.5674, 0.5674, 0.3640, 0.1763]) return= 59812.40403986201\n", + "probs of actions: tensor([0.4401, 0.4532, 0.4122, 0.4032, 0.3970, 0.4278, 0.0902, 0.4619, 0.3996,\n", + " 0.4055, 0.4287, 0.4020, 0.0991, 0.4210, 0.4286, 0.4193, 0.0713, 0.0278,\n", + " 0.3751, 0.3976, 0.3955, 0.4142, 0.3706, 0.4904, 0.9183],\n", + " grad_fn=)\n", + "rewards: tensor([0.5076, 0.4095, 0.3590, 0.3118, 0.2786, 0.2504, 0.2488, 0.2120, 0.2167,\n", + " 0.2053, 0.2072, 0.2086, 0.2168, 0.2011, 0.1983, 0.1917, 0.2050, 0.1745,\n", + " 0.1997, 0.1973, 0.1954, 0.1896, 0.1998, 0.1973, 0.1991])\n", + "finalReturns: tensor([0.0288, 0.0324, 0.0227])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([9, 9, 9, 9, 9, 6, 9, 0, 9, 6, 6, 0, 9, 6, 9, 9, 9, 9, 0, 9, 9, 6, 9, 9,\n", + " 9])\n", + "loss= tensor(0.1111, grad_fn=) , base rewards= tensor([0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662,\n", + " 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.5662,\n", + " 0.5662, 0.5662, 0.5662, 0.5662, 0.5662, 0.3634, 0.1761]) return= 60649.09398743877\n", + "probs of actions: tensor([0.6854, 0.7487, 0.7432, 0.7094, 0.7146, 0.1807, 0.6713, 0.0347, 0.7256,\n", + " 0.1790, 0.1936, 0.0563, 0.6536, 0.1959, 0.6958, 0.6811, 0.6686, 0.6919,\n", + " 0.0458, 0.6781, 0.6969, 0.1834, 0.8403, 0.8036, 0.0253],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2753, 0.2480, 0.2471, 0.2107,\n", + " 0.2158, 0.2092, 0.2079, 0.1828, 0.1946, 0.1890, 0.1948, 0.1992, 0.2026,\n", + " 0.2132, 0.1867, 0.1930, 0.2024, 0.1948, 0.1992, 0.2026])\n", + "finalReturns: tensor([0.0303, 0.0384, 0.0265])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([9, 9, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 9, 6, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0092, grad_fn=) , base rewards= tensor([0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015,\n", + " 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.6015,\n", + " 0.6015, 0.6015, 0.6015, 0.6015, 0.6015, 0.3829, 0.1843]) return= 62572.5693677297\n", + "probs of actions: tensor([0.7904, 0.8445, 0.0282, 0.8092, 0.8090, 0.8079, 0.7612, 0.8194, 0.8199,\n", + " 0.7612, 0.7964, 0.7755, 0.7516, 0.7987, 0.1141, 0.7796, 0.1087, 0.7876,\n", + " 0.8168, 0.7721, 0.7937, 0.7671, 0.9175, 0.9006, 0.9779],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3694, 0.2953, 0.2735, 0.2576, 0.2460, 0.2375, 0.2312,\n", + " 0.2265, 0.2231, 0.2205, 0.2185, 0.2171, 0.2205, 0.2082, 0.2138, 0.2032,\n", + " 0.2056, 0.2074, 0.2087, 0.2098, 0.2105, 0.2111, 0.2196])\n", + "finalReturns: tensor([0.0397, 0.0478, 0.0354])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([9, 9, 3, 9, 9, 9, 9, 6, 9, 9, 6, 9, 9, 9, 9, 9, 6, 9, 9, 9, 0, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680,\n", + " 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.5680,\n", + " 0.5680, 0.5680, 0.5680, 0.5680, 0.5680, 0.3644, 0.1765]) return= 62135.91864110961\n", + "probs of actions: tensor([0.8372, 0.8838, 0.0120, 0.8512, 0.8532, 0.8522, 0.8053, 0.0686, 0.8631,\n", + " 0.8069, 0.0854, 0.8223, 0.7987, 0.8417, 0.8412, 0.8223, 0.0815, 0.8315,\n", + " 0.8569, 0.8163, 0.0252, 0.8151, 0.9453, 0.9285, 0.9871],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3685, 0.3037, 0.2795, 0.2620, 0.2492, 0.2444, 0.2256,\n", + " 0.2224, 0.2245, 0.2111, 0.2115, 0.2118, 0.2121, 0.2123, 0.2169, 0.2055,\n", + " 0.2073, 0.2087, 0.2178, 0.1899, 0.1955, 0.1998, 0.2111])\n", + "finalReturns: tensor([0.0384, 0.0465, 0.0346])\n", + "----------------------------------------\n", + "iter 1 stage 22 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 9, 9, 6, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 0])\n", + "loss= tensor(0.0045, grad_fn=) , base rewards= tensor([0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024,\n", + " 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.6024,\n", + " 0.6024, 0.6024, 0.6024, 0.6024, 0.6024, 0.3834, 0.1845]) return= 63171.85534316236\n", + "probs of actions: tensor([0.8761, 0.9140, 0.9068, 0.8864, 0.8894, 0.8893, 0.8472, 0.8918, 0.8966,\n", + " 0.8503, 0.8758, 0.8626, 0.0164, 0.8787, 0.8780, 0.0591, 0.8541, 0.8692,\n", + " 0.8905, 0.8559, 0.8723, 0.8523, 0.9583, 0.9486, 0.9922],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2274, 0.2043, 0.2064, 0.2125, 0.2022, 0.2049,\n", + " 0.2068, 0.2083, 0.2094, 0.2103, 0.2109, 0.2114, 0.2198])\n", + "finalReturns: tensor([0.0397, 0.0478, 0.0354])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 12, 9, 9, 9, 9, 9, 12, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 12, 9, 9, 9, 9, 0])\n", + "loss= tensor(0.0137, grad_fn=) , base rewards= tensor([0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975,\n", + " 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975, 0.7975,\n", + " 0.7975, 0.7975, 0.7975, 0.7975, 0.5704, 0.3657, 0.1770]) return= 64479.669562396586\n", + "probs of actions: tensor([0.9159, 0.9412, 0.9358, 0.0256, 0.9201, 0.9246, 0.9016, 0.9215, 0.9276,\n", + " 0.0340, 0.9117, 0.9078, 0.8983, 0.9093, 0.9158, 0.9064, 0.9014, 0.9157,\n", + " 0.9270, 0.0320, 0.9053, 0.9155, 0.9631, 0.9623, 0.9863],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3143, 0.2999, 0.2768, 0.2600, 0.2478, 0.2388,\n", + " 0.2259, 0.2346, 0.2290, 0.2249, 0.2219, 0.2196, 0.2179, 0.2166, 0.2156,\n", + " 0.2149, 0.2081, 0.2211, 0.2190, 0.2175, 0.2163, 0.2235])\n", + "finalReturns: tensor([0.0788, 0.0869, 0.0741, 0.0465])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 9, 9, 9, 9, 12, 9, 9, 12, 9, 9, 9, 9, 9, 6,\n", + " 9, 0, 9, 9, 9, 6, 0])\n", + "loss= tensor(0.2748, grad_fn=) , base rewards= tensor([0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363,\n", + " 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363, 0.7363,\n", + " 0.7363, 0.7363, 0.7363, 0.7363, 0.5326, 0.3447, 0.1682]) return= 63525.18956622784\n", + "probs of actions: tensor([0.9149, 0.9400, 0.9339, 0.9228, 0.9178, 0.9228, 0.9010, 0.9185, 0.0332,\n", + " 0.8975, 0.9112, 0.0388, 0.8970, 0.9078, 0.9157, 0.9048, 0.9007, 0.0332,\n", + " 0.9261, 0.0118, 0.9043, 0.9107, 0.9565, 0.0225, 0.9908],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2302,\n", + " 0.2378, 0.2314, 0.2204, 0.2305, 0.2260, 0.2226, 0.2202, 0.2183, 0.2214,\n", + " 0.2089, 0.2179, 0.1900, 0.1956, 0.1998, 0.2075, 0.2067])\n", + "finalReturns: tensor([0.0734, 0.0815, 0.0695, 0.0385])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 12, 9, 9, 6, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 0])\n", + "loss= tensor(0.0129, grad_fn=) , base rewards= tensor([0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825,\n", + " 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825, 0.7825,\n", + " 0.7825, 0.7825, 0.7825, 0.7825, 0.5611, 0.3605, 0.1749]) return= 63854.30325636411\n", + "probs of actions: tensor([0.9253, 0.9474, 0.9409, 0.9324, 0.0420, 0.9313, 0.9130, 0.0223, 0.9336,\n", + " 0.9088, 0.9203, 0.9165, 0.9102, 0.9164, 0.9261, 0.9145, 0.9124, 0.9255,\n", + " 0.9341, 0.9146, 0.9132, 0.9181, 0.9589, 0.9694, 0.9937],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2854, 0.2788, 0.2615, 0.2534, 0.2322,\n", + " 0.2273, 0.2236, 0.2209, 0.2188, 0.2173, 0.2162, 0.2153, 0.2147, 0.2142,\n", + " 0.2139, 0.2136, 0.2134, 0.2133, 0.2131, 0.2131, 0.2211])\n", + "finalReturns: tensor([0.0781, 0.0862, 0.0736, 0.0462])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 21 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 12, 9, 9, 9, 9, 0])\n", + "loss= tensor(0.0193, grad_fn=) , base rewards= tensor([0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966,\n", + " 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966, 0.7966,\n", + " 0.7966, 0.7966, 0.7966, 0.7966, 0.5698, 0.3654, 0.1769]) return= 64011.61156289775\n", + "probs of actions: tensor([0.9028, 0.9281, 0.9189, 0.9113, 0.9003, 0.9093, 0.8888, 0.9008, 0.9104,\n", + " 0.8831, 0.8980, 0.8920, 0.8875, 0.8917, 0.9071, 0.8885, 0.8897, 0.9041,\n", + " 0.9133, 0.0715, 0.8885, 0.8815, 0.9319, 0.9598, 0.9956],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2365,\n", + " 0.2304, 0.2260, 0.2226, 0.2202, 0.2183, 0.2169, 0.2159, 0.2151, 0.2145,\n", + " 0.2141, 0.2075, 0.2206, 0.2187, 0.2172, 0.2161, 0.2234])\n", + "finalReturns: tensor([0.0788, 0.0869, 0.0741, 0.0465])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 9, 9, 9, 9, 9, 9, 9, 12, 9, 9, 15, 12, 9, 9, 12, 9, 12,\n", + " 9, 9, 9, 9, 9, 9, 0])\n", + "loss= tensor(0.0421, grad_fn=) , base rewards= tensor([0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001,\n", + " 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001, 0.8001,\n", + " 0.8001, 0.8001, 0.8001, 0.8001, 0.5720, 0.3666, 0.1774]) return= 65108.245685588154\n", + "probs of actions: tensor([0.8282, 0.8623, 0.8464, 0.8418, 0.8199, 0.8360, 0.8128, 0.8229, 0.1314,\n", + " 0.8013, 0.8239, 0.0089, 0.1378, 0.8145, 0.8448, 0.1504, 0.8174, 0.1274,\n", + " 0.8468, 0.8121, 0.8161, 0.7587, 0.8521, 0.9195, 0.9976],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4193, 0.3613, 0.3206, 0.2917, 0.2708, 0.2557, 0.2446, 0.2302,\n", + " 0.2378, 0.2314, 0.2123, 0.2315, 0.2389, 0.2322, 0.2210, 0.2309, 0.2200,\n", + " 0.2302, 0.2258, 0.2225, 0.2200, 0.2182, 0.2169, 0.2239])\n", + "finalReturns: tensor([0.0789, 0.0870, 0.0742, 0.0465])\n", + "----------------------------------------\n", + "iter 1 stage 21 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 9, 9, 9, 9, 9, 9, 12, 9, 12, 9, 9, 12, 12, 12, 9,\n", + " 15, 12, 9, 9, 12, 9, 0])\n", + "loss= tensor(0.1889, grad_fn=) , base rewards= tensor([0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339,\n", + " 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339, 0.8339,\n", + " 0.8339, 0.8339, 0.8339, 0.8339, 0.5927, 0.3780, 0.1822]) return= 66273.57654399677\n", + "probs of actions: tensor([0.3208, 0.2918, 0.3097, 0.6656, 0.6256, 0.6527, 0.6345, 0.6362, 0.6539,\n", + " 0.3379, 0.6420, 0.3300, 0.6465, 0.6312, 0.2827, 0.3408, 0.3112, 0.6632,\n", + " 0.0122, 0.3303, 0.6451, 0.4837, 0.3308, 0.7926, 0.9987],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3408, 0.3061, 0.2812, 0.2633, 0.2502, 0.2405,\n", + " 0.2272, 0.2356, 0.2235, 0.2328, 0.2277, 0.2176, 0.2221, 0.2254, 0.2342,\n", + " 0.2144, 0.2331, 0.2401, 0.2331, 0.2216, 0.2314, 0.2348])\n", + "finalReturns: tensor([0.0870, 0.0951, 0.0881, 0.0525])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 12, 12, 12, 9, 12, 12, 15, 12, 9, 9, 12, 9, 12, 12, 9, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.2135, grad_fn=) , base rewards= tensor([1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212,\n", + " 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212, 1.0212,\n", + " 1.0212, 1.0212, 1.0212, 0.7747, 0.5564, 0.3579, 0.1738]) return= 67469.79672706983\n", + "probs of actions: tensor([0.2699, 0.6926, 0.7001, 0.6739, 0.2550, 0.6957, 0.6790, 0.0173, 0.6889,\n", + " 0.2628, 0.2843, 0.6976, 0.2999, 0.6886, 0.6446, 0.2603, 0.6645, 0.6650,\n", + " 0.6531, 0.6966, 0.6835, 0.8314, 0.7349, 0.5680, 0.9983],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4130, 0.3642, 0.3296, 0.3110, 0.2784, 0.2674, 0.2512, 0.2611,\n", + " 0.2609, 0.2484, 0.2330, 0.2399, 0.2267, 0.2289, 0.2369, 0.2244, 0.2272,\n", + " 0.2293, 0.2309, 0.2320, 0.2329, 0.2336, 0.2341, 0.2489])\n", + "finalReturns: tensor([0.1603, 0.1747, 0.1602, 0.1251, 0.0751])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 9, 12, 12, 12, 9, 12, 12, 9,\n", + " 12, 12, 12, 12, 9, 12, 0])\n", + "loss= tensor(0.3982, grad_fn=) , base rewards= tensor([1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143,\n", + " 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143, 1.0143,\n", + " 1.0143, 1.0143, 1.0143, 0.7703, 0.5536, 0.3564, 0.1731]) return= 67733.46532960936\n", + "probs of actions: tensor([0.8418, 0.8431, 0.8455, 0.8234, 0.8511, 0.1417, 0.8230, 0.8359, 0.8338,\n", + " 0.8354, 0.1529, 0.8379, 0.8105, 0.8279, 0.1763, 0.8419, 0.8088, 0.1605,\n", + " 0.8070, 0.8347, 0.8422, 0.9195, 0.1189, 0.7536, 0.9979],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2955, 0.2673, 0.2592, 0.2532,\n", + " 0.2487, 0.2517, 0.2354, 0.2355, 0.2355, 0.2418, 0.2281, 0.2300, 0.2377,\n", + " 0.2250, 0.2276, 0.2296, 0.2311, 0.2385, 0.2257, 0.2425])\n", + "finalReturns: tensor([0.1531, 0.1675, 0.1531, 0.1118, 0.0694])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0534, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9099, 0.9138, 0.9140, 0.8978, 0.9148, 0.9090, 0.8954, 0.9049, 0.9047,\n", + " 0.9035, 0.8959, 0.9057, 0.8875, 0.8993, 0.8838, 0.9082, 0.8855, 0.8936,\n", + " 0.8859, 0.9043, 0.9167, 0.9566, 0.9230, 0.8634, 0.9973],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 15, 9, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0448, grad_fn=) , base rewards= tensor([1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323,\n", + " 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323, 1.0323,\n", + " 1.0323, 1.0323, 1.0323, 0.7819, 0.5608, 0.3604, 0.1748]) return= 68680.34770364207\n", + "probs of actions: tensor([0.9237, 0.9274, 0.9270, 0.9128, 0.9279, 0.9232, 0.9108, 0.9185, 0.9195,\n", + " 0.9184, 0.9107, 0.9201, 0.0090, 0.0734, 0.9014, 0.9213, 0.9018, 0.9092,\n", + " 0.9019, 0.9186, 0.9349, 0.9651, 0.9375, 0.8722, 0.9980],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2344, 0.2547, 0.2376, 0.2371, 0.2367, 0.2364,\n", + " 0.2362, 0.2361, 0.2359, 0.2359, 0.2358, 0.2357, 0.2501])\n", + "finalReturns: tensor([0.1612, 0.1756, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0309, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9452, 0.9495, 0.9486, 0.9376, 0.9484, 0.9455, 0.9354, 0.9409, 0.9425,\n", + " 0.9408, 0.9347, 0.9422, 0.9302, 0.9372, 0.9278, 0.9434, 0.9283, 0.9348,\n", + " 0.9291, 0.9408, 0.9553, 0.9748, 0.9568, 0.9097, 0.9988],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 20 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0189, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9643, 0.9682, 0.9674, 0.9595, 0.9663, 0.9648, 0.9575, 0.9611, 0.9624,\n", + " 0.9606, 0.9569, 0.9619, 0.9534, 0.9585, 0.9525, 0.9628, 0.9520, 0.9574,\n", + " 0.9532, 0.9609, 0.9724, 0.9833, 0.9721, 0.9466, 0.9995],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 209999 adversary: const95-1.0,\n", + " actions: tensor([ 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 15, 12, 12,\n", + " 9, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0135, grad_fn=) , base rewards= tensor([1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239,\n", + " 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239, 1.0239,\n", + " 1.0239, 1.0239, 1.0239, 0.7765, 0.5575, 0.3585, 0.1740]) return= 68418.15387194039\n", + "probs of actions: tensor([0.0213, 0.9771, 0.9759, 0.9698, 0.9749, 0.9739, 0.9680, 0.9708, 0.9719,\n", + " 0.9702, 0.9677, 0.9714, 0.9648, 0.9688, 0.9647, 0.0047, 0.9634, 0.9685,\n", + " 0.0284, 0.9710, 0.9806, 0.9873, 0.9793, 0.9627, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.5031, 0.4130, 0.3642, 0.3296, 0.3047, 0.2866, 0.2734, 0.2637, 0.2565,\n", + " 0.2512, 0.2473, 0.2443, 0.2421, 0.2405, 0.2393, 0.2302, 0.2452, 0.2428,\n", + " 0.2473, 0.2321, 0.2330, 0.2337, 0.2341, 0.2345, 0.2492])\n", + "finalReturns: tensor([0.1605, 0.1749, 0.1604, 0.1252, 0.0752])\n", + "----------------------------------------\n", + "iter 1 stage 20 ep 239999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0093, grad_fn=) , base rewards= tensor([1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332, 1.0332,\n", + " 1.0332, 1.0332, 1.0332, 0.7825, 0.5612, 0.3606, 0.1749]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9810, 0.9838, 0.9830, 0.9785, 0.9821, 0.9814, 0.9769, 0.9789, 0.9797,\n", + " 0.9782, 0.9766, 0.9792, 0.9742, 0.9773, 0.9744, 0.9799, 0.9734, 0.9771,\n", + " 0.9746, 0.9788, 0.9866, 0.9908, 0.9859, 0.9750, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.1613, 0.1757, 0.1609, 0.1255, 0.0753])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0147, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9829, 0.9857, 0.9848, 0.9809, 0.9839, 0.9834, 0.9793, 0.9810, 0.9817,\n", + " 0.9800, 0.9791, 0.9810, 0.9765, 0.9796, 0.9771, 0.9821, 0.9761, 0.9795,\n", + " 0.9773, 0.9816, 0.9874, 0.9913, 0.9874, 0.9803, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0115, grad_fn=) , base rewards= tensor([1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881,\n", + " 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881, 1.1881,\n", + " 1.1881, 1.1881, 0.9414, 0.7229, 0.5243, 0.3400, 0.1662]) return= 68487.85710629346\n", + "probs of actions: tensor([0.9863, 0.9887, 0.9880, 0.9849, 0.9871, 0.9869, 0.9833, 0.9847, 0.9852,\n", + " 0.9837, 0.9833, 0.9847, 0.9810, 0.9835, 0.9818, 0.9857, 0.0142, 0.9837,\n", + " 0.9816, 0.9863, 0.9894, 0.9925, 0.9901, 0.9853, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2441, 0.2298,\n", + " 0.2312, 0.2323, 0.2331, 0.2337, 0.2342, 0.2346, 0.2492])\n", + "finalReturns: tensor([0.2290, 0.2434, 0.2289, 0.1937, 0.1437, 0.0830])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0109, grad_fn=) , base rewards= tensor([1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969,\n", + " 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969, 1.1969,\n", + " 1.1969, 1.1969, 0.9473, 0.7267, 0.5266, 0.3414, 0.1668]) return= 68466.13679373146\n", + "probs of actions: tensor([0.9871, 0.9894, 0.9886, 0.9857, 0.9878, 0.9876, 0.9842, 0.9854, 0.9859,\n", + " 0.9844, 0.9841, 0.9854, 0.0124, 0.9845, 0.9828, 0.9864, 0.9816, 0.9844,\n", + " 0.9827, 0.9874, 0.9904, 0.9920, 0.9903, 0.9871, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2488, 0.2332, 0.2338, 0.2343, 0.2346, 0.2348,\n", + " 0.2350, 0.2352, 0.2353, 0.2354, 0.2354, 0.2355, 0.2499])\n", + "finalReturns: tensor([0.2297, 0.2441, 0.2295, 0.1941, 0.1440, 0.0831])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0119, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9861, 0.9886, 0.9877, 0.9847, 0.9868, 0.9867, 0.9830, 0.9844, 0.9848,\n", + " 0.9831, 0.9829, 0.9842, 0.9807, 0.9830, 0.9819, 0.9855, 0.9805, 0.9834,\n", + " 0.9816, 0.9860, 0.9886, 0.9912, 0.9900, 0.9871, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 9, 12, 12, 12, 0])\n", + "loss= tensor(1.3077, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68553.0200585037\n", + "probs of actions: tensor([0.9907, 0.9926, 0.9919, 0.9898, 0.9912, 0.9911, 0.9885, 0.9896, 0.9898,\n", + " 0.9885, 0.9884, 0.9893, 0.9868, 0.9885, 0.9877, 0.9902, 0.9867, 0.9888,\n", + " 0.9876, 0.9906, 0.0035, 0.9945, 0.9941, 0.9918, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2426, 0.2287, 0.2304, 0.2317, 0.2471])\n", + "finalReturns: tensor([0.2160, 0.2304, 0.2093, 0.1814, 0.1368, 0.0800])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 19 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0061, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9924, 0.9940, 0.9934, 0.9917, 0.9928, 0.9928, 0.9905, 0.9914, 0.9916,\n", + " 0.9904, 0.9904, 0.9912, 0.9891, 0.9904, 0.9901, 0.9920, 0.9890, 0.9909,\n", + " 0.9898, 0.9925, 0.9938, 0.9950, 0.9955, 0.9941, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 209999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0064, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9923, 0.9939, 0.9933, 0.9915, 0.9926, 0.9926, 0.9902, 0.9912, 0.9913,\n", + " 0.9900, 0.9902, 0.9909, 0.9888, 0.9902, 0.9899, 0.9918, 0.9888, 0.9907,\n", + " 0.9896, 0.9921, 0.9934, 0.9947, 0.9953, 0.9946, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 239999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0052, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9937, 0.9951, 0.9945, 0.9930, 0.9939, 0.9940, 0.9920, 0.9928, 0.9928,\n", + " 0.9917, 0.9919, 0.9925, 0.9907, 0.9918, 0.9918, 0.9932, 0.9907, 0.9924,\n", + " 0.9915, 0.9935, 0.9943, 0.9953, 0.9964, 0.9963, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 269999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0042, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9949, 0.9961, 0.9956, 0.9943, 0.9950, 0.9951, 0.9934, 0.9942, 0.9941,\n", + " 0.9931, 0.9934, 0.9938, 0.9924, 0.9933, 0.9934, 0.9945, 0.9925, 0.9938,\n", + " 0.9930, 0.9945, 0.9955, 0.9960, 0.9971, 0.9974, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 19 ep 299999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0036, grad_fn=) , base rewards= tensor([1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009, 1.2009,\n", + " 1.2009, 1.2009, 0.9500, 0.7285, 0.5277, 0.3420, 0.1670]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9955, 0.9965, 0.9961, 0.9950, 0.9956, 0.9957, 0.9942, 0.9949, 0.9947,\n", + " 0.9938, 0.9941, 0.9945, 0.9932, 0.9940, 0.9942, 0.9951, 0.9933, 0.9945,\n", + " 0.9938, 0.9955, 0.9958, 0.9966, 0.9976, 0.9978, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.2301, 0.2445, 0.2297, 0.1944, 0.1441, 0.0832])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0060, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9956, 0.9966, 0.9962, 0.9951, 0.9957, 0.9958, 0.9943, 0.9950, 0.9948,\n", + " 0.9939, 0.9942, 0.9946, 0.9934, 0.9942, 0.9944, 0.9952, 0.9935, 0.9947,\n", + " 0.9950, 0.9955, 0.9961, 0.9962, 0.9977, 0.9982, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 59999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9976, 0.9982, 0.9980, 0.9974, 0.9977, 0.9978, 0.9969, 0.9973, 0.9972,\n", + " 0.9966, 0.9968, 0.9971, 0.9963, 0.9968, 0.9969, 0.9974, 0.9963, 0.9971,\n", + " 0.9975, 0.9977, 0.9981, 0.9982, 0.9989, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 89999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0034, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9973, 0.9980, 0.9977, 0.9970, 0.9973, 0.9975, 0.9965, 0.9969, 0.9968,\n", + " 0.9961, 0.9964, 0.9967, 0.9959, 0.9964, 0.9966, 0.9971, 0.9959, 0.9968,\n", + " 0.9972, 0.9974, 0.9977, 0.9979, 0.9989, 0.9991, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 18 ep 119999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0022, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9981, 0.9986, 0.9984, 0.9979, 0.9982, 0.9983, 0.9975, 0.9978, 0.9977,\n", + " 0.9973, 0.9975, 0.9977, 0.9971, 0.9974, 0.9976, 0.9979, 0.9971, 0.9977,\n", + " 0.9980, 0.9986, 0.9984, 0.9985, 0.9993, 0.9995, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 149999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9984, 0.9989, 0.9987, 0.9983, 0.9984, 0.9986, 0.9979, 0.9982, 0.9981,\n", + " 0.9977, 0.9979, 0.9980, 0.9975, 0.9978, 0.9980, 0.9983, 0.9975, 0.9981,\n", + " 0.9985, 0.9989, 0.9987, 0.9988, 0.9994, 0.9997, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 179999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0014, grad_fn=) , base rewards= tensor([1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631, 1.3631,\n", + " 1.3631, 1.1119, 0.8901, 0.6892, 0.5034, 0.3283, 0.1613]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9987, 0.9991, 0.9989, 0.9985, 0.9987, 0.9988, 0.9982, 0.9985, 0.9984,\n", + " 0.9980, 0.9982, 0.9983, 0.9978, 0.9982, 0.9983, 0.9985, 0.9979, 0.9984,\n", + " 0.9988, 0.9992, 0.9989, 0.9990, 0.9995, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3047, 0.3191, 0.3044, 0.2690, 0.2187, 0.1578, 0.0890])\n", + "----------------------------------------\n", + "iter 1 stage 18 ep 190012 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 15, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0011, grad_fn=) , base rewards= tensor([1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810,\n", + " 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810, 1.3810,\n", + " 1.3810, 1.1241, 0.8984, 0.6947, 0.5068, 0.3302, 0.1621]) return= 68884.88646283273\n", + "probs of actions: tensor([0.9989, 0.9992, 0.9990, 0.9987, 0.9988, 0.9989, 0.9984, 0.9987, 0.9986,\n", + " 0.9982, 0.9984, 0.9985, 0.9981, 0.9984, 0.9985, 0.9987, 0.0012, 0.9986,\n", + " 0.9990, 0.9993, 0.9991, 0.9992, 0.9996, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2297, 0.2448,\n", + " 0.2425, 0.2408, 0.2395, 0.2385, 0.2378, 0.2372, 0.2512])\n", + "finalReturns: tensor([0.3064, 0.3208, 0.3058, 0.2700, 0.2195, 0.1582, 0.0892])\n", + "----------------------------------------\n", + "iter 1 stage 17 ep 1044 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214,\n", + " 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214, 1.5214,\n", + " 1.2697, 1.0477, 0.8466, 0.6606, 0.4855, 0.3183, 0.1570]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9989, 0.9992, 0.9991, 0.9987, 0.9989, 0.9990, 0.9985, 0.9987, 0.9986,\n", + " 0.9983, 0.9984, 0.9986, 0.9981, 0.9984, 0.9986, 0.9988, 0.9982, 0.9990,\n", + " 0.9990, 0.9993, 0.9991, 0.9992, 0.9996, 0.9998, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.3837, 0.3981, 0.3833, 0.3478, 0.2976, 0.2366, 0.1678, 0.0932])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 29999 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0017, grad_fn=) , base rewards= tensor([1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770,\n", + " 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.6770, 1.4248,\n", + " 1.2024, 1.0011, 0.8148, 0.6396, 0.4723, 0.3109, 0.1538]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9992, 0.9994, 0.9993, 0.9991, 0.9992, 0.9993, 0.9989, 0.9991, 0.9990,\n", + " 0.9987, 0.9989, 0.9990, 0.9986, 0.9989, 0.9990, 0.9991, 0.9989, 0.9994,\n", + " 0.9994, 0.9996, 0.9994, 0.9996, 0.9997, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.4658, 0.4802, 0.4654, 0.4299, 0.3796, 0.3186, 0.2498, 0.1752, 0.0964])\n", + "----------------------------------------\n", + "iter 1 stage 16 ep 35741 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 15, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0015, grad_fn=) , base rewards= tensor([1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877,\n", + " 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.6877, 1.4323,\n", + " 1.2076, 1.0047, 0.8173, 0.6412, 0.4733, 0.3115, 0.1541]) return= 68906.62996763481\n", + "probs of actions: tensor([9.9926e-01, 9.9949e-01, 9.9938e-01, 9.9916e-01, 9.9924e-01, 9.9932e-01,\n", + " 9.9897e-01, 9.9913e-01, 9.9906e-01, 9.9883e-01, 9.9895e-01, 9.9905e-01,\n", + " 8.9071e-04, 9.9894e-01, 9.9906e-01, 9.9918e-01, 9.9901e-01, 9.9949e-01,\n", + " 9.9950e-01, 9.9960e-01, 9.9945e-01, 9.9967e-01, 9.9976e-01, 9.9999e-01,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2344, 0.2484, 0.2451, 0.2427, 0.2409, 0.2396,\n", + " 0.2386, 0.2378, 0.2373, 0.2369, 0.2365, 0.2363, 0.2505])\n", + "finalReturns: tensor([0.4669, 0.4813, 0.4663, 0.4307, 0.3802, 0.3190, 0.2501, 0.1754, 0.0964])\n", + "----------------------------------------\n", + "iter 1 stage 15 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0021, grad_fn=) , base rewards= tensor([1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309,\n", + " 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.8309, 1.5780, 1.3551,\n", + " 1.1534, 0.9669, 0.7914, 0.6240, 0.4625, 0.3054, 0.1515]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9989, 0.9990, 0.9987, 0.9990, 0.9990, 0.9992, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.5504, 0.5648, 0.5499, 0.5144, 0.4641, 0.4030, 0.3342, 0.2596, 0.1807,\n", + " 0.0987])\n", + "----------------------------------------\n", + "iter 1 stage 14 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0030, grad_fn=) , base rewards= tensor([1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839,\n", + " 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.9839, 1.7301, 1.5065, 1.3043,\n", + " 1.1175, 0.9417, 0.7741, 0.6125, 0.4553, 0.3013, 0.1497]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9989, 0.9990, 0.9987, 0.9990, 0.9990, 0.9992, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.6368, 0.6512, 0.6363, 0.6007, 0.5503, 0.4892, 0.4203, 0.3457, 0.2668,\n", + " 0.1848, 0.1005])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "iter 1 stage 13 ep 60 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0039, grad_fn=) , base rewards= tensor([2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 2.1368,\n", + " 2.1368, 2.1368, 2.1368, 2.1368, 2.1368, 1.8817, 1.6572, 1.4543, 1.2670,\n", + " 1.0910, 0.9231, 0.7613, 0.6040, 0.4499, 0.2982, 0.1484]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9989, 0.9990, 0.9987, 0.9990, 0.9991, 0.9992, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9994, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.7246, 0.7390, 0.7241, 0.6884, 0.6380, 0.5768, 0.5079, 0.4332, 0.3542,\n", + " 0.2722, 0.1879, 0.1018])\n", + "----------------------------------------\n", + "iter 1 stage 12 ep 674 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0047, grad_fn=) , base rewards= tensor([2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903, 2.2903,\n", + " 2.2903, 2.2903, 2.2903, 2.2903, 2.0334, 1.8077, 1.6040, 1.4161, 1.2396,\n", + " 1.0714, 0.9093, 0.7518, 0.5976, 0.4458, 0.2960, 0.1475]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9989, 0.9991, 0.9990, 0.9992, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9994, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.8136, 0.8280, 0.8130, 0.7773, 0.7267, 0.6655, 0.5964, 0.5217, 0.4427,\n", + " 0.3606, 0.2762, 0.1901, 0.1027])\n", + "----------------------------------------\n", + "iter 1 stage 11 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0058, grad_fn=) , base rewards= tensor([2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451, 2.4451,\n", + " 2.4451, 2.4451, 2.4451, 2.1859, 1.9586, 1.7537, 1.5650, 1.3879, 1.2192,\n", + " 1.0569, 0.8991, 0.7447, 0.5928, 0.4428, 0.2943, 0.1467]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9989, 0.9991, 0.9990, 0.9992, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9994, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.9036, 0.9180, 0.9029, 0.8670, 0.8163, 0.7549, 0.6858, 0.6110, 0.5319,\n", + " 0.4498, 0.3654, 0.2792, 0.1918, 0.1035])\n", + "----------------------------------------\n", + "iter 1 stage 10 ep 58 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0070, grad_fn=) , base rewards= tensor([2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021, 2.6021,\n", + " 2.6021, 2.6021, 2.3399, 2.1104, 1.9040, 1.7141, 1.5362, 1.3670, 1.2041,\n", + " 1.0460, 0.8914, 0.7394, 0.5893, 0.4406, 0.2930, 0.1462]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9992, 0.9993, 0.9990, 0.9991, 0.9991,\n", + " 0.9988, 0.9990, 0.9991, 0.9990, 0.9992, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9994, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([0.9944, 1.0088, 0.9935, 0.9575, 0.9066, 0.8451, 0.7758, 0.7009, 0.6218,\n", + " 0.5396, 0.4551, 0.3689, 0.2815, 0.1931, 0.1040])\n", + "----------------------------------------\n", + "iter 1 stage 9 ep 794 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 15, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0075, grad_fn=) , base rewards= tensor([2.7830, 2.7830, 2.7830, 2.7830, 2.7830, 2.7830, 2.7830, 2.7830, 2.7830,\n", + " 2.7830, 2.5107, 2.2742, 2.0629, 1.8694, 1.6889, 1.5178, 1.3536, 1.1945,\n", + " 1.0391, 0.8865, 0.7360, 0.5870, 0.4391, 0.2922, 0.1458]) return= 68919.5088490973\n", + "probs of actions: tensor([9.9929e-01, 9.9951e-01, 9.9940e-01, 9.9919e-01, 9.9927e-01, 9.9935e-01,\n", + " 9.9900e-01, 6.2436e-04, 9.9908e-01, 9.9900e-01, 9.9922e-01, 9.9933e-01,\n", + " 9.9913e-01, 9.9936e-01, 9.9929e-01, 9.9932e-01, 9.9904e-01, 9.9950e-01,\n", + " 9.9951e-01, 9.9961e-01, 9.9946e-01, 9.9970e-01, 9.9976e-01, 1.0000e+00,\n", + " 1.0000e+00], grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2570, 0.2655,\n", + " 0.2578, 0.2522, 0.2480, 0.2449, 0.2425, 0.2408, 0.2395, 0.2385, 0.2378,\n", + " 0.2372, 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2503])\n", + "finalReturns: tensor([1.0883, 1.1027, 1.0870, 1.0504, 0.9989, 0.9369, 0.8672, 0.7919, 0.7126,\n", + " 0.6302, 0.5455, 0.4592, 0.3717, 0.2833, 0.1941, 0.1044])\n", + "----------------------------------------\n", + "iter 1 stage 8 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0090, grad_fn=) , base rewards= tensor([2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276, 2.9276,\n", + " 2.6556, 2.4193, 2.2080, 2.0147, 1.8342, 1.6632, 1.4990, 1.3399, 1.1845,\n", + " 1.0319, 0.8814, 0.7324, 0.5846, 0.4376, 0.2913, 0.1455]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.1785, 1.1929, 1.1773, 1.1406, 1.0892, 1.0272, 0.9575, 0.8823, 0.8029,\n", + " 0.7205, 0.6359, 0.5496, 0.4620, 0.3736, 0.2844, 0.1948, 0.1047])\n", + "----------------------------------------\n", + "iter 1 stage 7 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0103, grad_fn=) , base rewards= tensor([3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 3.0992, 2.8197,\n", + " 2.5781, 2.3632, 2.1671, 1.9848, 1.8123, 1.6471, 1.4872, 1.3313, 1.1783,\n", + " 1.0274, 0.8782, 0.7302, 0.5831, 0.4367, 0.2908, 0.1453]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.2720, 1.2864, 1.2704, 1.2334, 1.1815, 1.1191, 1.0491, 0.9736, 0.8941,\n", + " 0.8115, 0.7268, 0.6404, 0.5528, 0.4643, 0.3751, 0.2854, 0.1953, 0.1050])\n", + "----------------------------------------\n", + "iter 1 stage 6 ep 2 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0120, grad_fn=) , base rewards= tensor([3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 3.2799, 2.9902, 2.7415,\n", + " 2.5215, 2.3219, 2.1370, 1.9626, 1.7960, 1.6351, 1.4784, 1.3248, 1.1736,\n", + " 1.0241, 0.8758, 0.7286, 0.5820, 0.4360, 0.2904, 0.1451]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.3666, 1.3810, 1.3646, 1.3270, 1.2746, 1.2117, 1.1413, 1.0654, 0.9856,\n", + " 0.9029, 0.8179, 0.7314, 0.6437, 0.5552, 0.4659, 0.3762, 0.2861, 0.1957,\n", + " 0.1051])\n", + "----------------------------------------\n", + "iter 1 stage 5 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0133, grad_fn=) , base rewards= tensor([3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.4731, 3.1695, 2.9111, 2.6844,\n", + " 2.4799, 2.2915, 2.1146, 1.9461, 1.7839, 1.6262, 1.4718, 1.3200, 1.1701,\n", + " 1.0215, 0.8740, 0.7273, 0.5812, 0.4355, 0.2901, 0.1450]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.4627, 1.4771, 1.4601, 1.4217, 1.3686, 1.3050, 1.2341, 1.1578, 1.0776,\n", + " 0.9945, 0.9094, 0.8228, 0.7349, 0.6463, 0.5570, 0.4672, 0.3770, 0.2866,\n", + " 0.1960, 0.1053])\n", + "----------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter 1 stage 4 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0148, grad_fn=) , base rewards= tensor([3.6835, 3.6835, 3.6835, 3.6835, 3.6835, 3.3608, 3.0893, 2.8534, 2.6424,\n", + " 2.4492, 2.2689, 2.0980, 1.9339, 1.7748, 1.6195, 1.4669, 1.3164, 1.1675,\n", + " 1.0197, 0.8727, 0.7264, 0.5805, 0.4351, 0.2899, 0.1449]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.5606, 1.5750, 1.5572, 1.5179, 1.4637, 1.3993, 1.3276, 1.2507, 1.1700,\n", + " 1.0866, 1.0012, 0.9143, 0.8264, 0.7376, 0.6482, 0.5583, 0.4681, 0.3777,\n", + " 0.2870, 0.1962, 0.1054])\n", + "----------------------------------------\n", + "iter 1 stage 3 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0165, grad_fn=) , base rewards= tensor([3.9177, 3.9177, 3.9177, 3.9177, 3.5687, 3.2793, 3.0307, 2.8109, 2.6114,\n", + " 2.4265, 2.2522, 2.0856, 1.9247, 1.7680, 1.6145, 1.4632, 1.3137, 1.1655,\n", + " 1.0182, 0.8717, 0.7257, 0.5801, 0.4348, 0.2897, 0.1448]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.6609, 1.6753, 1.6565, 1.6158, 1.5603, 1.4947, 1.4220, 1.3444, 1.2631,\n", + " 1.1792, 1.0934, 1.0062, 0.9180, 0.8291, 0.7395, 0.6496, 0.5593, 0.4688,\n", + " 0.3781, 0.2873, 0.1964, 0.1054])\n", + "----------------------------------------\n", + "iter 1 stage 2 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0178, grad_fn=) , base rewards= tensor([4.1854, 4.1854, 4.1854, 3.7998, 3.4854, 3.2196, 2.9877, 2.7795, 2.5884,\n", + " 2.4096, 2.2397, 2.0764, 1.9179, 1.7630, 1.6108, 1.4605, 1.3117, 1.1640,\n", + " 1.0172, 0.8709, 0.7252, 0.5797, 0.4345, 0.2896, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.7644, 1.7788, 1.7586, 1.7161, 1.6589, 1.5917, 1.5177, 1.4390, 1.3568,\n", + " 1.2723, 1.1860, 1.0985, 1.0100, 0.9208, 0.8311, 0.7410, 0.6506, 0.5601,\n", + " 0.4693, 0.3785, 0.2875, 0.1965, 0.1055])\n", + "----------------------------------------\n", + "iter 1 stage 1 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0191, grad_fn=) , base rewards= tensor([4.5005, 4.5005, 4.0633, 3.7141, 3.4244, 3.1758, 2.9558, 2.7562, 2.5713,\n", + " 2.3970, 2.2304, 2.0695, 1.9128, 1.7592, 1.6080, 1.4584, 1.3102, 1.1629,\n", + " 1.0164, 0.8704, 0.7248, 0.5795, 0.4344, 0.2895, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.8720, 1.8864, 1.8645, 1.8196, 1.7600, 1.6907, 1.6150, 1.5348, 1.4516,\n", + " 1.3662, 1.2792, 1.1911, 1.1022, 1.0128, 0.9228, 0.8326, 0.7421, 0.6514,\n", + " 0.5606, 0.4697, 0.3787, 0.2877, 0.1966, 0.1055])\n", + "----------------------------------------\n", + "iter 1 stage 0 ep 0 adversary: const95-1.0,\n", + " actions: tensor([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 12, 12, 12, 12, 12, 0])\n", + "loss= tensor(0.0208, grad_fn=) , base rewards= tensor([4.8841, 4.3729, 3.9744, 3.6513, 3.3795, 3.1433, 2.9322, 2.7389, 2.5586,\n", + " 2.3875, 2.2234, 2.0643, 1.9089, 1.7564, 1.6059, 1.4569, 1.3091, 1.1621,\n", + " 1.0158, 0.8699, 0.7245, 0.5793, 0.4343, 0.2894, 0.1447]) return= 68694.09895647192\n", + "probs of actions: tensor([0.9993, 0.9995, 0.9994, 0.9992, 0.9993, 0.9993, 0.9990, 0.9992, 0.9991,\n", + " 0.9990, 0.9992, 0.9993, 0.9991, 0.9994, 0.9993, 0.9993, 0.9990, 0.9995,\n", + " 0.9995, 0.9996, 0.9995, 0.9997, 0.9998, 1.0000, 1.0000],\n", + " grad_fn=)\n", + "rewards: tensor([0.4968, 0.4229, 0.3712, 0.3345, 0.3083, 0.2892, 0.2753, 0.2651, 0.2576,\n", + " 0.2520, 0.2479, 0.2448, 0.2425, 0.2407, 0.2394, 0.2385, 0.2378, 0.2372,\n", + " 0.2368, 0.2365, 0.2363, 0.2361, 0.2360, 0.2359, 0.2502])\n", + "finalReturns: tensor([1.9853, 1.9997, 1.9753, 1.9272, 1.8645, 1.7924, 1.7143, 1.6323, 1.5475,\n", + " 1.4610, 1.3731, 1.2844, 1.1950, 1.1051, 1.0148, 0.9244, 0.8337, 0.7429,\n", + " 0.6520, 0.5610, 0.4700, 0.3789, 0.2878, 0.1967, 0.1056])\n", + "policy saved!\n", + "1,3,[5e-06,1][1, 10000, 1, 1],1683196677 saved\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# neuralNet=NNBase(num_input=game.T+2+game.stateAdvHistory, lr=hyperParams[0],num_actions=18,action_step=actionStep)\n", + "# algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=50_000, discountFactor =hyperParams[1])\n", + "\n", + "\n", + "# algorithm.solver(print_step=30_000,options=codeParams,converge_break=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NNBase(num_input=game.T+2+game.stateAdvHistory, lr=hyperParams[0],num_actions=18,action_step=actionStep)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=50_000, discountFactor =hyperParams[1])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "policy reset\n", + "policy loaded!\n" + ] + } + ], + "source": [ + "algorithm.loadPolicyNet(\"1,3,[5e-06,1][1, 10000, 1, 1],1683196677\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "mat1 and mat2 shapes cannot be multiplied (1x27 and 28x512)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [6]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43malgorithm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplayTrainedAgent\u001b[49m\u001b[43m(\u001b[49m\u001b[43madv\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\EquiLearn\\PGM_base\\learningBase.py:297\u001b[0m, in \u001b[0;36mReinforceAlgorithm.playTrainedAgent\u001b[1;34m(self, adversary, iterNum)\u001b[0m\n\u001b[0;32m 295\u001b[0m prevState \u001b[38;5;241m=\u001b[39m state\n\u001b[0;32m 296\u001b[0m normPrevState \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv\u001b[38;5;241m.\u001b[39mnormalizeState(prevState)\n\u001b[1;32m--> 297\u001b[0m probs\u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpolicy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnormPrevState\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 298\u001b[0m distAction \u001b[38;5;241m=\u001b[39m Categorical(probs)\n\u001b[0;32m 299\u001b[0m action \u001b[38;5;241m=\u001b[39m distAction\u001b[38;5;241m.\u001b[39msample()\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\nn\\modules\\module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28minput\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[0;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\nn\\modules\\container.py:204\u001b[0m, in \u001b[0;36mSequential.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m 202\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[0;32m 203\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[1;32m--> 204\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 205\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\nn\\modules\\module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28minput\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[0;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\torch\\nn\\modules\\linear.py:114\u001b[0m, in \u001b[0;36mLinear.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m--> 114\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mRuntimeError\u001b[0m: mat1 and mat2 shapes cannot be multiplied (1x27 and 28x512)" + ] + } + ], + "source": [ + "\n", + "algorithm.playTrainedAgent(adv,100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/PGM_base/previous files/test.py b/learningAgents/naive_policy_gradient/PGM_base/previous files/test.py new file mode 100644 index 0000000..3e5d22d --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/previous files/test.py @@ -0,0 +1,30 @@ +from learningBase import ReinforceAlgorithm +import environmentModelBase as model +from neuralNetworkSimple import NNBase +import torch +import torch.nn as nn +from torch.distributions import Categorical +import numpy as np +import matplotlib.pyplot as plt + +const95= model.Strategy(model.StrategyType.static, model.const,"const95", firstPrice=95 ) +actionStep=3 +adv= model.MixedStrategy() +adv._strategies.append(const95) +adv._strategyProbs=torch.ones(1) +game = model.Model(totalDemand = 400, + tupleCosts = (57, 71), + totalStages = 25, adversary=adv, stateAdvHistory=1) + +hyperParams=[0.0001, 1, 0] +codeParams=[1, 10000, 1, 1] + +neuralNet=NNBase(num_input=game.T+2+game.stateAdvHistory, lr=hyperParams[0],num_actions=18,action_step=actionStep, adv_hist=game.stateAdvHistory) +algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=2, numberEpisodes=3_000_000, discountFactor =hyperParams[1]) + + +# algorithm.solver(print_step=100_000,options=codeParams,converge_break=True) +algorithm.loadPolicyNet("1,3,[5e-06,1][1, 10000, 1, 1],1683196677") +returns=algorithm.playTrainedAgent(adv,100) +print(returns) +print(np.mean(np.array(returns),axis=1)) \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/PGM_base/randomstart.py b/learningAgents/naive_policy_gradient/PGM_base/randomstart.py new file mode 100644 index 0000000..460e3eb --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/randomstart.py @@ -0,0 +1,114 @@ +#!/usr/bin/python + +import random +import math +import fractions +import matplotlib.pyplot as plt +import sys + +# give random n-tuple uniformly from unit simplex +def randInSimplex(n, naive=False): + x = [0.0]*n + if naive: # random numbers re-normalized + sum = 0 + for i in range(n): + x[i] = random.uniform(0, 1) + sum += x[i] + return [k/sum for k in x] + + else: # properly uniformly in simplex + factor = 1.0 + i = n-1 + while i>0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/naive_policy_gradient/PGM_base/results - Copy.xlsx b/learningAgents/naive_policy_gradient/PGM_base/results - Copy.xlsx new file mode 100644 index 0000000..cee412e Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/results - Copy.xlsx differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/results.xlsx b/learningAgents/naive_policy_gradient/PGM_base/results.xlsx new file mode 100644 index 0000000..09c92fe Binary files /dev/null and b/learningAgents/naive_policy_gradient/PGM_base/results.xlsx differ diff --git a/learningAgents/naive_policy_gradient/PGM_base/utils.py b/learningAgents/naive_policy_gradient/PGM_base/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/naive_policy_gradient/PGM_base/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/naive_policy_gradient/Results.ipynb b/learningAgents/naive_policy_gradient/Results.ipynb new file mode 100644 index 0000000..0e7a7d2 --- /dev/null +++ b/learningAgents/naive_policy_gradient/Results.ipynb @@ -0,0 +1,208 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def NeuralNetwork():\n", + " lr = .003\n", + " num_actions = 20\n", + "\n", + " nn_ = 100\n", + "\n", + " policy = nn.Sequential(\n", + " nn.Linear(2, nn_), \n", + " nn.ReLU(),\n", + " nn.Linear(nn_,nn_),\n", + " nn.ReLU(),\n", + " nn.Linear(nn_,num_actions), \n", + " nn.Softmax(dim=0))\n", + " optim = torch.optim.Adam(policy.parameters(), lr=lr)\n", + "\n", + " return policy, optim" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "nrows=6\n", + "dataset = dict()\n", + "for mode in AdversaryModes:\n", + " game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25,\n", + " initState = [400/2,0], adversaryMode=mode)\n", + " algorithm = ReinforceAlgorithm(game, NeuralNetwork, numberIterations=50, numberEpisodes=10, discountFactor =0.5)\n", + " algorithm.solver()\n", + " profits = pd.DataFrame(game.profit).T\n", + " profits.columns = [\"learning Agent\", \"Adversary\"]\n", + " prices = pd.DataFrame(game.prices).T\n", + " prices.columns = [\"learning Agent\", \"Adversary\"] \n", + " demandPotential = pd.DataFrame(game.demandPotential).T\n", + " demandPotential.columns = [\"learning Agent\", \"Adversary\"]\n", + " \n", + " learning = pd.DataFrame(algorithm.returns.mean(axis = 0))\n", + " learning.columns=['average']\n", + "\n", + " dataset[f\"{mode.name}\"] = (learning, demandPotential, prices, profits)\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=nrows, ncols=2,sharex=True,sharey=True,figsize=(15,25))\n", + "for mode in AdversaryModes:\n", + " ax=dataset[mode.name][0].plot(color='r', title=f\"Learning Curve against {mode.name}\", ax=axes[mode.value%nrows][int(mode.value/nrows)])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=nrows, ncols=2,sharex=True,sharey=True,figsize=(20,30))\n", + "for mode in AdversaryModes:\n", + " ax=dataset[mode.name][1].plot(title=f\"Demand Potential Best Game against {mode.name}\", ax=axes[mode.value%nrows][int(mode.value/nrows)])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=nrows, ncols=2,sharex=True,sharey=True,figsize=(20,30))\n", + "for mode in AdversaryModes:\n", + " ax=dataset[mode.name][2].plot(title=f\"Prices Best Game against {mode.name}\", ax=axes[mode.value%nrows][int(mode.value/nrows)])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=nrows, ncols=2,sharex=True,sharey=True,figsize=(20,30))\n", + "for mode in AdversaryModes:\n", + " ax=dataset[mode.name][3].plot(title=f\"Profits Best Game against {mode.name}\", ax=axes[mode.value%nrows][int(mode.value/nrows)])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/checkTrainedAgent.ipynb b/learningAgents/naive_policy_gradient/checkTrainedAgent.ipynb new file mode 100644 index 0000000..c286aae --- /dev/null +++ b/learningAgents/naive_policy_gradient/checkTrainedAgent.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "795ca121", + "metadata": {}, + "outputs": [], + "source": [ + "from NeuralNetwork import NeuralNetwork\n", + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "import torch\n", + "import torch.nn as nn" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c8130ed9", + "metadata": {}, + "outputs": [], + "source": [ + "histNum=0\n", + "NN=NeuralNetwork(num_input=3+histNum)\n", + "NN.reset()\n", + "NN.load(\"nn ep 10^6 myopic, no adv history\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bf3dfe5f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "episode 0 return= 169386.8918878434 \n", + "\t actions: tensor([37, 37, 37, 22, 19, 2, 34, 34, 20, 38, 31, 35, 22, 20, 9, 24, 44, 25,\n", + " 27, 41, 35, 44, 13, 12, 40])\n", + "episode 1 return= 164839.54153217268 \n", + "\t actions: tensor([ 3, 22, 21, 45, 8, 42, 5, 13, 31, 44, 30, 10, 46, 37, 28, 27, 18, 8,\n", + " 0, 44, 40, 37, 24, 9, 42])\n", + "episode 2 return= 161177.47756998372 \n", + "\t actions: tensor([23, 1, 19, 31, 2, 45, 7, 35, 3, 32, 6, 0, 30, 43, 0, 40, 33, 25,\n", + " 34, 4, 10, 44, 2, 42, 8])\n", + "episode 3 return= 165658.17857914575 \n", + "\t actions: tensor([23, 21, 17, 36, 39, 14, 20, 12, 31, 0, 26, 39, 23, 23, 12, 32, 48, 44,\n", + " 36, 9, 34, 6, 32, 26, 48])\n", + "episode 4 return= 160802.0583981938 \n", + "\t actions: tensor([12, 7, 14, 40, 16, 0, 24, 49, 37, 10, 0, 24, 7, 41, 24, 3, 7, 21,\n", + " 17, 40, 22, 47, 19, 27, 44])\n", + "episode 5 return= 169039.7197454831 \n", + "\t actions: tensor([49, 31, 29, 46, 39, 31, 24, 40, 41, 49, 2, 15, 10, 30, 17, 29, 32, 8,\n", + " 22, 27, 2, 34, 38, 39, 8])\n", + "episode 6 return= 168389.07469979284 \n", + "\t actions: tensor([19, 35, 10, 48, 5, 46, 30, 23, 48, 27, 34, 18, 46, 3, 45, 18, 15, 47,\n", + " 8, 47, 16, 29, 34, 13, 15])\n", + "episode 7 return= 165056.24227238077 \n", + "\t actions: tensor([11, 3, 39, 15, 27, 44, 25, 8, 27, 44, 43, 22, 36, 27, 0, 35, 46, 5,\n", + " 6, 36, 27, 44, 34, 39, 45])\n", + "episode 8 return= 164847.96428064632 \n", + "\t actions: tensor([23, 40, 19, 41, 14, 11, 5, 27, 25, 48, 1, 4, 36, 13, 18, 32, 9, 9,\n", + " 47, 25, 16, 48, 24, 10, 2])\n", + "episode 9 return= 169530.17140838344 \n", + "\t actions: tensor([29, 39, 9, 23, 44, 27, 38, 29, 1, 10, 36, 35, 15, 23, 24, 30, 25, 24,\n", + " 18, 35, 32, 25, 21, 17, 0])\n", + "episode 10 return= 165153.95256093607 \n", + "\t actions: tensor([30, 33, 47, 27, 12, 12, 29, 49, 16, 3, 14, 46, 19, 3, 44, 34, 45, 4,\n", + " 49, 15, 26, 30, 16, 2, 43])\n", + "episode 11 return= 168383.4740371766 \n", + "\t actions: tensor([29, 26, 39, 34, 40, 27, 43, 20, 38, 21, 49, 46, 14, 36, 48, 21, 21, 19,\n", + " 6, 30, 6, 8, 26, 41, 43])\n", + "episode 12 return= 158984.9854297206 \n", + "\t actions: tensor([ 1, 8, 10, 42, 16, 28, 33, 1, 5, 19, 18, 30, 24, 18, 9, 49, 22, 2,\n", + " 40, 8, 44, 19, 2, 49, 48])\n", + "episode 13 return= 165006.16131014816 \n", + "\t actions: tensor([11, 5, 24, 7, 41, 26, 3, 40, 6, 40, 39, 0, 15, 6, 45, 21, 46, 37,\n", + " 40, 39, 16, 27, 20, 26, 26])\n", + "episode 14 return= 165959.0256838448 \n", + "\t actions: tensor([38, 42, 34, 44, 7, 26, 0, 26, 49, 32, 24, 30, 30, 43, 24, 3, 48, 14,\n", + " 25, 23, 27, 0, 14, 29, 47])\n", + "episode 15 return= 168624.1210249968 \n", + "\t actions: tensor([43, 24, 41, 32, 17, 39, 40, 20, 20, 36, 24, 32, 4, 14, 32, 36, 23, 10,\n", + " 47, 23, 19, 22, 27, 34, 39])\n", + "episode 16 return= 166441.84226610296 \n", + "\t actions: tensor([11, 25, 29, 33, 27, 18, 28, 39, 17, 27, 31, 9, 31, 42, 22, 0, 16, 9,\n", + " 26, 30, 6, 34, 20, 20, 27])\n", + "episode 17 return= 169120.81046257267 \n", + "\t actions: tensor([41, 44, 17, 40, 14, 21, 48, 11, 12, 15, 38, 48, 37, 46, 44, 27, 34, 42,\n", + " 2, 28, 27, 46, 2, 49, 22])\n", + "episode 18 return= 166918.58718593846 \n", + "\t actions: tensor([13, 12, 27, 11, 46, 34, 25, 32, 43, 28, 26, 39, 42, 4, 7, 18, 29, 46,\n", + " 4, 22, 2, 46, 35, 29, 16])\n", + "episode 19 return= 166880.41683537795 \n", + "\t actions: tensor([43, 34, 9, 17, 43, 26, 33, 9, 3, 3, 27, 40, 11, 18, 27, 10, 33, 25,\n", + " 41, 29, 38, 28, 34, 16, 27])\n", + "episode 20 return= 165901.5994213447 \n", + "\t actions: tensor([ 5, 20, 28, 27, 43, 2, 26, 43, 25, 48, 27, 0, 41, 28, 5, 34, 27, 27,\n", + " 27, 7, 21, 22, 19, 40, 27])\n", + "episode 21 return= 161025.75145414303 \n", + "\t actions: tensor([29, 17, 28, 5, 21, 4, 3, 32, 44, 2, 15, 27, 17, 45, 6, 44, 44, 23,\n", + " 0, 1, 31, 34, 13, 24, 44])\n", + "episode 22 return= 166259.30519555334 \n", + "\t actions: tensor([12, 0, 38, 10, 37, 16, 18, 22, 19, 32, 18, 17, 6, 46, 28, 32, 22, 20,\n", + " 4, 37, 34, 44, 29, 22, 8])\n", + "episode 23 return= 165941.82203621938 \n", + "\t actions: tensor([42, 13, 32, 35, 7, 16, 39, 2, 12, 1, 26, 41, 29, 30, 3, 39, 17, 47,\n", + " 38, 27, 37, 23, 27, 14, 36])\n", + "episode 24 return= 166536.89155923386 \n", + "\t actions: tensor([25, 37, 34, 41, 16, 49, 19, 15, 42, 6, 2, 19, 42, 0, 31, 6, 49, 47,\n", + " 35, 45, 0, 27, 45, 24, 19])\n", + "episode 25 return= 166221.716781765 \n", + "\t actions: tensor([48, 40, 16, 15, 7, 48, 24, 16, 12, 26, 24, 33, 24, 36, 27, 26, 15, 34,\n", + " 45, 2, 48, 2, 8, 5, 27])\n", + "episode 26 return= 165778.6689029038 \n", + "\t actions: tensor([ 1, 19, 8, 37, 34, 42, 13, 7, 27, 44, 40, 19, 27, 41, 22, 8, 13, 35,\n", + " 9, 12, 30, 8, 24, 20, 1])\n", + "episode 27 return= 165835.8901612138 \n", + "\t actions: tensor([27, 31, 18, 39, 36, 4, 16, 10, 12, 10, 29, 27, 28, 41, 10, 26, 41, 3,\n", + " 28, 32, 8, 26, 41, 2, 17])\n", + "episode 28 return= 161744.70368415464 \n", + "\t actions: tensor([41, 15, 1, 40, 19, 10, 40, 16, 2, 21, 4, 10, 16, 22, 20, 27, 44, 49,\n", + " 0, 39, 1, 22, 8, 47, 1])\n", + "episode 29 return= 165452.04174670804 \n", + "\t actions: tensor([28, 37, 3, 46, 26, 34, 38, 21, 41, 12, 4, 41, 8, 38, 15, 28, 19, 8,\n", + " 8, 36, 0, 47, 22, 30, 20])\n", + "episode 30 return= 166134.1684023132 \n", + "\t actions: tensor([18, 1, 49, 17, 39, 24, 34, 7, 32, 8, 31, 19, 15, 31, 22, 34, 17, 24,\n", + " 44, 40, 21, 24, 26, 36, 44])\n", + "episode 31 return= 160902.68958961384 \n", + "\t actions: tensor([ 0, 24, 31, 10, 39, 17, 2, 4, 39, 1, 38, 33, 16, 1, 38, 27, 43, 26,\n", + " 0, 47, 49, 17, 4, 1, 42])\n", + "episode 32 return= 166341.1750212098 \n", + "\t actions: tensor([44, 19, 2, 29, 32, 46, 49, 40, 27, 32, 47, 4, 5, 48, 15, 42, 28, 24,\n", + " 0, 11, 20, 3, 38, 0, 1])\n", + "episode 33 return= 165724.10930982477 \n", + "\t actions: tensor([29, 5, 28, 36, 32, 39, 25, 28, 47, 2, 1, 48, 8, 34, 33, 26, 3, 36,\n", + " 29, 32, 18, 8, 4, 2, 20])\n", + "episode 34 return= 163962.36846642688 \n", + "\t actions: tensor([ 7, 8, 18, 14, 24, 12, 10, 41, 24, 0, 5, 45, 30, 26, 27, 20, 47, 24,\n", + " 18, 25, 25, 8, 27, 46, 13])\n", + "episode 35 return= 163580.23567852014 \n", + "\t actions: tensor([36, 33, 47, 45, 16, 15, 23, 13, 18, 10, 13, 0, 27, 48, 21, 27, 8, 24,\n", + " 24, 44, 13, 14, 2, 23, 46])\n", + "episode 36 return= 164552.53188529727 \n", + "\t actions: tensor([39, 5, 19, 9, 22, 26, 16, 48, 41, 48, 24, 16, 8, 19, 6, 48, 8, 23,\n", + " 4, 24, 42, 18, 13, 47, 5])\n", + "episode 37 return= 161245.79641049792 \n", + "\t actions: tensor([21, 4, 49, 47, 1, 36, 4, 4, 13, 29, 1, 11, 26, 45, 11, 34, 45, 8,\n", + " 0, 38, 39, 34, 1, 46, 20])\n", + "episode 38 return= 165398.91839047556 \n", + "\t actions: tensor([26, 32, 21, 34, 13, 40, 38, 6, 21, 0, 42, 43, 30, 19, 21, 12, 19, 27,\n", + " 17, 19, 5, 22, 0, 44, 2])\n", + "episode 39 return= 161814.52074461503 \n", + "\t actions: tensor([22, 4, 27, 33, 30, 7, 43, 1, 37, 34, 11, 18, 44, 9, 49, 4, 30, 22,\n", + " 4, 21, 41, 19, 0, 36, 48])\n", + "episode 40 return= 163126.14535941504 \n", + "\t actions: tensor([ 1, 37, 2, 8, 21, 37, 32, 1, 19, 8, 21, 43, 18, 6, 27, 45, 40, 2,\n", + " 18, 16, 22, 38, 29, 41, 1])\n", + "episode 41 return= 161017.4597418679 \n", + "\t actions: tensor([16, 12, 42, 0, 18, 5, 1, 25, 28, 19, 25, 1, 29, 27, 47, 8, 2, 20,\n", + " 36, 15, 24, 29, 5, 4, 27])\n", + "episode 42 return= 170579.90143677822 \n", + "\t actions: tensor([49, 34, 18, 0, 24, 49, 10, 36, 30, 37, 45, 32, 40, 8, 30, 46, 17, 30,\n", + " 48, 30, 45, 46, 21, 35, 28])\n", + "episode 43 return= 168356.8350279185 \n", + "\t actions: tensor([29, 8, 1, 26, 24, 48, 26, 27, 48, 34, 18, 6, 27, 40, 27, 27, 34, 24,\n", + " 8, 37, 27, 27, 28, 29, 27])\n", + "episode 44 return= 163051.54788903418 \n", + "\t actions: tensor([12, 10, 3, 47, 5, 32, 41, 41, 48, 32, 6, 3, 1, 37, 26, 18, 9, 32,\n", + " 43, 27, 26, 27, 20, 36, 48])\n", + "episode 45 return= 167295.86547050948 \n", + "\t actions: tensor([38, 2, 41, 34, 38, 46, 48, 5, 39, 49, 45, 22, 32, 27, 43, 3, 11, 27,\n", + " 18, 24, 27, 11, 9, 19, 44])\n", + "episode 46 return= 165487.6488424664 \n", + "\t actions: tensor([40, 19, 21, 48, 46, 13, 44, 27, 4, 33, 28, 5, 11, 16, 21, 18, 32, 33,\n", + " 2, 7, 43, 22, 27, 0, 24])\n", + "episode 47 return= 167513.63369738663 \n", + "\t actions: tensor([24, 32, 8, 20, 40, 19, 45, 22, 28, 27, 39, 48, 44, 41, 19, 30, 8, 1,\n", + " 29, 8, 27, 7, 13, 40, 19])\n", + "episode 48 return= 159518.80621623588 \n", + "\t actions: tensor([38, 1, 4, 10, 21, 22, 15, 1, 17, 8, 8, 13, 43, 22, 49, 6, 7, 44,\n", + " 17, 8, 16, 32, 33, 24, 38])\n", + "episode 49 return= 163187.06281349462 \n", + "\t actions: tensor([15, 20, 33, 34, 19, 15, 1, 26, 32, 33, 22, 19, 9, 19, 38, 0, 21, 31,\n", + " 42, 3, 41, 4, 41, 5, 41])\n", + "episode 50 return= 167202.841494803 \n", + "\t actions: tensor([47, 22, 33, 2, 26, 21, 27, 48, 0, 40, 46, 32, 46, 19, 25, 26, 21, 48,\n", + " 14, 0, 39, 27, 18, 45, 27])\n", + "episode 51 return= 166790.48794049132 \n", + "\t actions: tensor([44, 27, 30, 32, 16, 31, 20, 21, 12, 19, 49, 40, 33, 47, 33, 17, 18, 29,\n", + " 4, 1, 3, 24, 44, 2, 26])\n", + "episode 52 return= 169476.8123487167 \n", + "\t actions: tensor([10, 1, 41, 22, 32, 19, 27, 24, 39, 48, 12, 48, 42, 35, 5, 48, 39, 30,\n", + " 27, 34, 30, 5, 30, 22, 18])\n", + "episode 53 return= 167469.0696572619 \n", + "\t actions: tensor([33, 27, 16, 12, 21, 35, 48, 7, 19, 34, 5, 38, 45, 19, 40, 9, 43, 8,\n", + " 14, 43, 40, 26, 44, 46, 16])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "episode 54 return= 167970.2619801976 \n", + "\t actions: tensor([ 1, 21, 11, 28, 12, 23, 36, 47, 33, 26, 0, 19, 49, 47, 26, 41, 22, 45,\n", + " 29, 26, 26, 29, 34, 32, 37])\n", + "episode 55 return= 163088.9265332977 \n", + "\t actions: tensor([21, 13, 17, 19, 1, 49, 0, 21, 21, 48, 49, 46, 49, 0, 2, 6, 29, 29,\n", + " 4, 20, 35, 25, 14, 2, 8])\n", + "episode 56 return= 171896.4977866335 \n", + "\t actions: tensor([45, 36, 44, 39, 0, 16, 31, 19, 19, 26, 20, 47, 24, 38, 46, 37, 33, 32,\n", + " 25, 41, 31, 34, 28, 27, 27])\n", + "episode 57 return= 169818.11817029744 \n", + "\t actions: tensor([34, 19, 17, 31, 39, 22, 46, 39, 19, 15, 29, 26, 12, 47, 46, 24, 24, 38,\n", + " 46, 14, 0, 38, 10, 27, 10])\n", + "episode 58 return= 164052.25235974113 \n", + "\t actions: tensor([ 7, 8, 10, 10, 0, 5, 10, 41, 34, 40, 28, 39, 37, 43, 22, 37, 22, 35,\n", + " 2, 2, 47, 20, 21, 39, 19])\n", + "episode 59 return= 162987.7610045157 \n", + "\t actions: tensor([ 4, 30, 28, 27, 19, 32, 42, 2, 27, 25, 27, 2, 2, 46, 28, 7, 27, 27,\n", + " 35, 21, 12, 7, 40, 22, 47])\n", + "episode 60 return= 165656.53120072477 \n", + "\t actions: tensor([36, 47, 49, 34, 44, 36, 42, 9, 10, 25, 38, 29, 1, 4, 45, 41, 43, 27,\n", + " 17, 0, 1, 42, 31, 35, 48])\n", + "episode 61 return= 167970.61334594726 \n", + "\t actions: tensor([29, 29, 35, 2, 33, 44, 14, 21, 28, 25, 17, 14, 14, 10, 27, 22, 41, 47,\n", + " 35, 27, 19, 24, 48, 44, 21])\n", + "episode 62 return= 165514.4554778867 \n", + "\t actions: tensor([38, 23, 26, 43, 2, 24, 25, 38, 31, 31, 34, 22, 27, 27, 45, 8, 32, 6,\n", + " 1, 47, 40, 22, 0, 41, 47])\n", + "episode 63 return= 165791.34505114512 \n", + "\t actions: tensor([17, 36, 27, 8, 37, 49, 7, 36, 7, 14, 31, 46, 34, 29, 48, 10, 16, 6,\n", + " 5, 25, 11, 34, 41, 6, 19])\n", + "episode 64 return= 166674.31997452362 \n", + "\t actions: tensor([32, 29, 27, 42, 24, 11, 29, 38, 31, 27, 17, 9, 8, 29, 4, 36, 11, 5,\n", + " 34, 40, 15, 34, 46, 49, 12])\n", + "episode 65 return= 163435.3191843775 \n", + "\t actions: tensor([27, 34, 6, 39, 5, 11, 15, 34, 45, 8, 7, 31, 23, 44, 27, 5, 49, 17,\n", + " 19, 37, 19, 42, 0, 29, 46])\n", + "episode 66 return= 166792.67774757915 \n", + "\t actions: tensor([34, 38, 8, 16, 25, 33, 22, 0, 22, 22, 30, 16, 40, 26, 46, 46, 22, 26,\n", + " 4, 34, 19, 10, 20, 8, 28])\n", + "episode 67 return= 160916.27949397627 \n", + "\t actions: tensor([ 8, 23, 29, 2, 14, 29, 3, 15, 10, 4, 18, 45, 32, 2, 31, 26, 11, 14,\n", + " 40, 27, 18, 32, 42, 44, 44])\n", + "episode 68 return= 164805.16529967796 \n", + "\t actions: tensor([21, 32, 25, 12, 24, 33, 2, 1, 48, 41, 35, 36, 2, 30, 29, 25, 2, 42,\n", + " 7, 38, 27, 24, 8, 11, 34])\n", + "episode 69 return= 166505.6308661023 \n", + "\t actions: tensor([17, 20, 44, 5, 18, 22, 38, 36, 30, 33, 9, 8, 19, 19, 34, 9, 34, 32,\n", + " 9, 41, 44, 18, 26, 39, 30])\n", + "episode 70 return= 163197.6121019429 \n", + "\t actions: tensor([13, 41, 22, 40, 6, 7, 0, 2, 38, 27, 46, 14, 22, 6, 14, 19, 49, 26,\n", + " 33, 34, 18, 25, 19, 27, 44])\n", + "episode 71 return= 166879.60778979704 \n", + "\t actions: tensor([49, 47, 7, 34, 10, 27, 41, 5, 11, 48, 41, 28, 43, 14, 39, 37, 30, 8,\n", + " 30, 39, 21, 8, 40, 41, 43])\n", + "episode 72 return= 166610.45380175402 \n", + "\t actions: tensor([39, 27, 6, 29, 31, 18, 24, 6, 28, 10, 30, 24, 47, 40, 48, 14, 15, 13,\n", + " 2, 22, 32, 27, 31, 6, 22])\n", + "episode 73 return= 164247.48767353516 \n", + "\t actions: tensor([ 0, 30, 4, 34, 18, 27, 17, 6, 41, 41, 47, 9, 22, 12, 19, 13, 41, 41,\n", + " 41, 27, 2, 11, 15, 44, 21])\n", + "episode 74 return= 157912.7812067199 \n", + "\t actions: tensor([ 6, 41, 26, 42, 8, 0, 16, 6, 9, 7, 42, 15, 33, 5, 20, 0, 3, 30,\n", + " 18, 8, 1, 21, 3, 32, 19])\n", + "episode 75 return= 162625.11244844357 \n", + "\t actions: tensor([11, 29, 8, 27, 46, 8, 34, 2, 49, 19, 7, 3, 32, 1, 18, 30, 24, 41,\n", + " 10, 8, 19, 46, 42, 1, 16])\n", + "episode 76 return= 165018.43135610898 \n", + "\t actions: tensor([29, 25, 36, 7, 17, 13, 23, 27, 1, 41, 40, 4, 21, 39, 9, 24, 38, 43,\n", + " 47, 20, 17, 8, 2, 20, 32])\n", + "episode 77 return= 164214.43424599763 \n", + "\t actions: tensor([27, 25, 24, 9, 30, 40, 39, 27, 8, 44, 9, 22, 0, 11, 44, 33, 20, 10,\n", + " 16, 13, 42, 39, 1, 30, 39])\n", + "episode 78 return= 162413.96670515902 \n", + "\t actions: tensor([47, 0, 3, 29, 19, 0, 32, 35, 18, 9, 15, 27, 6, 38, 24, 19, 43, 49,\n", + " 4, 10, 27, 37, 15, 10, 36])\n", + "episode 79 return= 166820.6584486897 \n", + "\t actions: tensor([39, 42, 3, 14, 1, 8, 25, 21, 8, 3, 29, 37, 44, 48, 48, 4, 41, 43,\n", + " 37, 31, 27, 42, 19, 34, 18])\n", + "episode 80 return= 165459.50259754332 \n", + "\t actions: tensor([24, 41, 5, 40, 41, 11, 22, 49, 6, 13, 28, 27, 47, 24, 16, 6, 29, 48,\n", + " 18, 37, 34, 14, 8, 36, 45])\n", + "episode 81 return= 168427.120888105 \n", + "\t actions: tensor([27, 8, 41, 36, 44, 21, 39, 8, 36, 34, 41, 2, 24, 30, 9, 26, 27, 25,\n", + " 19, 17, 26, 41, 15, 43, 10])\n", + "episode 82 return= 168771.43859613518 \n", + "\t actions: tensor([42, 18, 1, 28, 48, 41, 30, 25, 34, 28, 32, 40, 12, 11, 36, 45, 19, 45,\n", + " 45, 27, 1, 0, 34, 35, 13])\n", + "episode 83 return= 167604.9322225316 \n", + "\t actions: tensor([19, 12, 39, 27, 19, 39, 43, 18, 8, 43, 8, 24, 1, 37, 14, 3, 31, 44,\n", + " 39, 20, 38, 39, 29, 14, 0])\n", + "episode 84 return= 164241.52766806568 \n", + "\t actions: tensor([ 2, 18, 5, 45, 22, 28, 19, 40, 21, 32, 46, 19, 8, 40, 45, 40, 10, 15,\n", + " 16, 22, 6, 0, 41, 46, 26])\n", + "episode 85 return= 165676.17239143344 \n", + "\t actions: tensor([ 5, 17, 24, 27, 14, 2, 7, 25, 2, 47, 21, 22, 22, 17, 34, 30, 46, 11,\n", + " 40, 48, 29, 24, 33, 47, 2])\n", + "episode 86 return= 169283.66705681995 \n", + "\t actions: tensor([25, 8, 41, 42, 31, 21, 19, 13, 42, 10, 47, 14, 38, 40, 8, 13, 47, 21,\n", + " 41, 47, 24, 38, 29, 38, 19])\n", + "episode 87 return= 166654.2009670567 \n", + "\t actions: tensor([39, 20, 2, 48, 17, 19, 20, 8, 23, 46, 26, 12, 25, 26, 41, 49, 28, 35,\n", + " 19, 27, 1, 8, 45, 23, 21])\n", + "episode 88 return= 161324.87541378115 \n", + "\t actions: tensor([11, 0, 1, 44, 17, 18, 12, 48, 22, 16, 22, 3, 19, 42, 27, 14, 32, 12,\n", + " 7, 15, 39, 28, 8, 32, 38])\n", + "episode 89 return= 167738.91312220925 \n", + "\t actions: tensor([21, 23, 11, 0, 16, 19, 24, 45, 10, 14, 25, 41, 32, 47, 45, 41, 26, 34,\n", + " 8, 6, 41, 48, 22, 17, 1])\n", + "episode 90 return= 165381.5683560383 \n", + "\t actions: tensor([19, 10, 24, 26, 2, 5, 43, 24, 19, 19, 2, 1, 44, 37, 41, 24, 34, 37,\n", + " 17, 29, 20, 15, 25, 19, 17])\n", + "episode 91 return= 170355.26949328868 \n", + "\t actions: tensor([23, 24, 28, 23, 49, 28, 1, 24, 26, 47, 14, 43, 49, 46, 34, 28, 49, 18,\n", + " 27, 44, 24, 26, 47, 15, 39])\n", + "episode 92 return= 166652.06475625298 \n", + "\t actions: tensor([44, 26, 33, 41, 20, 7, 3, 30, 17, 24, 45, 15, 29, 42, 32, 22, 0, 48,\n", + " 46, 18, 46, 35, 34, 49, 45])\n", + "episode 93 return= 170810.0014353296 \n", + "\t actions: tensor([36, 9, 27, 37, 27, 38, 45, 0, 14, 37, 25, 30, 30, 44, 47, 49, 29, 18,\n", + " 32, 23, 22, 48, 32, 33, 27])\n", + "episode 94 return= 166385.71006609857 \n", + "\t actions: tensor([38, 48, 19, 32, 24, 35, 16, 35, 32, 33, 48, 20, 42, 8, 4, 15, 49, 7,\n", + " 1, 19, 34, 43, 18, 36, 41])\n", + "episode 95 return= 166868.5562205318 \n", + "\t actions: tensor([24, 7, 37, 31, 29, 45, 17, 23, 5, 6, 31, 45, 46, 26, 14, 24, 21, 23,\n", + " 18, 25, 12, 18, 11, 32, 19])\n", + "episode 96 return= 161888.27217745272 \n", + "\t actions: tensor([ 2, 7, 1, 24, 41, 6, 17, 46, 2, 38, 27, 26, 4, 20, 44, 37, 29, 8,\n", + " 46, 9, 3, 27, 2, 22, 16])\n", + "episode 97 return= 169287.1667429373 \n", + "\t actions: tensor([21, 41, 31, 35, 22, 13, 43, 20, 25, 34, 42, 13, 39, 22, 24, 31, 34, 33,\n", + " 8, 18, 47, 42, 43, 7, 44])\n", + "episode 98 return= 165693.60964888192 \n", + "\t actions: tensor([ 1, 19, 21, 0, 30, 18, 11, 37, 12, 9, 48, 24, 22, 11, 48, 37, 22, 42,\n", + " 30, 41, 9, 46, 39, 19, 25])\n", + "episode 99 return= 161338.30958955246 \n", + "\t actions: tensor([43, 2, 34, 31, 16, 21, 39, 19, 15, 23, 23, 11, 29, 12, 41, 3, 5, 5,\n", + " 2, 3, 47, 10, 44, 9, 28])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABrzElEQVR4nO29eZxlZ13n//7e/d7au7t6SXdn7yRkA5KQRAWBRBLEJaigMINkHJwgo6iDGzjjREEcYVBmGJURIbI4vxBegJABIWSMLGJM0gkhe0hn7/RW3VVd2627P78/zvOce+6555y7V92qet6vV72669z11D33+T7f7+e7iFIKi8VisVjCiK31G7BYLBbLcGMNhcVisVgisYbCYrFYLJFYQ2GxWCyWSKyhsFgsFkskibV+A/1m27Zt6vTTT1/rt2GxWCzrinvvvfe4Umo66LYNZyhOP/109u/fv9Zvw2KxWNYVIvJs2G029GSxWCyWSKyhsFgsFksk1lBYLBaLJRJrKCwWi8USSUtDISI3icgxEXnIc+wWEblf/zwjIvfr468RkXtF5EH971Wex1yqjx8QkY+IiOjjaf18B0TkLhE53fOY60XkCf1zfT9P3GKxWCzt0Y5H8Ungtd4DSqlfUEq9RCn1EuALwBf1TceBn1JKXQRcD3zG87CPAjcA+/SPec63AXNKqbOBDwMfABCRLcCNwBXA5cCNIjLV4flZLBaLpUdaGgql1LeB2aDbtFfw88DN+r7fU0od0jc/DGS0x7ALGFdK3amcdrWfBl6v73cd8Cn9/88DV+vnvRa4XSk1q5SaA27HZ7AsFovFMnh61SheARxVSj0RcNvPAd9TShWB3cBBz20H9TH0v88DKKUqwDyw1Xs84DENiMgNIrJfRPbPzMz0cDoWy/rhWz+Y4dkTy2v9NiybgF4NxZvR3oQXEbkAJ4T0dnMo4LGqxW1Rj2k8qNTHlFKXKaUum54OLCy0WDYc77rlfj76zSfX+m1YNgFdGwoRSQA/C9ziO74H+HvgrUopcxUfBPZ47rYHOOS5ba/nOSdwQl3u8YDHWCybnpVylUPzhbV+G5ZNQC8exY8Bjyml3JCSiEwCXwXeo5T6rjmulDoMLIrIlVp/eCvwZX3zrTjCN8AbgDu0jnEbcI2ITGkR+xp9zGKxAOVqjWML1lBYBk876bE3A3cC54rIQRF5m77pTTSHnX4NOBv4A0/67HZ92zuAjwMHgCeBr+njnwC2isgB4F3AuwGUUrPA+4B79M979TGLZdOjlKJcVRyxhsKyCrRsCqiUenPI8X8XcOyPgT8Ouf9+4MKA4wXgjSGPuQm4qdV7tFg2G6VqDYCT+TKFcpVMMr7G78iykbGV2RbLOqRcred1HLVehWXAWENhsaxDypWa+/8jVtC2DBhrKCyWdYgJPQEcXSyu4TuxbAasobBY1iElj0dx1HoUlgFjDYXFsg4pezwKm/lkGTTWUFgs65CSNRSWVcQaCotlHVKueLKebOjJMmCsobBY1iHGo9gykuLoojUUlsFiDYXFsg4xYvbeqSxHF4o4XW8slsFgDYXFsg4xYvaeqRylSo25fHmN35GlW/Klylq/hZZYQ2GxrEOModi7JQfYorv1ytGFAi/5o9u566kTa/1WIrGGwmJZh7ihpy1ZwLbxWK8cOrlCqVrj2RP5tX4rkVhDYbGsQ4yYvXfK8SisoVifLBWdsNPykIefrKGwWDy88+bv8fWHDq/122iJaQq4e8rxKGwtxfpk2RiKojUUFsu64baHjvBPjw3/3HWjUYykEmwbTVmPYp2yWDAeRXWN30k01lBYLBqlFKVqjWProC7BaBTJuLBjPGPF7HWK9SgslnVGpeaEc46tg26sxqNIJmLsHM9wZGH43/Nm5sRSkf/89w9SKDd6DsaTWC5aj8JiWReYxXc9GAojZqfiMXZMZOzs7CHnX548wf+56zkePbzQcNwNPVmPwmJZH5j+SSeWilRrw13pXA89OR7FieUSxcpw70o3MyvaczCGwbC8UbKeROQmETkmIg95jt0iIvfrn2dE5H7Pbe8RkQMi8riIXOs5fqmIPKhv+4iIiD6e1s93QETuEpHTPY+5XkSe0D/X9+ukLZYgzC69phxjMcyUqzXiMSEeE3aMpwE4ZsNPQ4upvg41FBvAo/gk8FrvAaXULyilXqKUegnwBeCLACJyPvAm4AL9mL8SETP1/aPADcA+/WOe823AnFLqbODDwAf0c20BbgSuAC4HbhSRqa7O0mJpg0qt3rp72MNP5aoiFXe+vjvGM4CtpRhm8mXjUTS2Wll0DcVwe4MtDYVS6tvAbNBt2iv4eeBmfeg64LNKqaJS6mngAHC5iOwCxpVSdyqne9mngdd7HvMp/f/PA1fr570WuF0pNauUmgNux2ewLJZ+4m3dPeyZT6VKjWRcANg54RgKW0sxvGz40FMLXgEcVUo9oX/fDTzvuf2gPrZb/99/vOExSqkKMA9sjXiuJkTkBhHZLyL7Z2aGPwfeMpx4hwENexinVK2RSjhf352uRzHc73kzYzwGv0extIFCT1G8mbo3ASAB91ERx7t9TONBpT6mlLpMKXXZ9PR0xNu1WMLxjhcd+tBTpUZSh54msknSiZgNPQ0xK2XHECz4PIqljRJ6CkNEEsDPArd4Dh8E9np+3wMc0sf3BBxveIx+zgmcUFfYc1ksA6HRUAz3ouv1KEScojtrKIaXfIvQU6laczPZhpFePIofAx5TSnlDSrcCb9KZTGfgiNZ3K6UOA4sicqXWH94KfNnzGJPR9AbgDq1j3AZcIyJTWsS+Rh+zWAZCeR2FnsrVukcBMJJODP2udDNTNxS+0FOhQjwm+j7DG35qJz32ZuBO4FwROSgib9M3vYnGsBNKqYeBzwGPAF8HflUpZa7edwAfxxG4nwS+po9/AtgqIgeAdwHv1s81C7wPuEf/vFcfs1gGgmm0l4zL0IeeShXVYCiyyZitoxhigsTsWk2xXKoyPeqkNw9zv6dEqzsopd4ccvzfhRx/P/D+gOP7gQsDjheAN4Y8103ATa3eo8XSD4xHsWsiy8ywGwpP6Akgm4q7i5Fl+DBZTYvFukdhUmZ3jKc5slAYakHbVmavEd98/BhX/sk/2i/3EGEMxe5Jx1Cs9hzqRw4ttP2a5UqNVLye75FJxFkp22tpWAnyKJb0/7frrLUlayjWB8VKddUEpR8cXeTIQoHjQ14BvJkoVeozHkrVGidXcQ71I4cWeN1HvsOdT7Y3EtOvUWRS8aaGc5bhIUjMNobBVNbnh1hjsoZCc2yxwLn/5evcsv/51nfuA+bCGfZCm82E8Sj26GFAq6lTvHByBYCnTyy3df+m0FMyTqE8vFkzmx2vmG28RtdQjFmPYt0wknLkmvwqfViuoRjii2OzYVp47J40hmL10k1nlx2j1O5ciVLF51EkYzb0NGDue26Obz5+rKvHrugNYbmqKOqoxbLrUTiGot2sp//7/UPc99xcV++jW6yh0GSTTkuq1co8MBfJ0hC7m5sN08LDNRSrmCI7u+yEuQ63aSjK1Zrb6wmMR2GvpUHyF3cc4H1feaTjxymlyJerbBlJAbCgU2SNB7Fdh57a3TT+6dce46Z/frrj99EL1lBoYjEhl4qvukcxyNebWSwyv4px9vWOaeGxew1CT8ajaLdoLij0tFKurroAv5mYXylzYrnU8eMK5RpKwfYxxyAsrOhNYqHRo2h3k1qsVJsqvAeNNRQecqlE15pBraY6EsLrHsXgPvAbPrOf/3rrQ63vaAHqGsVENsloOrGqlc5mAWrbo6gotykgQDoZRyncsIal/ywWypzMl6lUO/sbm5CSMQim6M6sNdtG04i071EUy7Wmwr1BYw2Fh9F0vOvq1t/7wgP8u7+9u+37r4ZG8fzsCs8cb08ctXjGi8ZjbB9Lr2otxaw2FO1qFP6sJxM6LVpBe2AYT2A235lXYb7rO11D0TibYiyTYCSVaHvTWKzWWFixhmLNyKUSXZfRv3ByhX958gTPz+bbur/ZTQxKE6nVFHP50tBXGA8T9crsGNNj6VUVs+e0oVgqVtraLZYqzQV3gBW0B4j5XGY7DD+teArrnOepd4xNxIR0IsZIOt5WeqxSTuTC3zNq0FhD4WGkB4/ChJ2+9tDhtu5vLopBeRQLhTLVmmJmsUhtyMd6Dgt1j0LYPp5ZVSN7YrnkLvzthLxKPjE7k3T+bw3FYKhUa+6mbnapM0Ox7IrWvtBTscJIOoGIOB5FG5tUo6Mt2NDT2tGLR2EWma8+0J6hcD2KARkKE/OuaM/C0ppytUYiJogI28fSHFtYvers2eUS5+0cA9rTKcJCTzbzqX0ePbzQdqzfGxbqVNA2Vdk7/KGnYoXRtJOWP5JOtJXYYjSoQnl1u81aQ+FhNN1+nNCP+QC/f3C+rfCTiVsOKj12znMx24E27VGu1hvtbR9Ls1KurkoRVKFcJV+qcv6ucaC1oajWFDVFQ+gpk7Shp0546IV5fvJ//TN/9c0n27q/0Seg89CT+a5vG00h0uhR1A1Fe9EMr3FYTUHbGgoPuVTc/VA7pVSt8eI9EwD8w4OtvQrjufSjtfDRhULTTtK76xn22QrDgne8qMltX43wk1l4XqQNxdEWhsIsFo0Fd9qjsL3DWlKtKd7zxQep1hQPHpxv6zHeUE+nHoVp/jeWSTCaSriprcvFKiNp53NrV8wuNhiK1dMprKHw4PT07+6PX6rUOGt6lIv3TPDVFoaiWlNuu4Ved6xKKX78f36Hj337qYbjsw2GwnoU7VD21CZs120VVqPoznxWOycybB1JcbiFRlHyaCkGN/RkW4235JP/8gwPvjDPnqksjxxurxGjd1E+0WF/NlOVnU0lGMskGkNPmSSgQ0/taBQeQ7GaOoU1FB6MR9FNXNosMj9x0S4eaBF+8l4QvWoUS8UKs8slnvalwTYYCjv5rC0cjaIeeoLV8cbMDnXrSIod45mWKbJGD0sHhZ5KNj02ihdOrvBn33icV587zdtefgazy+1lBnoX5U5DTyaklEvGGcskfaEn7VGk422Fob0zR6xHsUaMpBNUaqqroiXTe+d1F+0CiPQqvOGtXqeSmYvWnylzYqnESCrOeCZhPYo2qVQVyYQOPWmPYjVqKYyeNDWSYtdEpqVGERR6ylqNoi3+65ceQil43+sv5IJTnFDxI4cWWj7OLMq7JjKdi9n6M8mm4g0exVKh4vaYG2kzkabBo1jFWgprKDyM6Fz0bnQKk9e+d0uOF++Z4OsPHQm9r/EiEjFpqgQ/tljgFz9xV4MYHYW5aP3GYC5fYmok5aR5WjG7LUqeTKLxbIJUIrYqRtbrUeycaD372lsYaMiknP/brKdwTuZL/ONjx/gPrziDPVM5ztvlZJk9cri1oTCL8ulbR7oQsyvExPEAxzIJd3jRcrHCaMYxFLl0gnyp2jKV3WoUQ0BOZyB0Ew7y9t45/5QJDs5FhZ6cL/P0WLrpte5/7iTfeeI4jx9dbOt1TU53k0exXGLrSMpJ87Ridlt4G+2JCNtGUpzoMGe+G2aXi8Rjwngmya6JDLPLpcgF3xiKoKwnayjCMQb5zOlRAMYzSU7dkmvLUJhF+bStua6ynkZSTr3EeDbJYqGCUoqlUj3ryYSgWrUQshrFEOC2Gu/Qo1BKUa4qd5GZyCaZXymHah1uAc5Yuin0NK93LuU2+8mYi3axUGmYlje7XGSLjnnb9Nj28KbHgrNxWI2Fd3a5xFQuSSwmbq59lFdRjAo92aynUMwgqslc0j32ol1jPNpG6GmhUCaXirN9PMNcvkS1gyLWlVLVrZw3oSdHC3XC3VD/t9Xa49UoVrMxYEtDISI3icgxEXnId/ydIvK4iDwsIh/Ux5Ii8ikReVBEHhWR93juf6k+fkBEPiIioo+nReQWffwuETnd85jrReQJ/XN93846hJy26p1mIpV8O7zxbIJyVYUOkvF6FKVqY+FMp4YiLA12dqnElpG027PIdhVtjVPE1phJ1I/05VbMLpfcFtS7JpzOtVE6hWk1kkrU32syHiMRE5v1FMFJXXg6lUu5x87fNcHTJ5ZbRhEWC2XGMgm2jqRQqv5c7bBcqpJzDYUjZpvXc+so9Ca11dozzBrFJ4HXeg+IyKuB64CLlVIXAB/SN70RSCulLgIuBd7uWfg/CtwA7NM/5jnfBswppc4GPgx8QL/GFuBG4ArgcuBGEZnq/BTbZ9S16h0aCv3heT0KqC/6fox7Oa0za7yvZx5jxnK2wlt17Y2nz+ZLbBlJusYo7L1Y6pQqNRLeXXpqdeZQew3FzonWHoUbeorHG45nknGb9RTBnPYoGgzFKeMoBY8diQ71LqxUGM8k3c+pE0F7pVQhqw3BWMbZRB7XIc1Rv0fRIrllaDUKpdS3gVnf4XcAf6qUKur7mLFPChgRkQSQBUrAgojsAsaVUncqZ2v7aeD1+jHXAZ/S//88cLX2Nq4FbldKzSql5oDb8RmsfmOsfqeZSK6hSLRnKMzFMB0wArFjj2LJW4HtLC75UoVCueZ4FG4ow4afWlGpqaZhQKsRynH0JGfTYAxFlEdRz3qShuOZZNx6FBEYL2DCE3o6/xSnyPHRFjrFYrHuUQAdaVd5n0cBcGTBGX1b9yjai2aY7sBj6cS60CjOAV6hQ0XfEpGX6eOfB5aBw8BzwIeUUrPAbuCg5/EH9TH0v88DKKUqwDyw1Xs84DENiMgNIrJfRPbPzMx0eUpejaIzS10PBTQairAP0jy/ydX3GqbONYpi00Q2cxFvHUmxYxXrAdY7/tBTbhU9iqkR55oZTScYSyfcWoqT+RKv+u//xD89Vh/B6RbcJRq/vtlUrO3K7M/e/Rw/99F/6cfbXzeczJd10kDCPXbKRIbxTKKloL1YqDCeTbJl1DEUnQjaXkNhXvvQSefzbdYoWhgK/dlvG0uvixYeCWAKuBL4HeBz2gu4HKgCpwBnAL8lImcCEvAcJrYSdlvUYxoPKvUxpdRlSqnLpqenOzoRL0aj6DTryR96Gte7hrDpcqYLpWsoPBeHEdw6EbPPnB4hFY9xVBsDcxFv0emxsLpjPdcr/jnUjkYxWENR0WHBLdqjAMerODzv7Dhvvvt5njmR59Ej9YWs7LveDJlE+4btnmfmuPfZuU2VJTWXLzGZTaLlUcDJbjv/lPGWtRQLK2XGPKEnM5GwHVYaPArHIJjP19vrCdrxKOp9o7z9pwZNt4biIPBF5XA3UAO2Af8G+LpSqqzDUd8FLtP33+N5/B7gkOe59gLokNUETqjLPR7wmIFgPrROZ0SUqs79k+2GnkpOH/opfdEtB4SeStX2NAqTBjs9lmZGGwPXUIymPBXG1lC0olytNezSM6nBz6E+uVJGKdyQBjiG4shCkUq1xmfufAZozGbyJ08Ysh2835mlxmtlM3AyX27IeDKcv2uCx44sRGYyLRYqjGcSbMl1rlEslyrkXI3CeX0TWjR1FCNuan7052c++22jabceYzXo1lB8CbgKQETOAVLAcZxw01XiMILjcTymlDoMLIrIldrzeCvwZf1ctwImo+kNwB1ax7gNuEZEprSIfY0+NjAyiTginc+xLnYqZhedHYYJdXkNhclkKLdZHe4IoWm2j6ebPYpcipF0YtXHeq5XylVFMuYJPa2CRzHrqco27BzPcGR+hdsePsohvaB4F5CggjvQYna7hkJvHI532LdoPTOXLzHpEbIN558yTqFc45kTwdMglVIsFByPIhGPMZlLhhrYRw8v8P6vPtKQZehPjwU47IaeTAuPNkNPWqPYOmwehYjcDNwJnCsiB0XkbcBNwJk6ZfazwPV6cf9LYBR4CLgH+Ful1AP6qd4BfBw4ADwJfE0f/wSwVUQOAO8C3g2gtY336ee5B3ivPjYwYjEhl4x37FEYjcL03jEXQ5RGYRZwaGw13olGYdpTbx1NsWOsXoHt9SiAVR/ruV6p+Gc8aI1ikKnFs56qbMOuiQwzi0X+5jtPceqWHNtGU6yU64tCudKoiRkcQ9HeBmMzGoqT+TJTgR6FI2iHhZ+KlRrlqmI863xft0QUYv7jo0f5m+883eBx5EtVckm/mO0YirG087u5vWV6rC4Kncg6abarlfaeaHUHpdSbQ256S8B9l3BSZIOeZz9wYcDxQsRjbsIxSqtGrosOsv6sp0Q8xmg6EZEeqz2KtGkZ4ryeUoqT+jGVNgp6TjRoEWnufOqEezwZF8a0IVrtsZ7rlVJVNYSesqk4SjkLhal87jdePcmwcyJLTcH9z5/kD37yfD595zMNnk0xoHssQDYZ49hC601OtabcGPvxVag8HxZO5ktulpOXs7ePkowLjxxe4KdefErT7cbLN4v81pEUJ0I0ClM7dXypyLbRNLWaYqUcrFHEpD6ZMBGPkUnGWhfclZ0OEOOZJDXlrCVmwzlIbGW2j9F0onONIqBS1lRnB5EvOjHLEdejqM/PNnHSdqZXmfYdpgJ7fqVMoVx1q7KNaGers9vD28IDOq92PnBskdseDu/xFcSJAI9i54SjK42k4rzxsj1kk41DbcLE7GyboacTy0XMPmQzeRRzIR5FKhFj+1h4jy1TAW0ylraMpEJDT0YjMh6bSVc27YFGUwlEHINixqAa2plJUapWdc8o5zxWK/PJGgofuVS8Y43CiNneUMB4NhkaQzQeRToRIx4T14PxGpZ2Qk+z+foiY4r3ZhaLzC6XG4qKTL8nW50dTVB6LNQHz7Tif3/rKX7/iw929JrG2Htj5zvHnXTnN162l/FMkpF0ojH0FCJmZ9qs+/CGIY8vbg6PolCuslKuBmoU4GzswiqdTQjZZDNuGUmHGgqjV5q/sdtiXF9LsZgwaoRtnyfQzjwc16PQYbDVKrqzhsLHSCrRsjGXH1NF7d3hjWcSoRee0Sicoer13aI3nbYtQ6HdX+NRgFN0N7tcZOuox1CMpymUayyuwljP9Yx/DnWmQ4/i8PxKx1lSc/kSY5lEw6J/3s4x3vPj5/HOq84GnEXG61EEebDm/bbz+l5DERZC2WiYTVhQ1hMYQxH8/TCLsQkbbRtNMZcvB3Z6NX9/46mZayfrCV2O+TKdDI6haJ315PUoVquNhzUUPnJtzq71EpSuGB16qscsvbuIkyv1XUq5jfTYemFduiEN1mRCGXa4tRRWpwjDNHb0tvAwKY1+Q/Ho4QUeeqF5hOaR+YJ7LbSLSW/2EosJb3/lWWwdTev30egpmE1EIubTKFLx0P5iXoyh2Daa3jShp7mAPk9exrPhmqIJ74xnjUeRolpTgfcv+DyKvPYEzbUEda2jyVCk4u17FBnrUawpI+luPIrmmPFENhmR9VStDyzxvJ53d9DOgjO7XCIeE8YyiQaPwr/4mLCULboLxyQPpALGi/rj/n/81Uf4z3/fHGI6Ml+gXFWRMwVMqqXB6ElR5FIJd8EBR3RPxWMN8W1w0rtL1VrLzqamhuJFu8Y2Tehpbrm1RxFmKIynMebRKCDYGyu6HoXzdzXitNkYep9nLNPsUbRKj3U8injdo7Aaxdowkoq3bMzlx5/1BNEX3nKp4laBj6QTbnqsub9Ie3UUTnvqFLGYMJVLkowLh06usFio+DQK7VHYFNlQgmoTsqnGrDTD/EqZ5+dWGo4tFspuEkSUkf/m4zNc+r7bXY/kxFKpDUPReE2aIVl+sm0OL5pZLDKaTrBnKrdpQk+mz9NkNsSjyIRv7BZ9GoXpyxWUIuv3KFYiDMVIym8o4q0rsyuOmG00itVqNW4NhY9cFxpFkLg4nk2SL1WbtAalVINHMZqui+fGUGzJpdrSKLyeg4iwfSzjdsHc4tEodozbfk+tMLUJQTMe/AvvUsGZU+41IN4511GG4vm5POWq4r/f9jjghETaMhS+0JM/Ndb7fltlPs0sFpkeSzM96mTvdDJbYb1i0s5NTy0/EyHfV3B27fGYuIt9vY1HgKHwZT2ZUFJQ6GnU71GkEi3TY80mYdxqFGvLSNqJE3aSIRTmUUBzdXax4oQGjEeR86TEmaZlk7lkWxqFtz01OKL1o4cdQ+ENPY2mE2STcZsiG0FQoz0368n35TUe4KGTda/iiEf/iUptNjHlb/1ghn996kSTnhRENpVgpVwfk+kX3Q3pNsX3mcUi06Npto6mqanGVvUbldYaRfjCu1ioMJapp7KaRJGgNh4m68kVsz3zsg3Go/DXPzjRhVYehSNmpxMxUvGY1SjWipF0gppq7PveilJAAdREyIVnFp26R1H3YOZXykxkk6R0rLkVs8ulBs9h+1hdnPQaEBFxWnxYMTsUN/TkEYjNl9u/Qze7xIOe8JO3LXiUoVguOn2+doyn+aP/+wjlqmJLyC7XMOJ7H96xu16MR1Fs0Wp8ZsnxKLZpsXwzCNon82UyyVho4WRU2x2nIWB9UTfGJsijMBrFbL5EpVoL0SiMmN34XtrZpBqPQsTRJq1GsUYE9V9qhb/XE+DGEP0XXt0VNRpFPf7sGoq4tBd6Wio2eA5G0AaaMmlOmcjylQcOc8Wf/D/eetPdfPG+g1jqRGkU3h16VVfaQr1VNMDRNg3FUrHCaCbBO6/a585AaOVR+D2bUqXWVGwH3gLB6GvHhJ626U3Gagva33j4CN98/FjrO/aRueVSqD4BRMb8nYaAdWNuso6iQk9KocOT4RrFaLpxg+DfpP7zE8ebXsPxKHTLcj1/ezWwhsJHWLghClPR681CCduh1C+cetbTkkejGM8mScZjLQ1FuVpjoVBpDD2N1RecKZ+heP/PXMi7f/w8fuSsbTxxdJH3feURW4DnwYT6Glp4BIRyvPrVCyfz7v8PL7SnUSwVKoymE/zCy/Zy2tYc0GzU/eR8c1LCQk+ZNjSKQrnKYqHC9FjaTb/tRtDe/8xs19rGn33jB9zw6Xv53nNzXT2+FcvFCu+65f6GepGTK8GdYw2RHkWh3JShtDUktbhYqbnPdWyxyEqpWaMYz9T1SS/ecaiPHVngLZ+4i5vvfq7hPt5EhrGIWq1+Yw2FD7fdbweCdlAWSn14UePzmOd1s55SCYqVmjuXYNIYihajUOfyza0fzOwJkeZY7JnTo/zKK8/iz3/hJfzG1fuYy5d5+nhwt8zNSH28aOMc6mRcGiqzvZ7mC57QU7sexWLRMRTJeIzfvfY8ROBUbTDC8G9eylXVddaTWTynR9NMj6YbjrXLkzNLvOF/39m1V7BQKFOq1viVv7t3ILU9jxxe4Ivfe6Fh2NPJfClUnwAixWFHo2g0MmFtPArlKnumnMr6maUiy6UqiZg0fF6hYrZnHOrHv/O0834Kfo2z6jYfHdfzt1cDayh81PvCd2Yo/Fko42EeRbFRo/D2oTehp2Qi1lKjqDeTq3sRxqOYzCaJx4LmPjlccpozevy+505GvsZmIrJ1dynEUPjEbHMNROlbS1oYBfiJi3dx3395DWdNj0a+N9MnyHgUQdebea8Q7VGYGorpsTTj2QTJuIQ2BpxZLPKHtz7cZPhMPc5cyGCuViwWKrz87G0sFiq8/e/ubampdIr5jA7MLLnH5vLl0IwniPYo/KEniDIUNddQHF8sNrQYN4Smx+r7PXV8iS/f/wLQPEO76PcobOhpbTAfVifV2UEeRdgOxfUo9OsY93O5VOlIo/A2BDQYjaJVuuXZ06OMZRLcNyDXfz0SZij8VdEm42kyl2zQKI7MF9gz5XgGLTUKT7aLP0QYRJNG0SL0FOVRmEV+eiyNiLB1JM2JEDH7i/cd5JP/8kzTPGmzmHYz1KlaUywVK1x62hQfeuOL+d5zJ/nA1x7v+HmiMN/dA8fqhuJkvsREpEYRXsDmF7PBSWH3Z4sppShUquzV18HMUpF8qdKgTwCcvm2EREw4fdtIw3Gzafyrbz7pZEammuehNGgU1qNYO/zx4HYoB2ShZJJO0z+/oTCLjrkocp645ILxKOIxKi3SY08EtKc2HkUrQxGLCS/ZO8l9z3ZuKA6dXOHXb/7ehqvJMP26Ek2tuxs7si7pHdw5O8Y4slCgUq1RrFQ5sVzi1C3aUERpFMUKo5noLCc/Riuph56is54iQ08ejwJg21gqNOvprqed8S/+XbZZTFsZimdPLDele5rfxzIJXnfRLl597jTfPXA88nk6xfUotKFQSoXOojBkknFSiVjTudZqiqVSxTUkhmyquQFjuapQyjH+I6k4xxdLel52o5E5a3qUh997LefsGGs4brKg7n56lmsv2MmuiUxDM0ilVIBGYT2KNWEk3blHUawGZ6EEVWcbj2LE9Sici+jIfIGacnaq7YjZQXMMpnIpknFpaSgAXnrqFD84utgyb9vPZ/71WW79/iHe/YUHN5QYXtco/ONFG4ugzN/r3B1jVGuKIwsFd5fuGooWdRSdzg/wTz9rnfUUrVGI1K+brSPpwNBTtaa4RxuKk35D0YZHoZTiur/8Ln/9rScbjvurnHdNZvuenmu+Y8/P5SmUqywVK1RqKlKjgOAOsovFCkrVBWiDGWrlxbQUTydizmjipWLDvGwvxivw4u399MuvONNp3RIwAtfVKLJJVsrBRYL9xhoKH8b6dypmB4UCxgMMhYk5mrizuThM8ZbJemqlURiPwrtLisWE83eNc97O5uEsfi45dZKaggeeP9nyvoZaTfGl773AZC7JHY8d47P3PN/2Y4edSi049JRNxhoWRLNbPWensxt8YW7FLbYzWUyt6ij82S6taBazW2U9hb/+zGKRLbmU+/hto8Ghp0cPL7jdhps8CtdQRLzOUpGT+XJDxTo0d2KdHk0zmy/1dbEzn5FS8NTMMifz0X2eDOMBO3S/YTPkknHKVdXwvs11kk7GHUOxWNDzstv7vI1mccmpk1x62lRT6MlcV/5JmquRImsNhY9Rj7jcLiVdLeknyqMwuz/jwZjZyE7BXRsaxXKRyVyyodspwN//xx/hN39sX8v3/NK9RtBuP/z0r0+d4PB8gfdedyE/cvZW3veVR3g2ZM5wL/zZNx7nP91yf9+fN4pSQAsP0A35PJsG8/mdq8MGh+ZX3GK7vW7oKfjaqVRrrJSrTfnzrXANRTE668lcg62ynqY9adRO6KnU5B3+q56WCM06m7mmo0Tz52dXGu5rqBsK528wPZZ2aw76hXe08IGZJVdLCJtFYQj6vvobAhqCijHNPOtMIqY785a0mN2eB7l9PM3lZ2zht689FzCtW+rXXtFnKMZXcXiRNRQ+MskYIr1rFBDcQTZfqpJNxt2sJLOLMKmWE9kkiVisZQsPf/sOQywmTV1Fg5jIJTl7+2ho5tN9z83x9s/sbwhNfeG+FxhLJ7jm/B389ze8mHhM+K3Pfb/vvYK+99xJvnT/CxyeX2l95z5R79fl68jqm0Nt/h77tjuZSi/Mrbipsa08CrP58KdFtqKum9UL7oI8ilhMyPg8ID+mKtuwbSRNSdfkeLnr6VlO3ZIjk2yO25v7Rr3OwTmnxiTMG6nPduguRTeKfKnCSCqOiKNTGI8iSqMAPWys4DdsjS3GDcZQFLwjait+j6LYMC+7FelEnM+9/Yf44bO2ATSHnnytgszfcDV0ipaGQkRuEpFjIvKQ7/g7ReRxEXlYRD7oOX6xiNypjz8oIhl9/FL9+wER+Yjo1UxE0iJyiz5+l4ic7nmu60XkCf1zfd/OOvp8neFFPWY9QYhHUWx0Rf2hJ1ejaNFC5MRS8xyDTrnk1Em+99xcoNZw55MnuO3ho7z/q48Azpfv6w8d5nUX7SKTjHPKZJY/+ukL2P/sHF/osso7TOPIl5y48Fe+f7ir5+2G+oyHoKwnj0dRrLj9uLaOpHjhpONR5FJxt6tomKFYLOpFskONIq7z8E2rcaeFR/BmINNiHOrxAI8CaAg/1WqKe56Z5YoztjjXcL4bjyLYULh/AxN6MpMZ+6hTLBUrTOZS7J3K8eSxHj2KQohH4UswgHooLpOIMT2aZn6lzPxKue3Qkx+/YF73KOqV2TA8HsUngdd6D4jIq4HrgIuVUhcAH9LHE8DfAb+ij78KMGfxUeAGYJ/+Mc/5NmBOKXU28GHgA/q5tgA3AlcAlwM3ishUNyfZKbk2Boh4CUtXHM8kmr5k+VLVLbaDeqjr0Hzdo0gmpKVG0U7X0VZccupUaOGduUBvvvt57njsKN94+CjLpSo/e8lu9z4/89LdXLh7nL/8pwNUuogxv+lj/8qffaM5NdLs4L+kc8lXAzc9NuHXKBoX3uViVe9Whd1TWQ7OrXB0ocDO8Yy7WSiFeIPGG+nUo4DG9vf+2d7+9xu201dKNYee3H5P9dDP40cXOZkvc8WZW5nIJhsGakF98S9GaBSmD1aTOOwPPZnX76dHUawymk5w9vbRzjyKTICYXTCGzadRBIWetEeRScbZ5hkk5q+jaJcwjaLJoxgGQ6GU+jYw6zv8DuBPlVJFfR9TAnkN8IBS6vv6+AmlVFVEdgHjSqk7lbON/DTwev2Y64BP6f9/HrhaexvXArcrpWaVUnPA7fgM1qDwNuprh7AslIlsksVipWGQzXKx0lBok0nGiAkcPunRKNrMemrVI6gVUYV3K2UnRHbezjF+7wsP8pl/fZY9U1ledvoW9z4iwq9ftY9nT+T5vw8c6ui1n5pZ4q6nZ3lct0X3UihXiceEhw8tcOBY8+2DwG3h4U+P9X1ZvXUQuyezHDq5wuH5FXZOZNxrIMyjMKm1nWY9QWMYIiz0BMawBb/+wkqFUrXmLs5Qn63gzTy6S+sTrkcREj6K9ChCQk9NY0W1R9NPj2K5VGEkHefs7aM8fXzZ9ZYmstGGwgkVNzblM+/Xn/UUVNxoPIq09igM/kl27ZJLJXweRT2rynlPwd0fBkG3GsU5wCt0qOhbIvIyz3ElIreJyH0i8rv6+G7AG584qI+Z254HUEpVgHlgq/d4wGMGSi7dXOgSRVg3z/FsEqVomFWd96XLmVBXSc8YyCbjJOMxaorQ2H+tppjLl3sOPUUV3uVLVUbSCf7s51/MyXyJe5+d42deupuYr+L7Nefv4LydY/yvOw50pFXc9vBRIHixWSlVeeU508QEbr2/MwPULeHpsfGmrKcRj6F44eQKR+Z9HkVo6Kl7j8IrbJartSbPx5BONuf3G2aWnM1Iq9DTXU/Psnsyy94tOSayKeZ9MfB2Cu6MmL3sm/GwUCiTStS7uOZSCUZS8b5qFEv6Mzp7epRStcYDL8wzlkk0JX74Gc8mqNaUO4AKvJqKT6MISEU2f4+M1ij89+2UXMrpIm3+fkWfR7GaMym6NRQJYAq4Evgd4HPaC0gALwf+rf73Z0TkaiAooGpWlbDboh7TgIjcICL7RWT/zMxMRycSRC6V6LiFR5ihgMYP0tntBPd4mcimEBF3txjmVTw/l6daU5wymW37PQYRVXi3UqqQTcW44JQJ3vWac0nEhJ+9ZE/T/USEX796H0/NLPPVB9vXFL7+8BH9Os2LTb5U4dQtOX74rG186f5Dq1KvEVqZ7UuDXPIYilMmsxTKNQ7NF9g5kSEeE+IxCc16MtdUdx6Fs3kxs73DQ0+x0JYYZsKhdxHbkkshAjM69KSU4u6nZ7niTMdzDKotMKGOMI+iWlMcOrninqc3fdNph9F4/tNjwbUc3ZIvOoPBztIJB/c+O9eyhgKC23gsFitkkrGm73fQPHWzkHtDT859uzcU0JjEAHWNYnQdpMceBL6oHO4GasA2ffxbSqnjSqk88A/AJfq4d5XZAxzyPNdecDWOCZxQl3s84DENKKU+ppS6TCl12fT0dJenVGckFe9b6AkaL7ygAhyTIjuhWx2b8EeYTrH/GWdhv+S0ybbfYxhnbhtpmKXgvs9ylVzSeT+/8sozuev3r+YMX8sBw2sv2Mm+7aP8xR1P8E+PHeN9X3mEn//fd3J/SI3G4fkVvq9vC/LcCuUa2VScn37JKTw3mw99nn5SDz01exRQXxQbQk9TdUO9c8Jpn5KKxwYWelopVd1rImhjYt5vqEehDYW3y3AiHmMqV6/OPnBsiRPLJa48YyvQLPAWK1U3xBJWR3FkoUClpjh/l1PP07DwBjTY2zbq1Bz0C9ej0IbCGQ3cOiU5aIaM076j+bGmAWO+3OxRpBMxt4U7dG8o/G3uzQbAfPbxmDCaXp2ZFN0aii8BVwGIyDlACjgO3AZcLCI5vei/EnhEKXUYWBSRK7Xn8Vbgy/q5bgVMRtMbgDu0jnEbcI2ITGkR+xp9bOCMpBMdzc0OCz0FXXjLpUrArNxEw/3Nc4VlPt373Bxj6QT7to8F3t4JWV8c1JD3NDMTEbcldRCxmPDOq/fxg6NL/NIn7+Ezdz7L3c/MurFuP9/QYafzd403hS8q1Rqlao1sMs5rL9xJKhHjy6sQfjKLe5BGAfUvqxN6co7t9nh0O3WfrVQiwlD0GHpaLlVCtRRDJhGe9VTvHJtpOL5tNOWGnj7zr88CcOWZdUOxVKy4HpV30Q8LPZmMpwt2BxmK5r5J/fYojEYxkU263tNEGx6FCeX4DZvfAwLc2ohCUNZTMk46EXe/z+3WUfipexT1inygoWZrLJMYDo9CRG4G7gTOFZGDIvI24CbgTJ0y+1ngeu1dzAF/DtwD3A/cp5T6qn6qdwAfBw4ATwJf08c/AWwVkQPAu4B3AyilZoH36ee6B3ivPjZwRiLmZj8/m2fOVxxU7sCjyBcbs57M63nvXw89BYdc7n1mjpeeNhXZIbZdRnxxUMOKrvdol5+8aBcf/LmL+T+/fAXfv/EaRAhtD/L1h45w9vZRLto90eRRmOH02WSc8UySV54zzT8+drTDs+qccrVGIqAGxR+LXi5WXcO+J8ijiOj8a77Q/o1COxhPwWwewkJPmVR41tPMUpFUPOYO6TGY4rAv3/8Cn77zWf79j5zhtj43Xq7Z7Jic/XQivF7DZDxdeMoEEORRNBuKvtZReD6js3Vn3nY8iqCOz84sigCPItm4iIM368lUvTvGaaRbjyLZWD/j1yggOFNrELS8YpVSbw656S0h9/87nBRZ//H9wIUBxwvAG0Oe6yYco7Sq5DxT5/z88qf2c8lpk/y3n73YPRYlZkPjhRflUZg87yiNYn6lzA+OLfK6i3Z1ckqhZD1x0Ils/RxWytWWWSJeYjHh519WjxSOpoLn/84ul7j7mVl+5ZVnslysNhU2mt/N+zpv5xh3PHaMSrXWUozshUpNBWYS+ePE3tDTRDbpagfe0FNYm/GlolMI1o2BN5uXoNneXjKJeGhIaGaxyLbRVJMx3Dqa5ts/mOH3vvAAl5+xhfe87jz3NnNNzq+U2aprA8DpVBwW8nh+No8IvCgg9LSwUmZ6tLGt+jb9vM6she4WVUOp4nikZnE+e/sodz51oiONwrvwHlsosndLsxZYT4/1tvBo1BCmx9I8ObPcdXqs8VyNh+ivzAbHO+20X1s32MrsAMyXMkhEPb5UbHCTazVHXAxaZOrDi5wLr1pTFMq1pm6So65GYTyKcI3CKZCDy07vT0mJv+GcIaiPfieMZhJuTN7L/3v0KNWa4rUX7NIZRY3nWCjVPQpwwjvVmgrUUfpJOzMelFK6V5PzNxMRdk9mScSEbTrNNB0VeipUugo7QT1Ntx4iC9MoYqGhp9nlUmAIcdtoym1x/xf/5qUNz+33is21vGM8HR56msuzczzjZlS141GAU0TaKyZhwPUotE7Rqs8TNG/sajXF0yeWA7W5dMLp4OAtxvRqFADTY87mwf99bxdjjMw5BXkUI+lEQ5bWoLCGIgAzuzZoZ7ZUrDQsqlHiotk9mgvPPM4vbpkGgeZCNWGFoFbj9z07R0zgxXsnOz2tQMJGv+Y7DD35GU0H73Rue+gIuyezXLh7nGzSCXt5i/XMImeMlJnxcNAzTW4QhLVh8Wa3FCs1KjXVkLW2eyrLjvGMmzbcSqPoRsgGZ3fpFbODeotBdMHd7HIpcP7FaVtyJOPCX/3bS9g+1qhf+BdPs9vePp6hUK4FbqYOzq6wdyoXmL65GBDK6WcbD7c7s99QtOEdj6UTiNTrEl44uUKpUuPMgMFSItJUjGmGCplrwYSeuhazk42ZVf6sJ9CJN9ajWBtGPMOEvDizB2qRrX+9iIhTne0aCtM5tvHCGU2HaRTNC869z81x3s7xrhccP2GtqVfKwe2R22UkxFDsf3aOHz1nGyJSN1KeL5trKIxHoXUA7zS5dsmXKvy3rz0a2Xbb4GgUEa27y9XA9NZfv3ofN/7U+e7vURpFL4Yil0pQqSk3JBrmUZgWHkELeFjbl7dceRrfffdVXHralqbb/B6FG3rSBiUozHZwLs+eqWzTTBZToxDmUfSj3fiyb4LkhadMcOa2ES5uY2MViwlj6foc6qd0x4IzQ7L9ssnGeqtCudqwDpjz6qUyG7waRaPHAtqjsIZibXCbsPl0CuPieY+XA9xBL04euvNBum5x0whErVEYQ+G2gmj8ElaqNb733Mm+hZ0gfPRrJ10vgxgLiJ3WaoqFQtndQQY1VjOLurntlElnQTJN5jrhnmfm+OtvPcX+Z1vnQJSrimRA/6SsJ/NkyRfWAKcNyjUX7HR/j0yPLXYfejKLhmmnEWUolApewMMaSSbisSZPwtAUelqph56gOfOpVKlxeKHAni059/HmsUshfZPMzrsfHkX9M9Lh3FySO377VVxyanvfmXFP3chTepRqkEcBzX21ipWqG6oEx0iNZRINdSud4N9IlQISGcI8935jDUUARgjzfwAmdJQvN4eewr643i+K61GE1lFoQ6FdV3967GNHFsmXqlx6Wv8MRTZgV+9NUe2WkVSzRrGsm/2ZhSKosZqZ6GVuSyfi7BhPu911O8G8fjvpg2H9ulxjpgfgAJHzJCJDT10MLTK4hkL3LQqto9B/N38fppVSlZVyteP+YK6hyNc9imwy7oaP/HrIoZMrKAV7tSfovf4XQjqx1vtN9W4ozHe027+z9/0+NbPMWDrRUBPhJefLMCuWa27GE8CPnjPNAzde0zTLol1MSNroIEWdXentjjCSdkJPgy5KtYYigDCB1+y6vR5FkJX34h1e5Bfa/K83kWv0KPzpsffqCup+GoqRAO/JfPl7CT2NZppdYn9DuCB9ZMWI2Z7X3j2Z7UqjWCo27oKjqIQ02st5jJkb1ohYhFqHnrpbNIx3Z66l0DqKgB5EALO6g2qnbV9SiRi5VNzjUVQYzybcgjO/jmc+p70BHkVU36SxTKI/GkXR6IDdGYrxTL3V+NPHlzlzeiS0bb+/D1ghIGurnZb/YRijb667oA4QRk8Ny7TrF9ZQBFDXKHyhJ/2BRXV09ON1ZfMhC7CplDVFW2Eaxb3PzrFjPN1Q6NUr/qIeaA7/dMNoOtHQ4wqaG8KZxW8lQqMAR9DuRqMwA2za8SjCMte8ldlhht5LVOgpqNisXYyXaxbd0BYeegFvMhRLzaNz28W72JvsqEwiWNsyzQBNjcl4g6EI7psE/Su6c2d+9MWjWAoNO4FuwOgruPN6FL0SjwnpRMyTHltt0kLNRm/Q4SdrKAKoaxTNoRNwvoSmI2yrlgoT2SQzS0UWC2V31+5faF597na+9huvcHdhYemx9z47x2Wnbelpl+InG7SrD1isO2VUi2yNnTgbF4ogId2f9QTOonPo5ErHA5LMwt5Oi4NyNTg9tp4G6Q09tfAoAgyFUqonMTvrhp5K7usE3i9ZD5V5ObHs7Na3hoRRovCHj8YzSTImJOfrK/X8bJ5ETNg10Rx68m8UvEyPtld0V6rUAtviG8x31J8w0i5GU8yXKhyaL4QK2dA8N7tQrroGtF94m0GGeRTQrDH2G2soAjBWOsyjgPqC1sqjeN2Fu1gpVfm3H7/LHU7k9yhiMXGLk6C+W/R6FMeXirxwcoWXnjrZzSmF4oaePOcapqV0wmjGcYm9XyT/QhHU09/EY71GavdUlkpNcXShs1oKs7C3pVFUggv63DTIUpseRSK44G6lXKWmumvfAfXPqR56Cu8ea17Pixk12k1r+vFskpMhHkXB9x05OLfCKZNZt6iwwVAUwz2KbWPptlqNf+G+g7zmz78VOv2wHWMexXjWyVI0xijKo8gFDBbK9LC5Cn6NBN7KbL9HYfQy61GsAW7oKUTMhvrOpZVG8fJ92/jrX7yUx44s8oGvP+Y8f4v4aVDoyYSvtkX0XOoGM/rVWzhkLsxMD4bCLKZeQdsVM93QU1DYq94vx2BqKToNP5kvTzsaRdQwoFwqTr7cnkeRDtEozN+h+9kEjWJ21DwKaF7AXUPRRoWyH28H2fmVMuPZZF3k93sUc/mGSuZx3SuqVlOh86fB8SjaGV703GyeSk3xnSeOB96eL1bdkE03TGSTrJSr7pyUsEaY4FyjUemx/cDb5DHKo+hkLEI3WEMRgLvI+QyF93f3w2sRegK4+kU7uOn6l7lf7laxf1fMrtRDLfWGY/39yESEXDLe4D2ZsEW7s36DGAv4G9bFzOjQUyoRa2hzYTSZTlNkzeLczmAXR6MIF4gLXjE74vML0yjM36HTMagGN/SkF+yogjtoXsBPLJdIxKSpz1M7THpDT8aj0NehMeyG53WxnWHCzGQpVDyhxwBDMZZmsViJnHEB9RTafw4xFEt61HC34VmTkWW6G0cZCn/WU6Fc7btHMeIRzB2Pwp8xuToaRX+qtjYYab1QNXkUntDTsmcsJYR7FIaX79vG//cfruDOp060vJiCNAoTSuj3hQiOqBwceur+8hiNMBT+rCd/nNevjRhhtNMU2c41igiPolRlueTMJojqORWmUfQaEjFe6EKL0JOb9eRbwOd0VXY3C6gJH9VqisVixfEoArSQUqXG8aViw5wUbx3GYqFCKhEL7Oc07anONlpdECaF9rsHjlOrqaZBWss96EDe93v/8yfZPZmN3NT5C+6KlRrpPm/ksq00ipTVKNYMEQls3+ut1Db5/q00Ci8vPXWK//iqs1veL0ijKA7QUIyk4w3hn3pjvu4vj6CdzmKhTCIm7m40SEjPlypN2kgmGWfbaLrjFNlOQ09hjfZMq4bFNuogwtJj3VkUPfR6Am/oKSRlM0SjOLEcXJXdDhPZJPlSldl8CaWc0GFQGq7xGLx9lUyYcX6lzEJIy25ofyTq8aUiMXHO59EjC023m8mM3WK83UcOL3DmdLg3AfXrwiRsFMrNO/5eadQoArKeQsLk/cYaihC8+dQG74dhPAojXIbt8LohSKMoVAboUQTEWqH7PvpQDy94NQrTEM7salNxZ154Y+gpuNBv91TntRSdiNnlqnILHf2YOLF3DGoYqXicak01ZWgt9uhRGC/XVGaHbUwybn1Ds0bRTWos1Ot7zJwJJ/TU7FEEeU2NHkU5tPjMzMhopVMcXyzx8n3OcLIgncJ06O0WE3oqV1VkxhN4ZlLosHCxXO17aLiVRlH33K1GsSYEexTN4ZmgYSK9EjSPYlAaBTRnb7ihp14qs0M8Cm/Gi9PvKeHLegqO8+6ZyoaK2c+dyPP+rz7ipiwb+hV6MjvH5WJzi3g/YXOzw9pXtIvRksx10Cr01FdDoRfP57ShGPdoFIWArLYGQ5FrDD2FnX87HkWtpji+VOTCU8bZt300UKdox5hHMeHRcKL0CXDGzkJjG/C+Zz0l/RpFiJhtPYq1wTEUzR6FCfHWB907i1M7oad2cTUKz2LjFsENJPTUOKjJXJi9FtxBoxcWtFAEZY4Eve6eqSwvzK00GQOAm+95jr/5ztNNhsQYKZN1E0VU6Mlx/ytt1UGEGooePQporA1olfXkL4Q7sVTsOvRkdtlej8J4g97KbL8GZe4LdY8iKDUWYOtI6w6y8ytlKjXFttE0r9g3zd3PzDYZxOVStSdtzdteJCo1FjydhctVqjVFqdq8kPfKSDrh0ygavxvJuDPPe6mD0c3dYA1FCGOZZLNHUay6X7a6R+H820rM7gQRIRkXKrXVCz2t+BZrkd68JGMQFlsYCsebadRHguo39kxmKVVrgf2A7tOtTeZ9WsRSsUIiJihFyy9SuarCp8bpnbwZsRmFMRTFauMCFtRQsFPMwhSPSejwo2Q8RiImDVlP5WqNhUIlsMV4O0y6hsIxxOOZJCLS1BTPzezKNIeeFgrRHkUqEWMql4zs92Ru2zaW5hX7tlGq1LjnmcaGj46Y3UPoKeM1FNEehUkfXylVPNPt+vv9zDZlPQWPM7AaxRoRGHoqVtw6Bn96bNhutFsSsVhw6KnPYhkEexS5ZPcphhCcORY0VjLnq25dKQe776aW4nmfTlGp1njg4Lzz/B5DUanWKJRr7NBtUVrpFGGV2eY95kuVhjGoYaTj4R5FMt59fj/UvYVWm5JMMt6Q9TTXZZ8ngz/0ZMJJ/tkXxgP3ek3ZZJyEnskSZSjAqRGK8ihMWGp6NM0VZ24hGZcmnSJf6i30ZFqjZ5IxTpmIbpWTc723mtuEMdPndSCXjFOpKUqVmjvvwo/TatxqFGtC0CzafKnitgxut+CuW5JxaVhs3OlZA9Aosj6NYiUk/NMJIuK0QA4Qs70Ehp5CxGxorqV47Miia2gaRs7qL45pU94q8ylSo9DGbKkYvdBB3aPwN3Q0nWN7Mb7GmwkzaIZMMt7gUfRSlQ0BhkL/3o5HISJuem3Y/GlDq35PxohMj6XIpRJcetpUk6FY6lGjAOf8Tt860pR668dbMGr+3ukBeBRgBmcFF/SZdjmDxBqKEMYzCZZKjbHt5VKV8UzSadTlehTO7a2+vJ2SSsSa0mN7DQeFkfMt1r2OQTX4GwMGZb34hfSVkMl6pujOr0Pc99yc+3+voTChJtNzKMqjUMoZZxtWH5HVoafFQrntqvogj6Lb1Fj3fejXbqWHZVOxhsrsXhoCQj1uf3h+hXhM3KyiTDLW0M58MSQFeCKbZG65RD5gaJGXLSMp16gFYYyI8epfsW+aRw8vcEJ7GsaLbPUZteLULTlevGey5f28DSMHlWzi9p0rVwKznqA5IjAIWp6ViNwkIsdE5CHf8XeKyOMi8rCIfNB326kisiQiv+05dqmIPCgiB0TkI6K3ViKSFpFb9PG7ROR0z2OuF5En9M/1PZ9tB4xlkk2x7WVd9ZlLxRs8ilQi1tdGfeAsOGVfwV0m0Vs4KIxc2snVNkYxX6r0RTT37nRMU7xAjcKzK82XKoFGaiSdYMtIqilF9t5n59zcfG92k/FkdrXhUbgJCWG1Ce5Milrr9NgQMdupweiuxbjBLNAtQ0+Jxr/pCb34dtMQEJxrcSQVp6ZrKMw16PcoFgsVUvHmgrrxbNI18FEeRdQYV3A0imRcXI/m/FOc/mimL5PpztxKR2rF3/7Sy/jDn76g5f28iQOuRjGApoDgeMhBldnmPsOQHvtJ4LXeAyLyauA64GKl1AXAh3yP+TDwNd+xjwI3APv0j3nOtwFzSqmz9eM+oF9jC3AjcAVwOXCjiPRvEEMLXDG20GgoRtKJhiKYUiW8R1AvOIaiUaMYRGos1C9G4z6vlGs91VAYRj1T7pZLTlO8oNCTv1VzmDezezLbVJ1933Nz/PBZ2xpmk0M9DGLizKYhXRDGIEdVZrvn1K6haBKzy1237zCYv0srPSzray1RDz11ZygAJnWPKG9WkH9hXyoGt1GfyCZdAx/lUaSTsWhDsVhk60jaNVR7fF5mO00b22Esk2zLo84FeBT9Dg2b15iPaN0yFKEnpdS3Af8syXcAf6qUKur7HDM3iMjrgaeAhz3HdgHjSqk7lVPG+Gng9frm64BP6f9/HrhaexvXArcrpWaVUnPA7fgM1iAxOx8j0CnlzPsdSTsehWnnUapW+5oaa0jGpaHCdxB9ZAwjnl0LOFkcvdRQuM/r0SjCZhHkPFkdrSbr7ZnKNmgUM4tFnp9d4dLTphq6lDrnYkJPxqMI/yJV3PBhdG2COacozKbB30G2H6EnE1JpVdy5dSTVEKI7sVxCpJ691A3GQEx4niPjNxSF4HMczyZdYxU17S2TiOMfhORlZqnYMFa0rlv111C0i3dCo/k79N+jcM7FtJcPzHoaBkMRwjnAK3So6Fsi8jIAERkBfg/4I9/9dwMHPb8f1MfMbc8DKKUqwDyw1Xs84DENiMgNIrJfRPbPzMx0eUqNmOZpZoEpVmpUa4pcKuGEavSFUa6Ep1X2QjIeaxiFWqj0Npo0CneAkJkJ3ieNYswzzzdsFoG34K6gzzfsPM+aHuXZE3me0aEGo09cctqkNhT1L8tS0a9RhHsUrTLXvB5Fu+mxQQV3vS5guTZDTxftnuDAsSU3/352uchENhnZo6oVphDNbyhWfBpFkMflLWILa+Fhnq9QqYaO9Ty+VGwYS5pLJZjKJT0ehRlaNJjviR93Jke56m4MBiVmR43AHQqPIoQEMAVcCfwO8DntBfwR8GGl1JLv/kHBX9XitqjHNB5U6mNKqcuUUpdNT0+38/5b4vcozK53NJ1wxF/9wZSqwQJTr/jF7JVSte8XocH1KDyDmfphKEbScY+hCPYovKGnVpP13vrDp5FOxPiTf3gUcOonknHhglMmGiapQd1QTOacKuKoDrJu6CmshUey/dBTOsxQFKs9FdtB+6Gni/ZMUlPwyCGnF9LccrmnsBPUDYTXI3DEbI9GEZIV5jUuURpFJhlDqeaMMcPxxVJTm/3dU/VwZK9jUDvFq1G4WYn9To/Vn/lcpEfhdH8e5Nzsbs/qIPBF5XA3UAO24egJHxSRZ4DfBH5fRH5N33+P5/F7gEOe59oLICIJYAIn1OUeD3jMwPFrFPWLMK6b6NU1in5nPEGzRlGs9L+PjMHfnG9F11H0ymg66e7yFkI9ijilao1Ktday+nz7WIb/+Oqz+cYjR/mXA8e577k5Ltw9QSYZZzyTaDQUntcbzyQjPYpWGkU21UHoydUo/Iai+zGo7mubrKcW19vFeyYA+L6uLzmx3H1VtsE1FD6NYsUfegoQ7BsNRbRHAc0t0sFp33Fiuci2MZ+hmKy3dulH9XsnJOMxknEhX/aEnvo+uKhRowjalOZSCao1NdC52d2uPF8CrgIQkXOAFHBcKfUKpdTpSqnTgf8B/IlS6i+UUoeBRRG5UnsebwW+rJ/rVsBkNL0BuEPrGLcB14jIlBaxr9HHVoW6oXA+ILPbHk0ndFvuekjKX1bfDwI1igG8DnhaEfQ59GTEbGdoTePQovpr1wXBoDGoft728jPYPZnlvV95hAcOznPJqU5+g3e4DjTGq8cyiUiNotwi9NSJR5EKSI8t67TNfnkUrTzYHeMZdoynefDgSaC3Pk+GuqGon4Nfo1iMELMNkWJ2IrihITgLZbmq3Hbkht2TOV6YW0Ep1ZfJjJ1iuhqYRXpQ6bF1j6L53IJa+vebdtJjbwbuBM4VkYMi8jbgJuBMnTL7WeB61drveQfwceAA8CT1rKhPAFtF5ADwLuDdAEqpWeB9wD3657362KpgXOwFv0eRTjQMEykPKPTkT4+NygbqldyAQk8mVrxcqgT2AQLv/ASPoYjYlWWScX7/dS/isSOLFCu1UEOxVHJmHyTjMcazzZ2AvZQq0emx3lBGN72elvu0060X3LW+3i7aPckDLzgehWMoepuMaLKevIu+f2b0UohG4Q1XRYWeTGi1GCBoe9t3eNk9lWWlXGUuX151jwLqxapFN/Q0GI9izmgUAZ99vTHg4FJkW/5FlVJvDrnpLS0e94e+3/cDFwbcrwC8MeQ5bsIxSqtOOhEjFY+5C4x3upm3/0qpUnPbNvSTVFAdxYDTY1dKurlZpUYu2Yf0WB2GWC5WI8Rsj0fRZjPC1120k5edPsU9z8xxyWmTQH24jlIKEWGpUHHTUccyyaY+UF5MT61Wjfagu9BTWCFap2ST7WU9Abx4zwT/79GjzK+UmcuXew49jQdpFIkYhXLNjY2HVa4b45JOxCI3VWGdb6HevmObrxbELcScW1n1rCeoJ2MMquDOXHtu1lPA86/G3OzV+4uuM/zDi7wX4YgOPSnldIwcxALuZD156ygGF3oyX6zlUsUT/un9nEbcC9jpHBqPSZO34E0xNMOgWmV3iQh//vMv4Z8PHHezmiaySSo15Q6u8babHs8kODgbPka1E42iG4+i1zGohlyboSeAi7RO8d0Dx6nWVN9CTw1ZT/r9mLBLuapC02Mh2puAep+koFi7qcr2h57c6Ycn8+4YgEFlBwZhWtAMSqOI6UFfJuspyGPxfn8HhW3hEUGDoSgZjyJBVlepFiu1wRXcJWKUa42hp0FlPXn7ydSn2/W+h3CHF2mPwju0yP/a+VLVbWTXTthr75Ycb778VPd3bztr5zXrYZCxTDIy68mEnhItKrNj0nrHGFRH0Y/Osc7j20uPBbhYt6D41uNOunivhmIyyFAk6h6A6zEGpscabyT6/CM9CrfPU7OYDfDCyYKeFxJv2aOpn5i52cVKjZhAYgCvnUslItNjTWh0TTWKzcyYJ1vGLKCm4M45Vh2cRhGTpl5Pg9op5by7+j7uykzoaalQ0bMImhcKc5EXyu1pFGGMRxiK8WwiUqNoNffcvJ+RNpr6BYnZvY5Brb8PE3pqvRhtGUmxZyrLN39wzP29F644cwu/c+25XHHmFveYdxxqvSFgQNZTzngU7aUWBxXd+dt3GCZzSXKpOC/MrfTcObYbnOmQFbcgdhAtdrLJeGR67OgqaBTWUETg9SiWfKEncMJRQcNE+oE/9DRIjSKhh594Q0/9yBxpDD1VGAtInWwMPXXvvgd5FOb1xzNJSpVaaHuIVqGneExIJWJtiaSxmDRlrPUr9OR6FG1uTC7eM8HRBWcn3quhSCfi/Oqrz24IfWRT9YU9qMW4YTSVICaNqbVBRHkU/vYdBhHhlMksL5zMs9RGG/h+Y4oOC5UBdk7wpOMHNwU0nRWsR7EmeFuN54tV4jFnnoC3a2RxUHUUibpHUanWqNTUwC5EqHdx7cd0O4MxDN7Qkx9vq2YzwKgbI+UOyFmpJx+MZhpDHmEdZFsZCvOe2l2EUvFYoEbRe/fY9rOewMl8MnTbEDAKE3paKVUjvaZYTBjLJFt6FOb6DtYoiu64VD+mlmK52HqwVL8xg7eK5f5PtzN4w8BRHoUNPa0Rfo8il3JcS3Mx5kvVgYw/BGcxMLvSwoBytL2MpJzhJ/0MPbkeRSF8FoHbkLBc1yj65VGYbBCzk/X27brlnueY13Hf+jjbcIOfTXZgKBKNhsK8bs8ahVtw175HYejVowjCbWFRqbrt5MOMwavOneby07cE3uY+X8AcbsPMUrFJyDaY6mynu/Pqh55WylUKA5iXbfAWv0ZpFIP0KGzWUwR+jcJ8UU2sOF+sOBrFgNNjCz3E7tvFyYmvuIaiH6Gn0Ux9p7NYqASKmf7QU0pPxuuUJo2i4BWzTRty54t04NgSv/eFBymUa1z/w6e7f+dELPxzzKbibfcQajYUzqz10R4XsWwyTjwmbS9IF+52DMVoOtH3/H7wiNklr5gdHF76n296acvnM+8xqDL7+GKJF+0cD3zc7sksc/kyM0tFTt8aPb6035g6ikI5eKhQP/B+F4M+x5RO5R/k3GxrKCIYyyRY1rUFpnMs0OhRhAwT6RVvCw+zeA8q6wlwiwjzfdQo0om4cwEXq6FitjfrKWy6XTuMpROIOKGnak2xUq560mMbPYofHHVakR1ZKACtK7MBXrxnkp26E20rUolYUx3FaDrRczZOLCb8zVsv5YJTJlrfGcfLOmPbCNXaYHoAZT0exZLRKHoIr9U9isbQk1LB7TsMJkX22RP5tv82/cIUHRYrg89KhPBeUiPp+NoW3G1m3PTOQqUhL99byez0ehqMoajWlO7hMpgcbS9Z3Trd6AT9eq2RdJzFQlkXYzXvNtOJGDFxvKZ8qdK1gYrFhLG00+/JX6FrXte08fjB0UUAjs47hqKdKYUf/oWXtP1e/BrFQsBkv2656rwdHd3/5y7Z7Q4u6jdmYV8p1fpSFR0mZpv2Hf6GgAaTIlutKbfB5WqRS8YpVxXLxUrf52UbvBP7wqIXg241bg1FBCacsVAoky9W3Q+sHhOsUqmpwXgUOl5u+gTBYENPuVSCY4sFT+ipP5fGaCbBscVi4NAicLJWsrpoaaXcWyv1iZxTge1vmWH6ExmP4sAxx6M4uqg9ij7PPU8l4g2CbJiQvxr82lX7BvbcWc/CvliotKy8bkU6pOAurIbCYOZSwOpWZUN9tz+XL7F3KjfQ10jGJdQrHfW09B8EVsyOwDti05tuaXa9J1ecndpA2ozrRcsxFMajGNzHZYYx9TP0BM5u6PB89BjMrJ4YuFLqLcXQtPHwt3JwPQo39OR4FEe0R9GqhUen+ENPCyu9d44dRrzdXsNajHeCiJNVWPR5FGHtOwzbxzJuodtaGYqT+fLANYoonWnQc7OtoYigPpOiosMijR7FfESjrl5JuoZC9VRf0C5m0txKqYpI//rqj2US7oIctpCY6tZCj80IJ7JOBfaiLx11JBUnJs7nWK7W3BnLx3SNQbnFhLtOScdjlDyCrCPk9yf0NEx4GzqGNQTslHSieRxqWPsOQzwm7mz01Q49eXsxDSzrqY3WLblU3O1HNwisoYjAO5NiuVQXR1OJGImYRJbV90qywaPQaaMD6vUEjvFbLjlZT9k+VpiOphPuFz3MUJjq1l40Cmj2KMzC5fTtcmpinjm+TKWmOGfHKIvFils0Ce1VPLdDU9ZTH2ZRDCPGwy1WajpZoXdj6LQubww9HV80HkV4B1yjU6y2R2Gu15oanMdv6iiiNm+DnnJnDUUE3il3po+MIZeql9UPxqNwFi1vRXE/GvWF4Rbc9blViPeLGx56qmsUvezKxnWXWLf4y/PaThuPCk9ofeLlZzuTEI8uFChXayRi0jfjGJT11I9FdNhIxZ1EhJVStaFlSi9kknE3ecMwly8RE5rad3jZPenoA6vZYhwavfxBpCBDex7FoMVsaygiMBrF/ErZ7UpqyKUSnIyYOtUr5jm9GsWgLkRwLsaKHjDUz7kX3p10WFO4bNITeuqDRhGUgTOWdmpinji6hAj8yNlbATi6UKRc7W/mmjfrSSm1pmL2IBERd3jRYqHSc+U5OLtyv0exrBNJotKLjaC9mkOLoDHBZNBjAFp5FFbMXiPMLtD0y/G2B8il43WNYgCGwhR/latqYC2MvRjd5cRSqa9fNm9qX9iu2quP9GIoxrNOTyeTDtrkUaxU+MGxRfZO5ThNF2YdWyxQrqq+tmFx5p3rGpiyU4ezET0KqFcm98sYZpLxpoK7fKlCrkWx4x4delptj8KbHTg4jaIe8g6/z2DnZltDEUEqESOdiHFEZ+14L4pcKu5mPQ2mjqI5PXbQWU/g9NTpZ+jJu8sM1SjcPlOVnsVsgEN6hrI/7LVQKHPg6BLn7Bhlx7gT7z4yX+h7B+Ckx6MwtRveEaIbCaMpLBUrPTc9hGAxe7lUbdhwBPGSUyfZMpLi9G2rXZldv27WOutpkHOzraFowVgm6VbwencruWSiPp5wIHUUQemxA/Qo9LmdWC71NfRk/mbxmIR6Km6/nB7HvXoNRSremNM/nkkyly/x1PElzt4+xlgmyUgq7oaeotp3dEoqEXO/sKZ2Y6N6FE6oSGsU/fIofKGnfLH1BuKcHWPc9wev4ZTJbOT9+k12FTwKd1Z6xIbUfM8GpVNYQ9GCcU96p3ehy6Xj7q5xUKNQQYeeKlUSMRmI52Iwjcfm8qW+NlYzF/BoxCyHXCrOUqFCqdpjwZ02FC+cLDQtWmOZhDYKin3bRwHYMZ7RYrZyCxz7QTpRT481/aU2okYBzuI4u1zqW3gt7StWBKcDQiuPYq3wXq+DauHhehQREQV3yt2AUmRbrjwicpOIHBORh3zH3ykij4vIwyLyQX3sNSJyr4g8qP+9ynP/S/XxAyLyEdGrhoikReQWffwuETnd85jrReQJ/XN93866A8aySQ7PB3gUHqMx6PTYldLgOlMazPko1d8KcLNgRy2U2VTCrX3oVaMAx6Pwt5v2zkI4Z8cYANvH0xxdKFDqt5jtyXoyHkWr6W7rlWwy7hbE9SfrqbngbqVUbalRrBWNDfsG28Ij2qMws1/WzqP4JPBa7wEReTVwHXCxUuoC4EP6puPATymlLgKuBz7jedhHgRuAffrHPOfbgDml1NnAh4EP6NfYAtwIXAFcDtwoIlMdnl/PjGcS7g4n58t6MgzGUOj02KoZijJY5897bv0MPfmro4PwGod+hJ7mV8rudD2Dd6E+a7sTx945nuHoYoFyn8fZerOe3K6qGzb0FOe4NhR9E7O70CjWinQihnGUBx16ivJYzHqUH1B1dstvh1Lq28Cs7/A7gD9VShX1fY7pf7+nlDqk7/MwkNEewy5gXCl1p3Jk+U8Dr9f3uw74lP7/54GrtbdxLXC7UmpWKTUH3I7PYK0G3ovf22bau5MYVFNAcPoQmTGLg6QhrNbP9Fi3g2v4F937ev0IPQFNLcFNZfTeLVn3S+WEnooD8Shqyhk4tbgJQk+m8LRvldmVZo1itdNe28X0KgMG1hQw14ZGYTZka+lRBHEO8AodKvqWiLws4D4/B3xPG5PdwEHPbQf1MfS/zwMopSrAPLDVezzgMQ2IyA0isl9E9s/MzHR5SsF4++s3Zj0N1qOo11Eoij0WorVDvxZrP/XQU4RHkeqPR+E1Rv4KXbNQ79s+5h7bMZ6hVKm585j7hfnsStWa219qI7bwgMZMvH5VZvtDT8ul6tAaCqh/XwalUZiODFEaxehaaxQhJIAp4Ergd4DPGc0BQEQuwAkhvd0cCngO1eK2qMc0HlTqY0qpy5RSl01PT7d3Bm3i3QmO+NJjDYPt9VQb6Lxsg9fw9TX0lGrtUTSEnnr4siXisQbx3IvRKPbtGHWP7Rh3+gMdnFsh0efQEzhV9YuFcmTG13rH+3n1S6No8ihKlYbQ6LCRGbBH4YySTUT2sRr03Oxuz+wg8EXlcDdQA7YBiMge4O+BtyqlnvTcf4/n8XuAQ57b9urHJoAJnFCXezzgMauGVwTNhYSeBjMK1aNRlKsD7fMEg/MoxtoQs72v3avnZMJP/kXLHD/H41HsnHBqKU7my/3VKBJeQ1GJzPha73g/r75oFIk41Zpyh0mVKjXK1dWfM9EJ5vodpNf/1794Kf/+5WeE3u56FGulUYTwJeAqABE5B0gBx0VkEvgq8B6l1HfNnZVSh4FFEblSex5vBb6sb74VR/gGeANwh9YxbgOuEZEpLWJfo4+tKubiTyViDXFs7w58EBqFv814P3f5QZgBQtBfjWIknXD69OTCZzZn+6iPmM/LbyguOGWcD/zcRfzExbvcY9vH6hPrBhF6KmpDsVH1CWj87PolZkN9eFG/56MMgmwb6au98sNnbWPXRHiNyKDnZrf864vIzcCrgG0ichAnE+km4CadMlsCrldKKRH5NeBs4A9E5A/0U1yjxe534GRQZYGv6R+ATwCfEZEDOJ7EmwCUUrMi8j7gHn2/9yql/KL6wDFxV//C402/HGh6bMWpzN4yMlhDISLkUk6/mGwfv5TJeIyP/eJlXLwnfERlv7KeoO45+DUKEeEXXnZqw7Ht4/VupP009mmPRtGvrqrDijfc0o/OrWnPONSxTH2H7E93HibqYvbavUd3bvaANIqWn6xS6s0hN70l4L5/DPxxyPPsBy4MOF4A3hjymJtwjNKaYXZJ/p2ud3EbbGW20llPg6+NzKXijqHoswv9Y+dHj+9s0Ef6FHpqZ3ebTsTZMpJidrkUOS+7U7waxcLKxvYoMm7YJdYXY2sWW9NB1qR7rgePYtAJJ60YSceHTqPYNJgvuT+P2+yeRHCna/UT85yuRrEKF6ExhqvegdPTL6dfGkW7u9vterxmso+foVej6Oe87GHELOz98pq8HgXUs3iGORmgne6uq8EgW41bQ9EC8yX3u771ObaxgQiVDYOLKr21tmgXs2sbtB7iJxuSTdYNnRqKnROOTtHvOgowoafKhq3Khrph70dDQO/zGY1ieR14FG7W0xp7FKMDHIdqDUUL6obC51GYqVMD6r8UjwnxmLhi9mqFnqC/WU9tvW5DT/8+hZ7aXLh2aEF7UKEnR6MY3kWuV4w32I+GgFDflbuhJ+1RDLNGMSwexSDHoVpD0YKw0FM7U6d6JRkXd2b2auxWsmsWeqr/LeM9hoDGO/QodmiPYhDpscWK01V1Y4vZJvTUb4/CCT3ly8Of9TSuOxFHDVZaDUYGOLxoeP/6Q4LZKfmbkmVXxVDEWC5WUGp13NqRNQo9mX45/fBkJnPti9mAO5diEOmxc8tlamrjtu+Aupjdr4FB5jqvexTDn/X0Sz9yBledt32t3wbv+fEXDey5N+4V3CeSutrXL0iaRXWQrb9T8ZjbK2g1xezVDj2JCLlkvC+ezGvO38F7r7uA83aOtb4zntDTANJjTyw7zfLGI2Y9r3eMR+Fvwtj18/nFbFNHkRzepWp6LM30WLr1HQfM+aeMD+y5h/evP0T8rze/lLOmRxuOZZLOLnjQHoVpU70qGkXahJ5W/7LIpuJ9MVC5VIK3/tDpbd/fiNn9beHhnMeJJWcC4kb2KIz32bfQU6JRzDYexWp7uZZGNu4V3EdeHeBWml3wIPo8GZIJqXsUq1DM4wr0ayDKZVPxNckaMUV3qQGEno67hmIDexR6A9MvQ9GUHluqNk0rtKw+1lD0QDaVGLhHseB6FINfRF//0t1sH8+siSiXSybWZNe4bSTNW648lR89p3/NJFO+0NOG9iiSfdYoAgruhnVo0WZi417Bq8BIerAeRSoeY37FMRTeorRB8aJd47xo1+DinFFM5JJ9y8XvhFhM+OPXX9TX53QNhfYoNnIdxWQuRToRY89Uri/P15T1NMRDizYT9hPogWwyvgoaxeqFntaSP/3Zi0jENkZ4wWwe6pPfNm7oaSKb5LvvvootEU0fO8GEPV2NojS8Q4s2E9ZQ9MDPXrK7L43QwkjGxc2LHtRQlGHhTF+ywHrGpNrWPYqNaygAto32L+MnFhNSiRgFHXpaLg730KLNgjUUPXDDj5410Of3pmyuRtaTpT+IOItdqVIjERP72XVIOhGj6IaeKkNdbLdZsFfwEOMNa612bYOlN0z4aSyzcYcWDYpMMu6K2cvF6lAX220WrKEYYrxdade64ZilM4yR38j6xKDIJGMeMdt6FMOANRRDTGPoyRqK9YTXo7B0RiYR94jZ1qMYBqyhGGK8HU1tnHt9UfcorKHolEyy0VBkh7h9x2bBrj5DjLdGY6Onx240jKHY6BlPgyCdiFGs1FBKsVyqWI9iCLCGYogxaZapRGzNWxhbOqMeerKGolOMR1Eo11BquFuMbxZaGgoRuUlEjonIQ77j7xSRx0XkYRH5oOf4e0TkgL7tWs/xS0XkQX3bR0SngohIWkRu0cfvEpHTPY+5XkSe0D/X9+WM1xFGo8jYPjfrDht66h4jZptpbdajWHvaWYE+CbzWe0BEXg1cB1yslLoA+JA+fj7wJuAC/Zi/EhHzKX8UuAHYp3/Mc74NmFNKnQ18GPiAfq4twI3AFcDlwI0iMtXVWa5TXENhhex1Rz30ZA1Fp6STcQqVqjvdznoUa09LQ6GU+jYw6zv8DuBPlVJFfZ9j+vh1wGeVUkWl1NPAAeByEdkFjCul7lRKKeDTwOs9j/mU/v/ngau1t3EtcLtSalYpNQfcjs9gbXTMYmNbLK8/0jY9tmtMwV2+rD0Ke/2vOd3GNM4BXqFDRd8SkZfp47uB5z33O6iP7db/9x9veIxSqgLMA1sjnqsJEblBRPaLyP6ZmZkuT2n4MBqFFbLXH0ajGM/a3XCnmII7M//ZbpTWnm4NRQKYAq4Efgf4nPYCghRXFXGcLh/TeFCpjymlLlNKXTY93b920WtNPfRkNYr1hi246x6njqJG3tUorLFda7pdgQ4CX1QOdwM1YJs+vtdzvz3AIX18T8BxvI8RkQQwgRPqCnuuTYMxFBu9IeBGxIrZ3eOI2XWPwjYFXHu6NRRfAq4CEJFzgBRwHLgVeJPOZDoDR7S+Wyl1GFgUkSu15/FW4Mv6uW4FTEbTG4A7tI5xG3CNiExpEfsafWzTYMIXts/T+sOmx3ZPJhmnUlPu0C47j2LtafkJiMjNwKuAbSJyECcT6SbgJp0yWwKu14v7wyLyOeARoAL8qlKqqp/qHTgZVFnga/oH4BPAZ0TkAI4n8SYApdSsiLwPuEff771KKb+ovqFxNQobelp3WI+ie0wiwNyy06bdTrhbe1pexUqpN4fc9JaQ+78feH/A8f3AhQHHC8AbQ57rJhyjtClJ2PTYdYs1FN1jrvfZvDYU1qNYc+xWdYhJuQV31lCsN2wLj+4xHvSsHvxkQ69rjzUUQ0wy4YSebHrg+uPFeyb5oTO3Wm+wC1yPYrlENhknbtvXrDnWpxti6llP1p6vN1530S5ed9GutX4b65K09qBPLJds+44hwa5AQ0zShp4smxCzMZrLl6w+MSRYQzHEpKyYbdmEmI3R7HLJ1lAMCdZQDDFJt47CfkyWzYMRsxcLFWsohgS7Ag0x9ToK+2WxbB6817tt3zEcWEMxxJhRqNZQWDYT3uvdehTDgTUUQ4yJ1dovi2UzkfYM6rLtO4YDayiGmBftGuODb7iYV567cTriWiytaPAobHrsUGDN9RAjIvz8ZXtb39Fi2UB4e5vZ9NjhwHoUFotlqPDWDdmw63BgDYXFYhkqYjFxa4isRjEcWENhsViGDiNoW41iOLCGwmKxDB1mqqP1KIYDaygsFsvQYQRtq1EMB9ZQWCyWocOkyNqsp+HAGgqLxTJ0WI1iuLCGwmKxDB0Zq1EMFdZQWCyWocNqFMNFS0MhIjeJyDERechz7A9F5AURuV//vE4fT4rIp0TkQRF5VETe43nMpfr4ARH5iIiIPp4WkVv08btE5HTPY64XkSf0z/V9PXOLxTK0mKI72z12OGjHo/gk8NqA4x9WSr1E//yDPvZGIK2Uugi4FHi7Z+H/KHADsE//mOd8GzCnlDob+DDwAQAR2QLcCFwBXA7cKCJTnZ2exWJZj9TFbOtRDAMtDYVS6tvAbJvPp4AREUkAWaAELIjILmBcKXWnUkoBnwZerx9zHfAp/f/PA1drb+Na4Hal1KxSag64nWCDZbFYNhjpRIyYNHaStawdvXwKvyYiD+jQlNnpfx5YBg4DzwEfUkrNAruBg57HHtTH0P8+D6CUqgDzwFbv8YDHNCAiN4jIfhHZPzMz08MpWSyWYSCTijOSSqAj1JY1pltD8VHgLOAlOEbhz/Txy4EqcApwBvBbInImEPRpK/1v2G1Rj2k8qNTHlFKXKaUum562LbktlvXOGy/dw+/++Hlr/TYsmq4MhVLqqFKqqpSqAX+DYyAA/g3wdaVUWSl1DPgucBmON7DH8xR7gEP6/weBvQA6ZDWBE+pyjwc8xmKxbGBeeuoUv3jlaWv9NiyargyF1hwMPwOYjKjngKvEYQS4EnhMKXUYWBSRK7X+8Fbgy/oxtwImo+kNwB1ax7gNuEZEpnRo6xp9zGKxWCyrSMvcMxG5GXgVsE1EDuJkIr1KRF6CEwp6Bni7vvtfAn+LYzgE+Ful1AP6tnfgZFBlga/pH4BPAJ8RkQM4nsSbAJRSsyLyPuAefb/3ar3DYrFYLKuIOJv3jcNll12m9u/fv9Zvw2KxWNYVInKvUuqyoNts7pnFYrFYIrGGwmKxWCyRWENhsVgslkisobBYLBZLJNZQWCwWiyWSDZf1JCIzwLM9PMU24Hif3s56YTOeM2zO896M5wyb87w7PefTlFKBrS02nKHoFRHZH5YitlHZjOcMm/O8N+M5w+Y8736esw09WSwWiyUSaygsFovFEok1FM18bK3fwBqwGc8ZNud5b8Zzhs153n07Z6tRWCwWiyUS61FYLBaLJRJrKCwWi8USiTUUGhF5rYg8LiIHROTda/1+BoWI7BWRfxKRR0XkYRH5DX18i4jcLiJP6H+nWj3XekNE4iLyPRH5iv59M5zzpIh8XkQe05/5D2308xaR/6Sv7YdE5GYRyWzEc9ZjqI+JyEOeY6HnKSLv0evb4yJybSevZQ0FzgKCM0vjx4HzgTeLyPlr+64GRgX4LaXUi3AGS/2qPtd3A/+olNoH/KP+faPxG8Cjnt83wzn/T5ypk+cBL8Y5/w173iKyG/h14DKl1IVAHGfGzUY8508Cr/UdCzxP/R1/E3CBfsxf6XWvLayhcLgcOKCUekopVQI+C1y3xu9pICilDiul7tP/X8RZOHbjnO+n9N0+Bbx+Td7ggBCRPcBPAB/3HN7o5zwO/CjOcDCUUiWl1Ek2+HnjDGTL6tHKOZwRyhvunJVS38YZ9uYl7DyvAz6rlCoqpZ4GDlAfYd0SaygcdgPPe34/qI9taETkdOClwF3ADj2yFv3v9jV8a4PgfwC/C9Q8xzb6OZ8JzAB/q0NuH9cjijfseSulXgA+hDOW+TAwr5T6Bhv4nH2EnWdPa5w1FA4ScGxD5w2LyCjwBeA3lVILa/1+BomI/CRwTCl171q/l1UmAVwCfFQp9VJgmY0RcglFx+SvA84ATgFGROQta/uuhoKe1jhrKBwOAns9v+/BcVc3JCKSxDES/0cp9UV9+KiI7NK37wKOrdX7GwA/Avy0iDyDE1a8SkT+jo19zuBc1weVUnfp3z+PYzg28nn/GPC0UmpGKVUGvgj8MBv7nL2EnWdPa5w1FA73APtE5AwRSeGIPreu8XsaCCIiODHrR5VSf+656Vbgev3/64Evr/Z7GxRKqfcopfYopU7H+WzvUEq9hQ18zgBKqSPA8yJyrj50NfAIG/u8nwOuFJGcvtavxtHhNvI5ewk7z1uBN4lIWkTOAPYBd7f7pLYyWyMir8OJY8eBm5RS71/bdzQYROTlwHeAB6nH638fR6f4HHAqzpftjUopv1C27hGRVwG/rZT6SRHZygY/ZxF5CY6AnwKeAn4JZ4O4Yc9bRP4I+AWcDL/vAb8MjLLBzllEbgZehdNO/ChwI/AlQs5TRP4z8O9x/i6/qZT6WtuvZQ2FxWKxWKKwoSeLxWKxRGINhcVisVgisYbCYrFYLJFYQ2GxWCyWSKyhsFgsFksk1lBYLBaLJRJrKCwWi8USyf8P8bou2tkk6xYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=histNum)\n", + "algorithm = ReinforceAlgorithm(game, NN.policy, numberIterations=1, numberEpisodes=1_000_000, discountFactor =0.9)\n", + "algorithm.playTrainedAgent(AdversaryModes.myopic,100 )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f7138f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f99f2b2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a3c5c41", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/debug_Simulations.py b/learningAgents/naive_policy_gradient/debug_Simulations.py new file mode 100644 index 0000000..f07ff51 --- /dev/null +++ b/learningAgents/naive_policy_gradient/debug_Simulations.py @@ -0,0 +1,21 @@ +from learningAgents import ReinforceAlgorithm +from environmentModel import Model, AdversaryModes +from NeuralNetwork import NeuralNetwork +import torch +import torch.nn as nn +from torch.distributions import Categorical + + +adversaryProbs = torch.zeros(len(AdversaryModes)) +adversaryProbs[0] = 0 +adversaryProbs[1] = 0 +adversaryProbs[6] = 1 +advHistoryNum = 3 +game = Model(totalDemand=400, + tupleCosts=(57, 71), + totalStages=25, adversaryProbs=adversaryProbs, advHistoryNum=advHistoryNum) +neuralNet = NeuralNetwork(num_input=3+advHistoryNum) +algorithm = ReinforceAlgorithm( + game, neuralNet, numberIterations=1, numberEpisodes=500_000, discountFactor=0.9) + +algorithm.solver() diff --git a/learningAgents/naive_policy_gradient/environmentModel.py b/learningAgents/naive_policy_gradient/environmentModel.py new file mode 100644 index 0000000..55802f2 --- /dev/null +++ b/learningAgents/naive_policy_gradient/environmentModel.py @@ -0,0 +1,286 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T), [0]*(self.T)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player, t): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player, self.stage) + + def const(self, player, price): # constant price strategy + """ + Adversary follows Constant strategy + """ + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return price + + def imit(self, player, firstprice): # price imitator strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return self.prices[1-player][self.stage-1] + + def fight(self, player, firstprice): # simplified fighting strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (self.totalDemand-self.costs[player] + + self.costs[1-player])/2 + + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return self.prices[player][self.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getself.demandPotential to Asp + P = self.prices[1-player][self.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (self.totalDemand+self.costs[0]+self.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + def fight_lb(self, player, firstprice): + P = self.fight(player, firstprice) + # never price less than production cost + P = max(P, self.costs[player]) + return P + + # sophisticated fighting strategy, compare fight() + # estimate *sales* of opponent as their target, kept between + # calls in global variable oppsaleguess[]. Assumed behavior + # of opponent is similar to this strategy itself. + oppsaleguess = [61, 75] # first guess opponent sales as in monopoly + + def guess(self, player, firstprice): # predictive fighting strategy + if self.stage == 0: + self.oppsaleguess[0] = 61 # always same start + self.oppsaleguess[1] = 75 # always same start + return firstprice + + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + aspire = [207, 193] # aspiration level + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = self.monopolyPrice(player, self.stage) + pcurrent = self.prices[player][self.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + if pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = self.demandPotential[1 - + player][t-1] - self.prices[1-player][t-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * self.oppsaleguess[player] + (1-alpha)*prevsales + # update + self.oppsaleguess[player] = newsalesguess + guessoppPrice = 400 - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, adversaryProbs, advHistoryNum) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + + self.rewardFunction = self.profits + + # [stage, agent's demand potential, agent's last price, history of adversary's prices] + self.initState = [ + 0, totalDemand/2, ((totalDemand/2) + tupleCosts[0])/2] + ([0]*advHistoryNum) + self.episodesMemory = list() + self.done = False + self.adversaryProbs = adversaryProbs + # number of previous adversary's action we consider in the state + self.advHistoryNum = advHistoryNum + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return torch.tensor(self.initState, dtype=torch.float32), reward, self.done + + def resetAdversary(self): + adversaryDist = Categorical(self.adversaryProbs) + adversaryInd = (adversaryDist.sample()).item() + self.adversaryMode = AdversaryModes(adversaryInd) + # print(self.adversaryMode) + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + if self.adversaryMode == AdversaryModes.constant_132: + return self.const(player=1, price=132) + elif self.adversaryMode == AdversaryModes.constant_95: + return self.const(player=1, price=95) + elif self.adversaryMode == AdversaryModes.imitation_128: + return self.imit(player=1, firstprice=128) + elif self.adversaryMode == AdversaryModes.imitation_132: + return self.imit(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_100: + return self.fight(player=1, firstprice=100) + elif self.adversaryMode == AdversaryModes.fight_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_lb_125: + return self.fight_lb(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_132: + return self.fight(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_lb_132: + return self.fight_lb(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.guess_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.guess_132: + return self.fight(player=1, firstprice=132) + else: + return self.myopic(player=1) + + def step(self, state, action): + """ + Transition Function. + Parameters: + - action: Price + - state: tupple in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + adversaryAction = self.adversaryChoosePrice() + myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [self.myopic() - action, adversaryAction]) + + done = (self.stage == self.T-1) + + + if not done: + newState = [self.stage+1, self.demandPotential[0] + [self.stage + 1], self.prices[0][self.stage]] + else: + newState = [self.stage+1, 0, self.prices[0] + [self.stage]] + + if(self.advHistoryNum>0): + advHistory = [0]*self.advHistoryNum + j = self.advHistoryNum-1 + for i in range(self.stage, max(-1, self.stage-self.advHistoryNum), -1): + advHistory[j] = self.prices[1][i] + j -= 1 + + newState+= advHistory + + + reward = self.rewardFunction() + self.stage = self.stage + 1 + + return torch.tensor(newState, dtype=torch.float32), reward, done + + +class AdversaryModes(Enum): + myopic = 0 + constant_132 = 1 + constant_95 = 2 + imitation_132 = 3 + imitation_128 = 4 + fight_132 = 5 + fight_lb_132 = 6 + fight_125 = 7 + fight_lb_125 = 8 + fight_100 = 9 + guess_132 = 10 + guess_125 = 11 diff --git a/learningAgents/naive_policy_gradient/learningAgents.py b/learningAgents/naive_policy_gradient/learningAgents.py new file mode 100644 index 0000000..a860c3a --- /dev/null +++ b/learningAgents/naive_policy_gradient/learningAgents.py @@ -0,0 +1,178 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +from torch.distributions import Categorical +import numpy as np # numerical python +from matplotlib import pyplot as plt +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + self.returns = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def savePolicy(self): + pass + + def solver(self): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + for episode in range(self.numberEpisodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + + if episode % 10_000 == 0: + startState = self.normaliseState(state) + probs = self.policy(startState) + print(probs) + + while not done: + prevState = state + normPrevState = self.normaliseState(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + if episode % 10_000 == 0: + print(episode) + print(actions) + + action_probs = self.policy(states) + action_dists = Categorical(action_probs) + action_logprobs = action_dists.log_prob(actions) + + discReturns = self.returnsComputation(rewards, episodeMemory) + + # sum of the our player's rewards rounds 0-25 + self.returns[iteration][episode] = discReturns[0] + + if episode % 10_000 == 0: + print(discReturns[0]) + + discReturns/= 1000 + + loss = - (torch.sum(discReturns*action_logprobs)) / len(episodeMemory) + + self.optim.zero_grad() + loss.backward() + self.optim.step() + + + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + """ + return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normaliseState(self, state): + normalised = [0]*len(state) + normalised[0] = state[0]/(self.env.T) + for i in range(1, len(state)): + normalised[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalised) + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normaliseState(prevState) + probs = self.neuralNetwork(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + retu = retu + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + print(f"episode {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + plt.plot(returns) + plt.show() diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Optim,Play-checkpoint.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Optim,Play-checkpoint.ipynb new file mode 100644 index 0000000..33d0828 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Optim,Play-checkpoint.ipynb @@ -0,0 +1,120 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame\n", + "import globals as gl\n", + "from environmentModelBase import Model\n", + "from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType\n", + "from neuralNetworkSimple import NNBase\n", + "import numpy as np\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def create_nn_strategy(name):\n", + " nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions)\n", + " nn.load(name)\n", + " return Strategy(StrategyType.neural_net,NNorFunc=neural_net, name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "low_nn_names=[\"low,1684386202\",\"low,1684484716\",\"low,1684557152\",\"low,1684856358\",\"low,1685028503\"]\n", + "low_strategies = [create_nn_strategy(name) for name in low_nn_names]\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "high_nn_names=[\"high,1684424924\",\"high,1684821735\"]\n", + "high_strategies = [create_nn_strategy(name) for name in high_nn_names]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bimatrix_game = BimatrixGame.BimatrixGame(low_strategies, high_strategies)\n", + "equilibria=BimatrixGame.run_tournament(bimatrix_game=bimatrix_game,number_rounds= 4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..363fcab --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/small optim play-checkpoint.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/small optim play-checkpoint.ipynb new file mode 100644 index 0000000..45788aa --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/.ipynb_checkpoints/small optim play-checkpoint.ipynb @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame\n", + "import globals as gl\n", + "from environmentModelBase import Model\n", + "from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType\n", + "from neuralNetworkSimple import NNBase\n", + "import numpy as np\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def create_nn_strategy(name):\n", + " nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions)\n", + " nn.load(name)\n", + " return Strategy(StrategyType.neural_net,NNorFunc=nn, name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "low_nn_names=[\"low,1684386202\",\"low,1684484716\",\"low,1684557152\",\"low,1684856358\",\"low,1685028503\"]\n", + "low_strategies = [create_nn_strategy(name) for name in low_nn_names]\n", + "low_strategies" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "high_nn_names=[\"high,1684424924\",\"high,1684821735\"]\n", + "high_strategies = [create_nn_strategy(name) for name in high_nn_names]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "equi: [0.00, 0.00, 0.00, 0.00, 1.00], [1.00, 0.00], 126449.42, 56561.34\n", + "Round 0 of 100\n", + "Round 1 of 100\n", + "Round 2 of 100\n", + "Round 3 of 100\n" + ] + } + ], + "source": [ + "bimatrix_game = BimatrixGame.BimatrixGame(low_strategies, high_strategies)\n", + "equilibria=BimatrixGame.run_tournament(bimatrix_game=bimatrix_game,number_rounds= 100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/BimatrixGame.py b/learningAgents/naive_policy_gradient/optim_PGM_base/BimatrixGame.py new file mode 100644 index 0000000..a6e6100 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/BimatrixGame.py @@ -0,0 +1,374 @@ +import globals as gl +import torch +import numpy as np +from environmentModelBase import Model +from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType +from neuralNetworkSimple import NNBase +from fractions import Fraction +import bimatrix +from multiprocessing import Pool +# totalDemand = 400 +# lowCost = 57 +# highCost = 71 +# totalStages = 25 +# adversaryHistroy = 3 +# lr = 0.000005 +# gamma = 1 +# numActions = 3 +# actionStep = 3 +# numStochasticIter = 10 + +# # episodes for learning the last stage, then for 2nd to last stage 2*numEpisodes. In total:300*numEpisodes +# numEpisodes = 3000 +# numEpisodesReset = numEpisodes +# # increase in num of episodes for each adv in support +# episodeIncreaseAdv = 1000 + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, lowCostStrategies, highCostStrategies) -> None: + # globals.initialize() + self.low_strategies = lowCostStrategies + self.high_strategies = highCostStrategies + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, lowIndex, highIndex): + stratL = self.low_strategies[lowIndex] + stratH = self.high_strategies[highIndex] + stratL.reset() + stratH.reset() + + env = Model(totalDemand=gl.total_demand, tupleCosts=(gl.low_cost, gl.high_cost), + totalStages=gl.total_stages, advMixedStrategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.num_stochastic_iter)] + + mean_payoffs=(np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[lowIndex][highIndex], self.matrix_B[lowIndex][highIndex] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f".\games\game{len(self.matrix_A)}x{len(self.matrix_A[0])}.txt", "w") as out: + out.write(output) + with open("game.txt", "w") as out: + out.write(output) + + def add_low_cost_row(self, rowA, rowB): + self.matrix_A = np.append(self.matrix_A, [rowA], axis=0) + self.matrix_B = np.append(self.matrix_B, [rowB], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100,gl.num_trace_equilibria) + equilibria=[] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + low_prob_str = ", ".join(map("{0:.2f}".format, low_cost_probabilities)) + high_prob_str = ", ".join( + map("{0:.2f}".format, high_cost_probabilities)) + print( + f"equi: [{low_prob_str}], [{high_prob_str}], {low_cost_payoff:.2f}, {high_cost_payoff:.2f}") + result={"low_cost_probabilities":low_cost_probabilities, + "high_cost_probabilities":high_cost_probabilities, + "low_cost_payoff":low_cost_payoff, + "high_cost_payoff":high_cost_payoff} + equilibria.append(result) + return equilibria + + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + + +def training(costs, adv_mixed_strategy, target_payoff): + """ + trains a neuralnet against adversaries. if the expected payoff of new agent is greater than payoff, returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + gl.initialize() + acceptable = False + + game = Model(gl.total_demand, costs, gl.total_stages, + advMixedStrategy=adv_mixed_strategy, stateAdvHistory=gl.num_adv_history) + neural_net = NNBase(num_input=game.T+2+game.stateAdvHistory, + lr=gl.lr, num_actions=gl.num_actions) + + number_episodes = gl.num_episodes+gl.episode_adv_increase * \ + (support_count(adv_mixed_strategy._strategyProbs)) + algorithm = ReinforceAlgorithm( + game, neural_net, numberIterations=1, numberEpisodes=number_episodes, discountFactor=gl.gamma) + algorithm.solver() + a = algorithm.returns[0][-1] + print(f"{neural_net.name} is trained against {str(adv_mixed_strategy)}") + + agent_payoffs = np.zeros(len(adv_mixed_strategy._strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy._strategies)) + expected_payoff = 0 + for strategy_index in range(len(adv_mixed_strategy._strategies)): + if adv_mixed_strategy._strategyProbs[strategy_index] > 0: + returns = algorithm.play_trained_agent(adversary=( + (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + agent_payoffs[strategy_index] = torch.mean(returns[0]) + adv_payoffs[strategy_index] = torch.mean(returns[1]) + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy._strategyProbs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy._strategies)): + if adv_mixed_strategy._strategyProbs[strategy_index] == 0: + returns = algorithm.play_trained_agent(adversary=( + adv_mixed_strategy._strategies[strategy_index].to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + agent_payoffs[strategy_index] = torch.mean(returns[0]) + adv_payoffs[strategy_index] = torch.mean(returns[1]) + algorithm.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, Strategy(strategyType=StrategyType.neural_net, NNorFunc=neural_net, name=neural_net.name)] + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + + +# def run_tournament_random(number_rounds): +# equilibria = [] +# neural_net = NNBase(num_input=gl.total_stages+2+gl.num_adv_history, +# lr=gl.lr, num_actions=gl.num_actions) +# neural_net.reset() +# rand_strategy = Strategy(StrategyType.neural_net, +# NNorFunc=neural_net, name="nnRandom") +# low_cost_players = [rand_strategy] +# high_cost_players = [rand_strategy] +# bimatrix_game = BimatrixGame(low_cost_players, high_cost_players) +# # bimatrixGame.reset_matrix() +# bimatrix_game.fill_matrix() +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() +# for round in range(number_rounds): +# print("Round", round, " of ", number_rounds) + +# update = False +# # inputs = [([gl.low_cost, gl.high_cost], MixedStrategy(strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), low_cost_payoff), ([ +# # gl.high_cost, gl.low_cost], MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), high_cost_payoff)] +# # with Pool() as pool: +# # results = pool.starmap(training, inputs) + +# # [low_acceptable, low_agent_payoffs, +# # low_adv_payoffs, low_cost_player] = results[0] +# # [high_acceptable, high_agent_payoffs, +# # high_adv_payoffs, high_cost_player] = results[1] + + +# # training([gl.low_cost, gl.high_cost], adv_mixed_strategy=MixedStrategy( +# # strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), target_payoff=low_cost_payoff) +# acceptable, agent_payoffs, adv_payoffs, low_cost_player = training([gl.low_cost, gl.high_cost], adv_mixed_strategy=MixedStrategy( +# strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), target_payoff=low_cost_payoff) +# if acceptable: +# update = True +# low_cost_players.append(low_cost_player) +# bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"low cost player {low_cost_player.name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + + +# acceptable, agent_payoffs, adv_payoffs, high_cost_player = training( +# [gl.high_cost, gl.low_cost], adv_mixed_strategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), target_payoff=high_cost_payoff) + +# if acceptable: +# update = True +# high_cost_players.append(high_cost_player) +# bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"high cost player {high_cost_player.name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + +# if update: +# gl.num_episodes = gl.num_episodes_reset +# else: +# gl.num_episodes += 1000 +# return equilibria, bimatrix_game + +def run_tournament(bimatrix_game, number_rounds): + equilibria = [] + + # bimatrixGame.reset_matrix() + bimatrix_game.fill_matrix() + dictionaries = bimatrix_game.compute_equilibria() + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(number_rounds): + print("Round", round, " of ", number_rounds) + inputs=[] + update = [False]* len(dictionaries) + for equilibrium in dictionaries: + + inputs.append(([gl.low_cost, gl.high_cost], MixedStrategy(strategiesList=bimatrix_game.high_strategies, probablitiesArray=equilibrium["high_cost_probabilities"]), equilibrium["low_cost_payoff"])) + inputs.append(([gl.high_cost, gl.low_cost], MixedStrategy(probablitiesArray=equilibrium["low_cost_probabilities"], strategiesList=bimatrix_game.low_strategies), equilibrium["high_cost_payoff"])) + # inputs = [([gl.low_cost, gl.high_cost], MixedStrategy(strategiesList=bimatrix_game.high_strategies, probablitiesArray=high_cost_probabilities), low_cost_payoff), ([ + # gl.high_cost, gl.low_cost], MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=bimatrix_game.low_strategies), high_cost_payoff)] + + with Pool() as pool: + results = pool.starmap(training, inputs) + # results[i]= low-cost stratgey for i = 2n + # high-cost strategy for i=2n+1 + + + + # [low_acceptable, low_agent_payoffs, + # low_adv_payoffs, low_cost_player] = results[0] + # [high_acceptable, high_agent_payoffs, + # high_adv_payoffs, high_cost_player] = results[1] + num_new_rows=0 + for i in range(0,len(results), 2): + # all low-cost strategies of different equilibria are added + [low_acceptable, low_agent_payoffs,low_adv_payoffs, low_cost_player] = results[i] + if low_acceptable: + num_new_rows+=1 + update[int(i/2)]= True + bimatrix_game.low_strategies.append(low_cost_player) + bimatrix_game.add_low_cost_row(low_agent_payoffs, low_adv_payoffs) + equi=dictionaries[int(i/2)] + print(f"low cost player {low_cost_player.name} added, trained with ",[equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + for i in range(1,len(results),2): + [high_acceptable, high_agent_payoffs,high_adv_payoffs, high_cost_player] = results[i] + if high_acceptable: + update[int(i/2)]= True + bimatrix_game.high_strategies.append(high_cost_player) + if num_new_rows>0: + high_adv_payoffs = np.append(high_adv_payoffs, np.zeros(num_new_rows)) + high_agent_payoffs = np.append(high_agent_payoffs, np.zeros(num_new_rows)) + + bimatrix_game.add_high_cost_col( + high_adv_payoffs, high_agent_payoffs) + if num_new_rows>0: + for j in range(num_new_rows,0,-1): + bimatrix_game.update_matrix_entry( + len(bimatrix_game.low_strategies)-j, len(bimatrix_game.high_strategies)-1) + # equilibria.append( + # [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) + equi=dictionaries[int(i/2)] + print(f"high cost player {high_cost_player.name} added, trained with ",[equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + + + # [low_acceptable, low_agent_payoffs, low_adv_payoffs, low_cost_player] = training([gl.low_cost, gl.high_cost], MixedStrategy( + # strategiesList=bimatrix_game.high_strategies, probablitiesArray=high_cost_probabilities), low_cost_payoff) + # [high_acceptable, high_agent_payoffs, high_adv_payoffs, high_cost_player] = training([ + # gl.high_cost, gl.low_cost], MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=bimatrix_game.low_strategies), high_cost_payoff) + + # training([gl.low_cost, gl.high_cost], adv_mixed_strategy=MixedStrategy( + # strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), target_payoff=low_cost_payoff) + # if low_acceptable: + # update = True + # bimatrix_game.low_strategies.append(low_cost_player) + # bimatrix_game.add_low_cost_row(low_agent_payoffs, low_adv_payoffs) + + # print(f"low cost player {low_cost_player.name} added") + + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + + # acceptable, agent_payoffs, adv_payoffs, high_cost_player = training( + # [gl.high_cost, gl.low_cost], adv_mixed_strategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), target_payoff=high_cost_payoff) + + # if high_acceptable: + # update = True + # bimatrix_game.high_strategies.append(high_cost_player) + # if low_acceptable: + # high_adv_payoffs = np.append(high_adv_payoffs, 0) + # high_agent_payoffs = np.append(high_agent_payoffs, 0) + + # bimatrix_game.add_high_cost_col( + # high_adv_payoffs, high_agent_payoffs) + # if low_acceptable: + # bimatrix_game.update_matrix_entry( + # len(bimatrix_game.low_strategies)-1, len(bimatrix_game.high_strategies)-1) + # # equilibria.append( + # # [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) + # print(f"high cost player {high_cost_player.name} added") + + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for i, equi in enumerate(dictionaries): + if update[i]: + equilibria.append( + [equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.num_episodes = gl.num_episodes_reset + else: + gl.num_episodes += 1000 + return equilibria diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/Deep_Q-Learning.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/Deep_Q-Learning.ipynb new file mode 100644 index 0000000..1ac8fcc --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/Deep_Q-Learning.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "authorized-valve", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from collections import deque, namedtuple\n", + "from environment import Model, AdversaryModes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f30716d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_demand = 400\n", + "agent_cost = 57\n", + "adversary_cost = 71 \n", + "costs = [agent_cost,adversary_cost]\n", + "total_stages = 25\n", + "adversary_probabilities=[0]*len(AdversaryModes)\n", + "adversary_probabilities[0]=1\n", + "\n", + "env = Model(total_demand, costs, total_stages, adversary_probabilities)\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d3611c5", + "metadata": {}, + "outputs": [], + "source": [ + "class QNetwork(nn.Module):\n", + "\n", + " def __init__(self, state_size, action_size):\n", + " super().__init__() \n", + " self.input_layer = nn.Linear(state_size, 200)\n", + " self.hidden_layer = nn.Linear(200, 200)\n", + " self.output_layer = nn.Linear(200, action_size)\n", + " \n", + " def forward(self, state):\n", + " x = self.input_layer(state)\n", + " x = F.relu(x)\n", + " x = self.hidden_layer(x)\n", + " x = F.relu(x)\n", + " x = self.output_layer(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2a6a493", + "metadata": {}, + "outputs": [], + "source": [ + "BUFFER_SIZE = int(10_000) # replay buffer size\n", + "BATCH_SIZE = 64 # minibatch size\n", + "GAMMA = 1 # discount factor\n", + "TAU = 0.001 # for soft update of target parameters\n", + "LR = 0.0005 # learning rate \n", + "UPDATE_EVERY = 8 # how often to update the network" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b0612b47", + "metadata": {}, + "outputs": [], + "source": [ + "class Agent():\n", + "\n", + " def __init__(self, state_size, action_size):\n", + "\n", + " self.state_size = state_size\n", + " self.action_size = action_size\n", + "\n", + " # Q-Network\n", + " self.qnetwork_local = QNetwork(state_size, action_size)\n", + " self.qnetwork_target = QNetwork(state_size, action_size)\n", + " self.optimiser = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n", + "\n", + " # Replay memory\n", + " self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE)\n", + " # Initialise time step (for updating every UPDATE_EVERY steps)\n", + " self.t_step = 0\n", + " \n", + " def step(self, state, action, reward, next_state, done):\n", + " # Save experience in replay memory\n", + " self.memory.add(state, action, reward, next_state, done)\n", + " \n", + " # Learn every UPDATE_EVERY time steps.\n", + " self.t_step = (self.t_step + 1) % UPDATE_EVERY\n", + " if self.t_step == 0:\n", + " # If enough samples are available in memory, get random subset and learn\n", + " if len(self.memory) > BATCH_SIZE:\n", + " experiences = self.memory.sample()\n", + " self.learn(experiences, GAMMA)\n", + "\n", + " def act(self, state, eps):\n", + "\n", + " state = state.float().unsqueeze(0)\n", + " self.qnetwork_local.eval()\n", + " with torch.no_grad():\n", + " action_values = self.qnetwork_local(state)\n", + " self.qnetwork_local.train()\n", + "\n", + " # Epsilon-greedy action selection\n", + " if random.random() > eps:\n", + " return np.argmax(action_values.data.numpy())\n", + " else:\n", + " return random.choice(np.arange(self.action_size))\n", + "\n", + " def learn(self, experiences, gamma):\n", + "\n", + " states, actions, rewards, next_states, dones = experiences\n", + " q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n", + " q_targets = rewards + gamma * q_targets_next * (1 - dones)\n", + " q_expected = self.qnetwork_local(states).gather(1, actions)\n", + " \n", + " loss = F.mse_loss(q_expected, q_targets)\n", + " self.optimiser.zero_grad()\n", + " loss.backward()\n", + " self.optimiser.step()\n", + "\n", + " self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \n", + "\n", + " def soft_update(self, local_model, target_model, tau):\n", + " \n", + " for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n", + " target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e60fdc3", + "metadata": {}, + "outputs": [], + "source": [ + "class ReplayBuffer:\n", + "\n", + " def __init__(self, action_size, buffer_size, batch_size):\n", + "\n", + " self.action_size = action_size\n", + " self.memory = deque(maxlen=buffer_size) \n", + " self.batch_size = batch_size\n", + " self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n", + " \n", + " def add(self, state, action, reward, next_state, done):\n", + " \"\"\"Add a new experience to memory.\"\"\"\n", + " experience = self.experience(state, action, reward, next_state, done)\n", + " self.memory.append(experience)\n", + " \n", + " def sample(self):\n", + " \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n", + " experiences = random.sample(self.memory, k=self.batch_size)\n", + "\n", + " states = torch.from_numpy(np.vstack([experience.state for experience in experiences if experience is not None])).float()\n", + " actions = torch.from_numpy(np.vstack([experience.action for experience in experiences if experience is not None])).long()\n", + " rewards = torch.from_numpy(np.vstack([experience.reward for experience in experiences if experience is not None])).float()\n", + " next_states = torch.from_numpy(np.vstack([experience.next_state for experience in experiences if experience is not None])).float()\n", + " dones = torch.from_numpy(np.vstack([experience.done for experience in experiences if experience is not None]).astype(np.uint8)).float()\n", + " \n", + " return (states, actions, rewards, next_states, dones)\n", + "\n", + " def __len__(self):\n", + " \"\"\"Return the current size of internal memory.\"\"\"\n", + " return len(self.memory)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7bff3bfd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0\tAverage Score: 169671.00\n", + "Episode 5000\tAverage Score: 165271.83\n", + "Episode 10000\tAverage Score: 165782.55\n", + "Episode 15000\tAverage Score: 166931.08\n", + "Episode 20000\tAverage Score: 167496.04\n", + "Episode 25000\tAverage Score: 169142.78\n", + "Episode 30000\tAverage Score: 171067.50\n", + "Episode 35000\tAverage Score: 171962.95\n", + "Episode 40000\tAverage Score: 172211.15\n", + "Episode 45000\tAverage Score: 172176.92\n", + "Episode 50000\tAverage Score: 173292.13\n", + "Episode 55000\tAverage Score: 174271.68\n", + "Episode 60000\tAverage Score: 176350.42\n", + "Episode 65000\tAverage Score: 177105.63\n", + "Episode 70000\tAverage Score: 178208.86\n", + "Episode 75000\tAverage Score: 177706.84\n", + "Episode 80000\tAverage Score: 177841.97\n", + "Episode 85000\tAverage Score: 176620.66\n", + "Episode 90000\tAverage Score: 177956.96\n", + "Episode 95000\tAverage Score: 177746.00\n", + "Episode 100000\tAverage Score: 178210.52\n", + "Episode 105000\tAverage Score: 177339.47\n", + "Episode 110000\tAverage Score: 177947.92\n", + "Episode 115000\tAverage Score: 177841.17\n", + "Episode 120000\tAverage Score: 177980.15\n", + "Episode 125000\tAverage Score: 177477.03\n", + "Episode 130000\tAverage Score: 178026.23\n", + "Episode 135000\tAverage Score: 178510.44\n", + "Episode 140000\tAverage Score: 178235.72\n", + "Episode 145000\tAverage Score: 178676.76\n", + "Episode 150000\tAverage Score: 177196.13\n", + "Episode 155000\tAverage Score: 176133.93\n", + "Episode 160000\tAverage Score: 178601.00\n", + "Episode 165000\tAverage Score: 178233.33\n", + "Episode 170000\tAverage Score: 177109.69\n", + "Episode 175000\tAverage Score: 178397.17\n", + "Episode 180000\tAverage Score: 178324.12\n", + "Episode 185000\tAverage Score: 178026.06\n", + "Episode 190000\tAverage Score: 178197.18\n", + "Episode 195000\tAverage Score: 177351.39\n", + "Episode 199999\tAverage Score: 178157.79" + ] + } + ], + "source": [ + "def dqn(number_episodes, eps_start=1.0, eps_end=0.0001, eps_decay=0.99995):\n", + "\n", + " scores = [] # list containing scores from each episode\n", + " scores_window = deque(maxlen=100) # last 100 scores\n", + " eps = eps_start # initialise epsilon\n", + " best_payoff = 0\n", + " best_actions = list()\n", + " for episode in range(number_episodes):\n", + " state, reward, done = env.reset()\n", + " score = 0\n", + " actions = list()\n", + " while not done:\n", + " action = agent.act(state, eps)\n", + " actions.append(action)\n", + " next_state, reward, done = env.step(action)\n", + " agent.step(state, action, reward, next_state, done)\n", + " state = next_state\n", + " score += reward\n", + " scores_window.append(score) # save most recent score\n", + " scores.append(score) # save most recent score\n", + " eps = max(eps_end, eps_decay*eps) # decrease epsilon\n", + " if score >= best_payoff:\n", + " best_payoff = score\n", + " best_actions = actions\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)), end=\"\")\n", + " if episode % 5000 == 0:\n", + " print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_window)))\n", + " return scores, best_payoff, best_actions\n", + "\n", + "agent = Agent(state_size=2, action_size=60)\n", + "scores, best_payoff, best_actions = dqn(200_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "empirical-friday", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the scores\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(np.arange(len(scores)), scores)\n", + "plt.ylabel('Score')\n", + "plt.xlabel('Episode #')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c8a33b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "180121" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_payoff" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7d0864cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([48, 52, 52, 52, 52, 50, 50, 50, 50, 50, 50, 50, 50, 50, 46, 46, 46,\n", + " 46, 46, 46, 46, 46, 46, 20, 4])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.transpose(best_actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c75ca275", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "177990.99859985997" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e9ffcee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "925.9989800259722" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std(scores[190_000:199_999])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29f8804a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684424924.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684424924.pt new file mode 100644 index 0000000..f1effd5 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684424924.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684821735.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684821735.pt new file mode 100644 index 0000000..8faf086 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/high,1684821735.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684386202.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684386202.pt new file mode 100644 index 0000000..a6491b9 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684386202.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684484716.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684484716.pt new file mode 100644 index 0000000..2a4790e Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684484716.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684557152.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684557152.pt new file mode 100644 index 0000000..e987095 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684557152.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684856358.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684856358.pt new file mode 100644 index 0000000..724e10b Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1684856358.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1685028503.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1685028503.pt new file mode 100644 index 0000000..fc37669 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/good NNs/low,1685028503.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684424924.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684424924.pt new file mode 100644 index 0000000..f1effd5 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684424924.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684821735.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684821735.pt new file mode 100644 index 0000000..8faf086 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high,1684821735.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133103.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133103.pt new file mode 100644 index 0000000..bbbce7f Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133103.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133233.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133233.pt new file mode 100644 index 0000000..bac0db9 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133233.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133322.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133322.pt new file mode 100644 index 0000000..bd9e19e Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686133322.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739675.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739675.pt new file mode 100644 index 0000000..b614b97 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739675.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739845.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739845.pt new file mode 100644 index 0000000..69533c2 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739845.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739930.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739930.pt new file mode 100644 index 0000000..7fcd3cc Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686739930.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740420.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740420.pt new file mode 100644 index 0000000..cf2921d Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740420.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740582.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740582.pt new file mode 100644 index 0000000..f9c5d25 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686740582.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742693.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742693.pt new file mode 100644 index 0000000..7a6c8c6 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742693.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742706.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742706.pt new file mode 100644 index 0000000..bf5e848 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742706.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742771.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742771.pt new file mode 100644 index 0000000..3f9597c Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686742771.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745362.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745362.pt new file mode 100644 index 0000000..0e25f34 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745362.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745372.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745372.pt new file mode 100644 index 0000000..5f3d28a Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745372.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745600.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745600.pt new file mode 100644 index 0000000..a195b36 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745600.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745704.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745704.pt new file mode 100644 index 0000000..b8b732e Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686745704.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686746596.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686746596.pt new file mode 100644 index 0000000..a5d925f Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1686746596.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687145369.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687145369.pt new file mode 100644 index 0000000..0defc01 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687145369.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687146254.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687146254.pt new file mode 100644 index 0000000..5b80564 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/high_1687146254.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684386202.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684386202.pt new file mode 100644 index 0000000..a6491b9 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684386202.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684484716.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684484716.pt new file mode 100644 index 0000000..2a4790e Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684484716.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684557152.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684557152.pt new file mode 100644 index 0000000..e987095 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684557152.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684856358.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684856358.pt new file mode 100644 index 0000000..724e10b Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1684856358.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1685028503.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1685028503.pt new file mode 100644 index 0000000..fc37669 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low,1685028503.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686168343.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686168343.pt new file mode 100644 index 0000000..dd0f543 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686168343.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686169040.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686169040.pt new file mode 100644 index 0000000..b71bc42 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686169040.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742712.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742712.pt new file mode 100644 index 0000000..917b16a Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742712.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742743.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742743.pt new file mode 100644 index 0000000..be913c0 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742743.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742756.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742756.pt new file mode 100644 index 0000000..b18d6c4 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686742756.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745446.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745446.pt new file mode 100644 index 0000000..1fd1f88 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745446.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745494.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745494.pt new file mode 100644 index 0000000..9e63c84 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745494.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745564.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745564.pt new file mode 100644 index 0000000..5698617 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1686745564.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687142620.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687142620.pt new file mode 100644 index 0000000..c0e2882 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687142620.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687146279.pt b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687146279.pt new file mode 100644 index 0000000..e713e86 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/NNs/low_1687146279.pt differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/Optim,Play.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/Optim,Play.ipynb new file mode 100644 index 0000000..d34e980 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/Optim,Play.ipynb @@ -0,0 +1,152 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame\n", + "import globals as gl\n", + "import environmentModelBase as em\n", + "from environmentModelBase import Model\n", + "from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType\n", + "from neuralNetworkSimple import NNBase\n", + "import numpy as np\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def create_nn_strategy(name):\n", + " nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions)\n", + " nn.load(name)\n", + " return Strategy(StrategyType.neural_net,NNorFunc=nn, name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "low_nn_names=[\"low,1684386202\",\"low,1684484716\",\"low,1684557152\",\"low,1684856358\",\"low,1685028503\"]\n", + "low_strategies =[Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)]+ [create_nn_strategy(name) for name in low_nn_names]\n", + "low_strategies" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "high_nn_names=[\"high,1684424924\",\"high,1684821735\"]\n", + "high_strategies =[Strategy(StrategyType.static, NNorFunc=em.myopic, name=\"myopic\"), \n", + " Strategy(StrategyType.static, NNorFunc=em.const, name=\"const\", firstPrice=132), \n", + " Strategy(StrategyType.static, NNorFunc=em.guess, name=\"guess\", firstPrice=132)]+ [create_nn_strategy(name) for name in high_nn_names]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "equi: [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00, 0.00], 126646.32, 56683.87\n", + "equi: [0.00, 0.00, 0.94, 0.00, 0.00, 0.00, 0.00, 0.06], [0.51, 0.00, 0.49, 0.00, 0.00], 148436.76, 77525.67\n", + "Round 0 of 100\n" + ] + } + ], + "source": [ + "bimatrix_game = BimatrixGame.BimatrixGame(low_strategies, high_strategies)\n", + "equilibria=BimatrixGame.run_tournament(bimatrix_game=bimatrix_game,number_rounds= 100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/Readme.docx b/learningAgents/naive_policy_gradient/optim_PGM_base/Readme.docx new file mode 100644 index 0000000..b446916 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/Readme.docx differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/bimatrix.py b/learningAgents/naive_policy_gradient/optim_PGM_base/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/check.py b/learningAgents/naive_policy_gradient/optim_PGM_base/check.py new file mode 100644 index 0000000..9639af3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/check.py @@ -0,0 +1,87 @@ +# import BimatrixGame as BG +# import globals as gl +# import torch +# import numpy as np +# from environmentModelBase import Model, MixedStrategy, Strategy, StrategyType +# import environmentModelBase as em +# from learningBase import ReinforceAlgorithm +# from neuralNetworkSimple import NNBase +import bimatrix + +# # def myopic19(env, player, firstprice=0): +# # """ +# # Adversary follows Myopic strategy +# # """ +# # return env.monopolyPrice(player)-19 + +# np.random.seed(0) +# gl.initialize() + +# number_rounds=50 + +# l1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.action_step) +# l1.load("low,1684386202") +# # l2=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep) +# # l2.load("low,1684332617") +# # h1=NNBase(lr=gl.lr, num_input=gl.totalStages+2+gl.adversaryHistroy,num_actions=gl.numActions,adv_hist=gl.adversaryHistroy,action_step=gl.actionStep) +# # h1.load("high,1684261807") +# equilibria = [] +# bimatrix_game.low_strategies = [ +# # Strategy(StrategyType.static, NNorFunc=myopic19, name="myopic19") +# # Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), +# # Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132), +# Strategy(StrategyType.neural_net, NNorFunc=l1, name=l1.name) +# # Strategy(StrategyType.neural_net, NNorFunc=l2, name=l2.nn_name) +# ] +# bimatrix_game.high_strategies = [ +# Strategy(StrategyType.static, NNorFunc=em.myopic, name="myopic") , +# Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), +# Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132), +# # Strategy(StrategyType.neural_net, NNorFunc=h1, name=h1.nn_name), +# ] +# bimatrix_game = BG.BimatrixGame(bimatrix_game.low_strategies, bimatrix_game.high_strategies) +# # bimatrixGame.reset_matrix() +# bimatrix_game.fill_matrix() +# print(bimatrix_game.matrix_A) +# print(bimatrix_game.matrix_B) +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() +# for round in range(number_rounds): +# print("Round", round, " of ", number_rounds) + +# update = False + + +# acceptable, agentPayoffs, advPayoffs, low_cost_player = BG.training([gl.lowCost, gl.highCost], advMixedStrategy=MixedStrategy( +# strategiesList=high_cost_players, probablitiesArray=high_cost_probabilities), targetPayoff=low_cost_payoff) +# if acceptable: +# update = True +# low_cost_players.append(low_cost_player) +# bimatrixGame.add_low_cost_row(agentPayoffs, advPayoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"low cost player {low_cost_player._name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + +# acceptable, agentPayoffs, advPayoffs, high_cost_player = BG.training( +# [gl.highCost, gl.lowCost], advMixedStrategy=MixedStrategy(probablitiesArray=low_cost_probabilities, strategiesList=low_cost_players), targetPayoff=high_cost_payoff) + +# if acceptable: +# update = True +# high_cost_players.append(high_cost_player) +# bimatrixGame.add_high_cost_col(advPayoffs, agentPayoffs) +# equilibria.append( +# [low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff]) +# print(f"high cost player {high_cost_player._name} added") + +# low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrixGame.compute_equilibria() + + # if update: + # gl.numEpisodes = gl.numEpisodesReset + # else: + # gl.numEpisodes += 1000 + +game=bimatrix.bimatrix("game8x5.txt") +equi=game.tracing(100,3) +print(equi) \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/columnprint.py b/learningAgents/naive_policy_gradient/optim_PGM_base/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/environmentModelBase.py b/learningAgents/naive_policy_gradient/optim_PGM_base/environmentModelBase.py new file mode 100644 index 0000000..0871e66 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/environmentModelBase.py @@ -0,0 +1,290 @@ + +import torch + + +import numpy as np # numerical python +import globals as gl + + + +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopicPrices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + self.our_target_demand = ( + (self.totalDemand + self.costs[1]-self.costs[0])/2) # target demand + self.target_price = (self.our_target_demand+self.costs[0])/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + self.myopicPrices[player][self.stage] = myopic(self, player) + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return monopolyPrice(demand=self.demandPotential[player][self.stage], cost=self.costs[player]) + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, advMixedStrategy, stateAdvHistory=0) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + """ adversary is a MixedStrategy""" + self.rewardFunction = self.profits + + self.episodesMemory = list() + self.done = False + + # number of previous adversary's action we consider in the state + self.stateAdvHistory = stateAdvHistory + self.advMixedStrategy = advMixedStrategy + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return self.get_state(0), reward, self.done + + def resetAdversary(self): + self.adversaryStrategy = self.advMixedStrategy.set_adversary_strategy() + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + return self.adversaryStrategy.play(environment=self, player=1) + + def step(self, price): + """ + Transition Function. + Parameters: + - action: Price + - state: list in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + + adversaryPrice = self.adversaryChoosePrice() + p = self.myopic() + # myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [price, adversaryPrice]) + + done = (self.stage == self.T-1) + + reward = self.rewardFunction() + self.stage += 1 + + return self.get_state(self.stage), reward, done + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.stateAdvHistory + + return define_state(stage, self.totalDemand, self.T, self.costs[player], self.prices[player], self.prices[1-player], self.demandPotential[player], num_adv_hist) + + + + + + + + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.totalDemand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demandPotential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.totalDemand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.totalDemand/2 + env.costs[1]-env.costs[0]), + (env.totalDemand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.totalDemand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demandPotential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demandPotential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def define_state(stage, total_demand, total_stages, agent_cost, agent_prices, adv_prices, agent_demands, num_adv_hist): + # [one-hote encoding of stage, our demand, our price, adversary's price history] + + stageEncode = [0]*total_stages + if stage < total_stages: + stageEncode[stage] = 1 + + if stage == 0: + state = stageEncode + \ + [total_demand/2, + ((total_demand/2) + agent_cost)/2] + ([0]*num_adv_hist) + + else: + # check last stageeee demand + state = stageEncode+[agent_demands[stage], agent_prices[stage-1]] + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = adv_prices[i] + j -= 1 + state += adv_history + + return torch.tensor(state, dtype=torch.float32) + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/game.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/game.txt new file mode 100644 index 0000000..f5dad6c --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/game.txt @@ -0,0 +1,20 @@ +8 5 + + 139591 138555 138555 98636 97112 + 138527 127512 127512 57201 54237 + 154998 168709 141639 123205 121624 + 178633 293700 90772 121993 120123 + 179308 274110 106754 125213 123027 + 178883 271646 108005 125236 122594 + 179499 272035 108949 125806 123321 + 179334 262146 116425 126646 124283 + + 93895 94732 94732 117810 118414 + 94760 103712 103712 158397 160790 + 79666 68729 79091 70341 69874 + 34271 -40479 31788 42684 43121 + 39861 -22350 45498 51111 51514 + 42117 -20579 47268 52258 52939 + 41428 -20468 47883 52671 52627 + 44679 -11328 53504 56684 56393 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/game5x2.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/game5x2.txt new file mode 100644 index 0000000..1994693 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/game5x2.txt @@ -0,0 +1,14 @@ +5 2 + + 123251 120040 + 125064 123150 + 124936 122700 + 125588 123158 + 126449 124202 + + 43296 43584 + 49730 51286 + 52351 52300 + 52733 52522 + 56561 56463 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/game8x5.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/game8x5.txt new file mode 100644 index 0000000..8b64c87 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/game8x5.txt @@ -0,0 +1,20 @@ +8 5 + + 139591 138555 138555 98440 97159 + 138527 127512 127512 56140 54261 + 154998 168709 141639 124168 121632 + 178433 294260 91786 122729 120188 + 179169 272487 104497 125383 123073 + 179003 271526 107660 124716 122747 + 179200 271077 108604 125874 123156 + 179353 261888 116425 126715 124336 + + 93895 94732 94732 117874 118409 + 94760 103712 103712 159265 160786 + 79666 68729 79091 70510 69823 + 35257 -40901 32920 44166 43625 + 40500 -21026 44007 51182 52000 + 40916 -20436 46605 52011 52516 + 41349 -19699 47435 52067 53243 + 44815 -11059 53380 56485 56184 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x1.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x1.txt new file mode 100644 index 0000000..e2838cd --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x1.txt @@ -0,0 +1,6 @@ +1 1 + + 141639 + + 79091 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x2.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x2.txt new file mode 100644 index 0000000..f1aed3f --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x2.txt @@ -0,0 +1,6 @@ +1 2 + + 22189 21459 + + 13977 14234 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x3.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x3.txt new file mode 100644 index 0000000..87b1b82 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game1x3.txt @@ -0,0 +1,6 @@ +1 3 + + 22189 21992 21459 + + 13977 14121 14270 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game2x3.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game2x3.txt new file mode 100644 index 0000000..bd09415 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game2x3.txt @@ -0,0 +1,8 @@ +2 3 + + 22189 21992 21459 + 22483 22248 21765 + + 13977 14121 14270 + 14736 14899 15202 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game3x3.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game3x3.txt new file mode 100644 index 0000000..4f61e01 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game3x3.txt @@ -0,0 +1,10 @@ +3 3 + + 22189 21992 21459 + 22483 22248 21765 + 22550 22622 22097 + + 13977 14121 14270 + 14736 14899 15202 + 12666 12744 13005 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x3.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x3.txt new file mode 100644 index 0000000..86b031e --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x3.txt @@ -0,0 +1,12 @@ +4 3 + + 22189 21992 21459 + 22483 22248 21765 + 22550 22622 22097 + 23422 23011 22506 + + 13977 14121 14270 + 14736 14899 15202 + 12666 12744 13005 + 13520 13790 14071 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x4.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x4.txt new file mode 100644 index 0000000..d31ee99 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x4.txt @@ -0,0 +1,12 @@ +4 4 + + 22189 21992 21459 20357 + 22483 22248 21765 20820 + 22550 22622 22097 21067 + 23422 23011 22506 21519 + + 13977 14121 14270 14415 + 14736 14899 15202 15667 + 12666 12744 13005 13385 + 13520 13790 14071 14494 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x5.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x5.txt new file mode 100644 index 0000000..d81e688 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game4x5.txt @@ -0,0 +1,12 @@ +4 5 + + 22189 21992 21459 20357 19190 + 22483 22248 21765 20820 19904 + 22550 22622 22097 21067 20065 + 23422 23011 22506 21519 20560 + + 13977 14121 14270 14415 14336 + 14736 14899 15202 15667 15945 + 12666 12744 13005 13385 13577 + 13520 13790 14071 14494 14729 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game5x2.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game5x2.txt new file mode 100644 index 0000000..b68a413 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game5x2.txt @@ -0,0 +1,14 @@ +5 2 + + 122595 120305 + 125248 122975 + 124924 122433 + 125771 123462 + 126361 124225 + + 42898 43797 + 51063 51384 + 52070 52217 + 52444 52926 + 56186 56401 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/games/game8x5.txt b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game8x5.txt new file mode 100644 index 0000000..f5dad6c --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/games/game8x5.txt @@ -0,0 +1,20 @@ +8 5 + + 139591 138555 138555 98636 97112 + 138527 127512 127512 57201 54237 + 154998 168709 141639 123205 121624 + 178633 293700 90772 121993 120123 + 179308 274110 106754 125213 123027 + 178883 271646 108005 125236 122594 + 179499 272035 108949 125806 123321 + 179334 262146 116425 126646 124283 + + 93895 94732 94732 117810 118414 + 94760 103712 103712 158397 160790 + 79666 68729 79091 70341 69874 + 34271 -40479 31788 42684 43121 + 39861 -22350 45498 51111 51514 + 42117 -20579 47268 52258 52939 + 41428 -20468 47883 52671 52627 + 44679 -11328 53504 56684 56393 + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/globals.py b/learningAgents/naive_policy_gradient/optim_PGM_base/globals.py new file mode 100644 index 0000000..84f5e9d --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/globals.py @@ -0,0 +1,42 @@ +def initialize(): + global total_demand, low_cost, high_cost, total_stages, num_adv_history, lr, gamma, num_actions + global action_step, num_stochastic_iter, num_episodes, num_episodes_reset, episode_adv_increase + global rewards_division_const,replay_buffer_size,prob_break_limit_ln,converge_break, print_step + global batch_update_size,buffer_play_coefficient, num_cores,num_trace_equilibria + + total_demand = 400 + low_cost = 57 + high_cost = 71 + # total_stages = 4 + total_stages = 25 + num_adv_history = 3 + # lr = 0.005 + lr = 0.000005 + gamma = 1 + num_actions = 20 + action_step = 3 + num_stochastic_iter = 10 + rewards_division_const = 10_000 + + # episodes for learning the last stage, then for 2nd to last stage 2*numEpisodes. In total:300*numEpisodes + num_episodes = 2000 + # num_episodes = 3000 + num_episodes_reset = num_episodes + # increase in num of episodes for each adv in support + episode_adv_increase = 500 + + replay_buffer_size= 100_000 + + prob_break_limit_ln=-0.001 + converge_break=True + + # if details of game after this many episodes need to be printed. None means no printing + print_step=None + # size of the batch of games that would be played in each process and then would update nn with other processes resultstogether + batch_update_size=50 + # proportion of episodes from buffer ( (1-coefficient)*episode will be new games) + buffer_play_coefficient=0 + + num_cores=4 + + num_trace_equilibria=3 diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/learningBase.py b/learningAgents/naive_policy_gradient/optim_PGM_base/learningBase.py new file mode 100644 index 0000000..1bae092 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/learningBase.py @@ -0,0 +1,519 @@ + +import environmentModelBase as model +import torch +import torch.nn as nn +from torch.distributions import Categorical +from enum import Enum +import numpy as np # numerical python +from openpyxl import load_workbook +import time +import globals as gl +from collections import deque, namedtuple +import random +from multiprocessing import Pool + +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + self.probBreakLn = -0.001 + self.costs = self.env.costs + + def write_to_excel(self, new_row): + """ + row includes: # ep adversary return advReturn loss lr gamma hist actions probs nn_name total_stages action_step num_actions agent's_prices + # adv's_prices agent's_demands adv's_demands return_against_adversaries + """ + + path = 'results.xlsx' + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + # print(new_row) + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + + self.returns = [] + self.loss = [] + + self.dataRow = [] + + def reset_policy_net(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def load_policy_net(self, name): + """ + Load Policy Neural Network. + """ + self.reset_policy_net() + self.neuralNetwork.load(name) + + # def saveResult(self): + # pass + + # return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def solver(self): + """ + print_step=None means no printing + """ + self.returns = [] + self.loss = [] + + # fig, axs = plt.subplots(max(self.numberIterations,2), 2, figsize=(15, 6*self.numberIterations)) + + for iter in range(self.numberIterations): + replay_buffer = ReplayBuffer(gl.replay_buffer_size) + self.reset_policy_net() + self.returns.append([]) + self.loss.append([]) + + for stage in range(self.env.T-1, -1, -1): + episodes = self.compute_num_episodes(stage) + if stage < self.env.T-1: + self.play_from_buffer(stage=stage, replay_buffer=replay_buffer, episodes=int( + gl.buffer_play_coefficient*episodes)) + + new_espisodes = int((1-gl.buffer_play_coefficient) * + episodes) if (stage < gl.total_stages-1) else episodes + + self.learn_stage_onwards( + iter=iter, stage=stage, episodes=new_espisodes, replay_buffer=replay_buffer) + + # axs[iter][0].scatter(range(len(self.returns[iter])), self.returns[iter]) + # axs[iter][1].scatter(range(len(self.loss[iter])), self.loss[iter]) + + # plt.show() + + def compute_num_episodes(self, stage): + return int(self.numberEpisodes*((gl.total_stages-stage)**1.2)) + # return int(self.numberEpisodes*((gl.total_stages-stage))) + + def learn_stage_onwards(self, iter, stage, episodes, replay_buffer): + """ + Method that just learns the actions of stages after the input stage. + + """ + # if stage0.999 means coverged? break + if should_break: + # self.returns[iteration] = self.returns[iteration][0:episode] + # self.loss[iteration] = self.loss[iteration][0:episode] + break + + name = f"{int(time.time())}" + # ep costs adversary return advReturn loss lr gamma hist actions probs nn_name total_stages action_step num_actions agent's_prices + # adv's_prices agent's_demands adv's_demands return_against_adversaries + self.dataRow = [len(self.returns[iter]), str(self.costs),str(self.env.advMixedStrategy), returns, sum(self.env.profit[1]), loss.item(), self.neuralNetwork.lr, self.gamma, self.env.stateAdvHistory, str( + actions*gl.action_step), str((torch.exp(action_log_probs)).detach().numpy()), name, self.env.T, gl.action_step, self.neuralNetwork.num_actions, str(self.env.prices[0]), str(self.env.prices[1]), str(self.env.demandPotential[0]), str(self.env.demandPotential[1])] + + self.neuralNetwork.name = name + # for advmode in model.AdversaryModes: + # new_row.append(np.array((self.playTrainedAgent(advmode,10))[0]).mean()) + + def play_from_buffer(self, stage, replay_buffer, episodes): + + samples = replay_buffer.sample_game(episodes) + # # field_names==["0 actions", "1 agent_demands", "2 agent_prices","3 adv_prices", "4 rewards"] + for sample in samples: + action_log_probs_cut = [] + for s in range(stage, gl.total_stages): + state = model.define_state(s, gl.total_demand, gl.total_stages, + self.costs[0], sample[2], sample[3], sample[1], gl.num_adv_history) + norm_state = normalize_state(state) + probs = self.policy(norm_state) + dist_action = Categorical(probs) + action_log_probs_cut.append( + dist_action.log_prob((sample[0])[s])) + + base_disc_returns = returns_computation(rewards=sample[4]) - (compute_base(agent_cost=self.costs[0], + stage_demand=(sample[1])[stage], adv_prices=sample[3], start_stage=stage)/gl.rewards_division_const) + + loss = loss_function( + base_disc_returns[stage:], torch.stack(action_log_probs_cut)) + self.policy.zero_grad() + loss.backward() + self.optim.step() + + def write_nn_data(self, prefix=""): + """ + writes the data in excel and saves nn + """ + self.neuralNetwork.name=f"{prefix}_{self.neuralNetwork.name}" + # self.name = f"{[self.neuralNetwork.lr, self.gamma,clc]}-stage {stage}-{int(time.time())}" + self.neuralNetwork.save() + # print(self.neuralNetwork.name, "saved") + # ep costs adversary return advReturn loss lr gamma hist actions probs nn_name total_stages action_step num_actions agent's_prices + # adv's_prices agent's_demands adv's_demands return_against_adversaries + self.write_to_excel(self.dataRow) + + # def myopic_price(demand,cost): + # return (demand + cost)/2 + + def play_trained_agent(self, adversary, iterNum): + """ + Current trained NN will plays against the adversary's strategy, without learning. + """ + + game = model.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advMixedStrategy=adversary, stateAdvHistory=gl.num_adv_history) + returns = torch.zeros(2, iterNum) + for episode in range(iterNum): + + # episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = normalize_state(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + compute_price(game.demandPotential[0][game.stage], game.costs[0], action=action.item(), action_step=gl.action_step)) + retu = retu + reward + # episodeMemory.append((normPrevState, action, reward)) + + # states = torch.stack([item[0] for item in episodeMemory]) + # actions = torch.tensor([item[1] for item in episodeMemory]) + # rewards = torch.tensor([item[2] for item in episodeMemory]) + + # print(f"iteration {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[0][episode], returns[1][episode] = sum( + game.profit[0]), sum(game.profit[1]) + + return returns + + # plt.plot(returns) + # plt.show() + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + nn_hist = None + policy = None + + def __init__(self, strategyType, NNorFunc, name, firstPrice=132) -> None: + """ + Based on the type of strategy, the neuralnet or the Strategy Function should be given as input. FirstPrice just applies to static strategies + """ + self.type = strategyType + self.name = name + # self._env = environment + + if strategyType == StrategyType.neural_net: + self.nn = NNorFunc + self.policy = NNorFunc.policy + self.nn_hist = gl.num_adv_history + else: + self.policy = NNorFunc + self.firstPrice = firstPrice + + def reset(self): + pass + + def play(self, environment, player=0): + """ + Computes the action to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + self.env = environment + if self.type == StrategyType.neural_net: + state = self.env.get_state( + self.env.stage, player, adv_hist=gl.num_adv_history) + normState = normalize_state(state=state) + probs = self.policy(normState) + distAction = Categorical(probs) + action = distAction.sample() + return compute_price(action=action.item(), action_step=gl.action_step, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + + else: + return self.policy(self.env, player, self._firstPrice) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state, reward, done = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.updatePricesProfitDemand(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablitiesArray=torch.ones(1), + strategiesList=[self]) + + return mix + + +class MixedStrategy(): + _strategies = [] + _strategyProbs = None + + def __init__(self, strategiesList=[], probablitiesArray=None) -> None: + self._strategies = strategiesList + self._strategyProbs = probablitiesArray + + def set_adversary_strategy(self): + if len(self._strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + if not torch.is_tensor(self._strategyProbs): + self._strategyProbs = torch.tensor(self._strategyProbs) + adversaryDist = Categorical(self._strategyProbs) + strategyInd = (adversaryDist.sample()).item() + return self._strategies[strategyInd] + else: + print("adversary's strategy can not be set!") + return None + + def __str__(self) -> str: + s = "" + for i in range(len(self._strategies)): + if self._strategyProbs[i] > 0: + s += f"{self._strategies[i].name}-{self._strategyProbs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + + +class ReplayBuffer(): + """ + the information of one round of game that is needed for creating the states later, update the nn and compute_base will be saved in buffer. The len of each input array is total_stages + """ + + def __init__(self, max_len): + + self.deque = deque([], maxlen=max_len) + # self.entry = namedtuple("Entry", field_names=["0 actions", "1 agent_demands", "2 agent_prices","3 adv_prices", "4 rewards"]) + + def add_game(self, actions, agent_demands, agent_prices, adv_prices, rewards): + # self.entry = namedtuple("Entry", field_names=["0 actions", "1 agent_demands", "2 agent_prices","3 adv_prices", "4 rewards"]) + entry = (actions, agent_demands, agent_prices, adv_prices, rewards) + self.deque.append(entry) + + def sample_game(self, sample_size): + """ return samples of tuples=(["0 actions", "1 agent_demands", "2 agent_prices","3 adv_prices", "4 rewards"])""" + + return random.sample(self.deque, min(sample_size, len(self.deque))) + + +def normalize_state(state): + # [stage one-hot encoded, agent's demand potential, agent's last price, history of adversary's prices] + + normalized = [0]*len(state) + for i in range(gl.total_stages): + normalized[i] = state[i] + for i in range(gl.total_stages, len(state)): + normalized[i] = state[i]/(gl.total_demand) + return torch.tensor(normalized) + + +def compute_price(demand, cost, action, action_step): + return model.monopolyPrice(demand, cost) - (action_step * action) + + +def returns_computation(rewards): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards with discount factor from that stage onwards. + output:tensor + + """ + discRewards = torch.zeros(len(rewards)) + discRewards[-1] = rewards[-1] + for i in range(len(rewards)-2, -1, -1): + discRewards[i] = rewards[i] + gl.gamma*discRewards[i+1] + return discRewards + + +def compute_base(agent_cost, adv_prices, start_stage=0, stage_demand=None): + """ + discounted rewards when we play myopic against the adversary from start_stage onwards + + """ + if stage_demand is None: + stage_demand = gl.total_demand/2 + profit = torch.zeros(gl.total_stages) + demand = stage_demand + for i in range(start_stage, gl.total_stages): + price = (demand + agent_cost)/2 + a = (demand-price)*(price-agent_cost) + profit[i] = (demand-price)*(price-agent_cost) + demand += (adv_prices[i]-price)/2 + return returns_computation(rewards=profit) + + +# def play_from_buffer(stage, replay_buffer, episodes): + +# with Pool() as pool: +# samples = [replay_buffer.sample_game( +# int(episodes/gl.num_cores)) for _ in range(gl.num_cores)] +# stage_repeat = [stage]*gl.num_cores +# results = pool.starmap(compute_buffer_update, +# zip(stage_repeat, samples)) +# return results + + +# def compute_buffer_update(stage, samples): + # # field_names=["action_log_probs 0","agent_cost 1", "agent_demands 2", "adv_prices 3", "rewards 4"] + # loss = [] + # for sample in samples: + # action_log_probs_cut = (sample[0])[stage:] + # base_disc_returns = returns_computation(rewards=sample[4]) - (compute_base(agent_cost=sample[1], + # stage_demand=(sample[2])[stage], adv_prices=samples[3], start_stage=stage)/gl.rewardsDivisionConst) + # final_returns = base_disc_returns[stage:] + + # loss.append(-(torch.sum(final_returns*action_log_probs_cut))) + + # return loss + +def loss_function(returns, log_probs): + + return -(torch.sum(returns*log_probs)) diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/lemke.py b/learningAgents/naive_policy_gradient/optim_PGM_base/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0] None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + + + self.name = f"nn, lr={self.lr}, numActions={self.num_actions},{int(time.time())}" + + def reset(self): + + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.DIMENSION), + nn.ReLU(), + # nn.Linear(self.nn_dim, self.nn_dim), + # nn.ReLU(), + nn.Linear(self.DIMENSION, self.num_actions), + nn.Softmax(dim=0)) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + # print(self.policy[0].weight) + # print(self.policy[2].weight) + # print("policy reset") + return self.policy, self.optim + + def save(self, name=None): + self.name = (self.name if name is None else name) + # print("policy saved!") + return torch.save(self.policy.state_dict(), self.SAVE_PATH_FORMAT.format(name=self.name)) + + def load(self, name=None): + if self.policy is None: + self.reset() + self.name = (self.name if name is None else name) + self.policy.load_state_dict( + torch.load(self.SAVE_PATH_FORMAT.format(name=self.name))) + # print("policy loaded!") + + diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/play.py b/learningAgents/naive_policy_gradient/optim_PGM_base/play.py new file mode 100644 index 0000000..f2d1bff --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/play.py @@ -0,0 +1,60 @@ +import BimatrixGame +import globals as gl +import environmentModelBase as em +from environmentModelBase import Model +from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType +from neuralNetworkSimple import NNBase +import numpy as np + +def create_nn_strategy(name): + nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions) + nn.load(name) + return Strategy(StrategyType.neural_net,NNorFunc=nn, name=name) + +# const132=Strategy(StrategyType.static,name="const132",staticIndex=1) +# const95=Strategy(StrategyType.static,"const95",staticIndex=2) + +# mainGame._strategies.append(const132) +# mainGame._strategies.append(const95) +# mainGame._strategies.append(myopic) +# mainGame.fill_matrix() +# mainGame.write_all_matrix() + +# nnMyopic=NNBase(num_input=27, num_actions=50, adv_hist=0) +# nnMyopic.reset() +# nnMyopic.load("0,[1e-05,1][1, 10000, 1, 1],1682423487") +# nn1st=Strategy(StrategyType.neural_net,nnMyopic,"nnMyopic" ) +# mainGame._strategies.append(nn1st) + + +# nnConst=NNBase(num_input=27, num_actions=50, adv_hist=0) +# nnConst.reset() +# nnConst.load("0,[1e-05,1][1, 10000, 1, 1],1682506150") +# mainGame._strategies.append(Strategy(StrategyType.neural_net,nnConst,"nnConst132" )) + +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.const,name="staticConst132",firstPrice=132)) +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.myopic,name="staticMyopic")) + + +# mainGame._strategies.append(Strategy(StrategyType.static,NNorFunc=em.guess,name="staticGuess132",firstPrice=132)) +# mainGame.fill_matrix() + +# mainGame.write_all_matrix() +if __name__ == '__main__': + np.random.seed(0) + gl.initialize() + low_nn_names=["low,1684386202","low,1684484716","low,1684557152","low,1684856358","low,1685028503"] + low_strategies =[Strategy(StrategyType.static, NNorFunc=em.myopic, name="myopic"), + Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), + Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132)]+ [create_nn_strategy(name) for name in low_nn_names] + high_nn_names=["high,1684424924","high,1684821735"] + high_strategies =[Strategy(StrategyType.static, NNorFunc=em.myopic, name="myopic"), + Strategy(StrategyType.static, NNorFunc=em.const, name="const", firstPrice=132), + Strategy(StrategyType.static, NNorFunc=em.guess, name="guess", firstPrice=132)]+ [create_nn_strategy(name) for name in high_nn_names] + + # low_strategies=[Strategy(StrategyType.static,NNorFunc=em.guess,name="staticGuess132",firstPrice=132)] + # high_strategies=[Strategy(StrategyType.static,NNorFunc=em.guess,name="staticGuess132",firstPrice=132)] + + bimatrix_game = BimatrixGame.BimatrixGame(low_strategies, high_strategies) + equilibria=BimatrixGame.run_tournament(bimatrix_game=bimatrix_game,number_rounds= 4) + print(equilibria) \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/randomstart.py b/learningAgents/naive_policy_gradient/optim_PGM_base/randomstart.py new file mode 100644 index 0000000..460e3eb --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/randomstart.py @@ -0,0 +1,114 @@ +#!/usr/bin/python + +import random +import math +import fractions +import matplotlib.pyplot as plt +import sys + +# give random n-tuple uniformly from unit simplex +def randInSimplex(n, naive=False): + x = [0.0]*n + if naive: # random numbers re-normalized + sum = 0 + for i in range(n): + x[i] = random.uniform(0, 1) + sum += x[i] + return [k/sum for k in x] + + else: # properly uniformly in simplex + factor = 1.0 + i = n-1 + while i>0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/results - Copy.xlsx b/learningAgents/naive_policy_gradient/optim_PGM_base/results - Copy.xlsx new file mode 100644 index 0000000..d2daff6 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/results - Copy.xlsx differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/results.xlsx b/learningAgents/naive_policy_gradient/optim_PGM_base/results.xlsx new file mode 100644 index 0000000..b0ff497 Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/results.xlsx differ diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/small optim play.ipynb b/learningAgents/naive_policy_gradient/optim_PGM_base/small optim play.ipynb new file mode 100644 index 0000000..f108aee --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/small optim play.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import BimatrixGame\n", + "import globals as gl\n", + "from environmentModelBase import Model\n", + "from learningBase import ReinforceAlgorithm, MixedStrategy, Strategy, StrategyType\n", + "from neuralNetworkSimple import NNBase\n", + "import numpy as np\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "gl.initialize()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# def create_nn_strategy(name):\n", + "# nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions)\n", + "# nn.load(name)\n", + "# return Strategy(StrategyType.neural_net,NNorFunc=nn, name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# low_nn_names=[\"low,1684386202\",\"low,1684484716\",\"low,1684557152\",\"low,1684856358\",\"low,1685028503\"]\n", + "# low_strategies = [create_nn_strategy(name) for name in low_nn_names]\n", + "# low_strategies" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# high_nn_names=[\"high,1684424924\",\"high,1684821735\"]\n", + "# high_strategies = [create_nn_strategy(name) for name in high_nn_names]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "nn=NNBase(num_input=gl.total_stages+2+gl.num_adv_history,lr=gl.lr, num_actions=gl.num_actions)\n", + "nn.reset()\n", + "player=Strategy(StrategyType.neural_net,NNorFunc=nn, name=\"rand\")\n", + "low_strategies=[player]\n", + "high_strategies=[player]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "equi: [1.00], [1.00], 22197.14, 13214.84\n", + "Round 0 of 5\n", + "high cost player high_1686133233 added\n", + "equi: [1.00], [0.00, 1.00], 29110.55, 14172.95\n", + "Round 1 of 5\n" + ] + } + ], + "source": [ + "bimatrix_game = BimatrixGame.BimatrixGame(low_strategies, high_strategies)\n", + "equilibria=BimatrixGame.run_tournament(bimatrix_game=bimatrix_game,number_rounds=5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_low:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for strategy in bimatrixGame._strategies_high:\n", + " print(strategy._name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/test.py b/learningAgents/naive_policy_gradient/optim_PGM_base/test.py new file mode 100644 index 0000000..73c2464 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/test.py @@ -0,0 +1,3 @@ +import torch + +print(torch.cuda.is_available()) \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/utils.py b/learningAgents/naive_policy_gradient/optim_PGM_base/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/naive_policy_gradient/optim_PGM_base/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/naive_policy_gradient/optim_PGM_base/~$results - Copy.xlsx b/learningAgents/naive_policy_gradient/optim_PGM_base/~$results - Copy.xlsx new file mode 100644 index 0000000..fdb909e Binary files /dev/null and b/learningAgents/naive_policy_gradient/optim_PGM_base/~$results - Copy.xlsx differ diff --git a/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test1-checkpoint.ipynb b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test1-checkpoint.ipynb new file mode 100644 index 0000000..6319f6e --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test1-checkpoint.ipynb @@ -0,0 +1,966 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.00001)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=20_000, discountFactor =0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "tensor([35, 39, 16, 13, 11, 0, 41, 36, 9, 22, 46, 46, 19, 17, 28, 38, 15, 8,\n", + " 42, 40, 31, 46, 30, 12, 3])\n", + "10000\n", + "tensor([44, 10, 13, 40, 12, 33, 38, 48, 17, 17, 24, 32, 32, 45, 17, 37, 26, 44,\n", + " 13, 3, 32, 19, 39, 8, 28])\n", + "20000\n", + "tensor([ 9, 11, 4, 22, 2, 19, 26, 41, 33, 39, 26, 45, 4, 40, 13, 23, 33, 29,\n", + " 40, 27, 7, 43, 15, 26, 15])\n", + "30000\n", + "tensor([16, 15, 21, 3, 8, 13, 23, 24, 43, 15, 44, 25, 16, 45, 40, 8, 19, 32,\n", + " 42, 24, 39, 13, 26, 22, 33])\n", + "40000\n", + "tensor([27, 30, 32, 17, 3, 45, 1, 24, 39, 19, 29, 8, 29, 14, 26, 2, 34, 43,\n", + " 17, 9, 27, 26, 43, 11, 41])\n", + "50000\n", + "tensor([14, 10, 1, 47, 33, 43, 35, 37, 42, 23, 33, 17, 22, 25, 2, 40, 19, 40,\n", + " 2, 37, 30, 40, 29, 14, 14])\n", + "60000\n", + "tensor([17, 5, 14, 43, 22, 3, 8, 15, 17, 5, 24, 12, 40, 12, 7, 46, 36, 21,\n", + " 30, 23, 33, 45, 29, 2, 27])\n", + "70000\n", + "tensor([46, 28, 1, 23, 22, 1, 39, 33, 42, 16, 35, 27, 48, 15, 25, 7, 43, 36,\n", + " 10, 43, 2, 35, 32, 39, 12])\n", + "80000\n", + "tensor([20, 41, 44, 24, 31, 41, 29, 44, 11, 7, 5, 33, 38, 24, 12, 5, 32, 32,\n", + " 28, 44, 0, 3, 31, 35, 41])\n", + "90000\n", + "tensor([46, 49, 30, 15, 5, 24, 6, 32, 5, 42, 39, 38, 43, 1, 48, 28, 7, 39,\n", + " 38, 13, 33, 13, 44, 36, 27])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hi'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# neuralNet.load(name=name)\n", + "\"hi\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.000000200.000000
1204.500000195.500000
2209.750000190.250000
3220.875000179.125000
4223.437500176.562500
5238.718750161.281250
6231.859375168.140625
7226.429688173.570312
8231.714844168.285156
9232.857422167.142578
10241.928711158.071289
11232.464355167.535645
12224.232178175.767822
13238.616089161.383911
14226.808044173.191956
15221.904022178.095978
16228.952011171.047989
17220.976006179.023994
18232.488003167.511997
19244.244001155.755999
20232.622001167.377999
21225.811000174.189000
22234.405500165.594500
23227.702750172.297250
24229.351375170.648625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.000000 200.000000\n", + "1 204.500000 195.500000\n", + "2 209.750000 190.250000\n", + "3 220.875000 179.125000\n", + "4 223.437500 176.562500\n", + "5 238.718750 161.281250\n", + "6 231.859375 168.140625\n", + "7 226.429688 173.570312\n", + "8 231.714844 168.285156\n", + "9 232.857422 167.142578\n", + "10 241.928711 158.071289\n", + "11 232.464355 167.535645\n", + "12 224.232178 175.767822\n", + "13 238.616089 161.383911\n", + "14 226.808044 173.191956\n", + "15 221.904022 178.095978\n", + "16 228.952011 171.047989\n", + "17 220.976006 179.023994\n", + "18 232.488003 167.511997\n", + "19 244.244001 155.755999\n", + "20 232.622001 167.377999\n", + "21 225.811000 174.189000\n", + "22 234.405500 165.594500\n", + "23 227.702750 172.297250\n", + "24 229.351375 170.648625" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 163902.035578\n", + "1 65305.822584\n", + "dtype: float64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05108.2500004160.250000
15375.0625003875.062500
25208.1406253555.140625
36352.7539062922.753906
44716.3603522785.860352
57931.4260252037.676025
67447.9502562359.075256
76276.6047522630.167252
86902.3191572366.100407
95795.4582072310.848832
108293.6570321895.352345
117615.9350102329.782666
124875.6503172744.074146
138182.1009342042.312848
147108.6929892610.798946
155957.3341362867.387114
167355.8735312502.400020
175353.0325992917.295844
185298.0097802328.641402
198569.0790141795.894825
207566.7717822322.179688
215828.2884602661.992412
227672.1778732237.029849
236708.8572222565.283210
246402.2491202482.462114
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5108.250000 4160.250000\n", + "1 5375.062500 3875.062500\n", + "2 5208.140625 3555.140625\n", + "3 6352.753906 2922.753906\n", + "4 4716.360352 2785.860352\n", + "5 7931.426025 2037.676025\n", + "6 7447.950256 2359.075256\n", + "7 6276.604752 2630.167252\n", + "8 6902.319157 2366.100407\n", + "9 5795.458207 2310.848832\n", + "10 8293.657032 1895.352345\n", + "11 7615.935010 2329.782666\n", + "12 4875.650317 2744.074146\n", + "13 8182.100934 2042.312848\n", + "14 7108.692989 2610.798946\n", + "15 5957.334136 2867.387114\n", + "16 7355.873531 2502.400020\n", + "17 5353.032599 2917.295844\n", + "18 5298.009780 2328.641402\n", + "19 8569.079014 1795.894825\n", + "20 7566.771782 2322.179688\n", + "21 5828.288460 2661.992412\n", + "22 7672.177873 2237.029849\n", + "23 6708.857222 2565.283210\n", + "24 6402.249120 2482.462114" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD4CAYAAAAKA1qZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABNQElEQVR4nO2dd5yU1b3/32e2s50tsOzsUnbpIG0pClaCYsWCijFKbKjRxPSr6b/ceK/JzU28JtFEY0GjINjAAopo7ApLb7uwwFbYwha2zPY5vz/OM+sAW2Z2+sx5v177mpkzzzNzHoaZ7znf8vkKKSUajUajCU1Mvp6ARqPRaHyHNgIajUYTwmgjoNFoNCGMNgIajUYTwmgjoNFoNCFMuK8nMBCpqaly1KhRvp6GRqPRBBTbtm07IaVMG+g4vzcCo0aNIj8/39fT0Gg0moBCCFHiyHHaHaTRaDQhjDYCGo1GE8JoI6DRaDQhjN/HBHqjs7OT8vJy2trafD2VPomOjsZsNhMREeHrqWg0Gk2fBKQRKC8vJz4+nlGjRiGE8PV0zkBKSW1tLeXl5YwePdrX09FoNJo+CUh3UFtbGykpKX5pAACEEKSkpPj1TkWj0WggQI0A4LcGwIa/z0+j0WgggI2ARqMJbj46WMPBqiZfTyPo0UZgkGzcuJHx48eTm5vLI4884uvpaDRBxw9e3skPXt6J7nniWbQRGATd3d3cd999bNiwgf3797Nq1Sr279/v62lpNEFDY1sndS0d7DvWyNbiel9PJ6jRRmAQbNmyhdzcXMaMGUNkZCTLli1j3bp1vp6WRhM0lNVZeu4/9/lRH84k+AnIFFF7/t+b+9h/rNGtrzlpRAK/vnJyn89XVFSQlZXV89hsNvPVV1+5dQ4aTShjMwILclN5d18VFQ2tZCbF+HhWwYneCQyC3nyUOhtIo3EfpYYR+PnlEwF4/otiH84muAn4nUB/K3ZPYTabKSsr63lcXl7OiBEjvD4PjSZYKa2zkBgTwcSMBC6ZPIzVW8p4YOFYhkQG/E+W36F3AoNg9uzZHDp0iKNHj9LR0cHq1au56qqrfD0tjSZoKK1rJXvoEABumz+ak62dvL6jwsezCk60ERgE4eHh/PWvf+WSSy5h4sSJ3HDDDUye7P0diaZ33t1XSXWjrtYOZMrqLD1GIG9kMlMyE3jus2KdLuoBtBEYJJdddhkHDx7k8OHD/PznP/f1dDQGJy2d3P3CNu57aTtWq/7BCES6rZLyegtZhhEQQnDbOaM5VN3Mp0UnfDy74EMbAU1QUVCpMsW2Ftfz0pZSH89GMxgqG9vo7JY9OwGAK6ZlkBoXxbOfFftuYkGKNgKaoMImMzApI4FHNhRQedJ/3EI1Te10dlt9PQ2/p7RWZQbZG4Go8DBunpvNBwXVHD3R4qupBSXaCGiCioLKJuKjw3niWzPpslr5xRt7/cKPbLVKLnn0Yx7ZUODrqfg9thoBeyMAcPO8bCLCBCs/L/bBrIIXbQQ0QcXBqiYmDI9nZEosP1w0jvcPVPHOnkpfT4ua5nbqWjpYk1+GpaPL19Pxa0rrLISZBBlJ0aeMp8dHc+VZI1ibX0ZjW6ePZhd8aCOgCRqklBRUNjFuWDwAt88fzdTMRH69fi8Nlg6fzs1W/NTU1sVbu477dC7+TmmdhRFJ0USEnfnzdNv80bR0dLM2v9wHMwtOHDICQogfCCH2CSH2CiFWCSGihRBDhRCbhBCHjNtku+MfEkIUCSEKhRCX2I3PEkLsMZ57TOgyW40bqWxso6mtiwnDlREIDzPxyHVTqbd08l/vHPDp3Gx+7uQhEbz4VYlP5+LvlNqlh57OVHMieSOTWfl5Md06+8stDGgEhBCZwPeAPCnlFCAMWAY8CGyWUo4FNhuPEUJMMp6fDCwGHhdChBkv9wSwAhhr/C1269V4kdtvv5309HSmTJni66loDAoqVVDYthMAmDwikRXnjWFNfjmf+TC9sKzeghBw7wU57Co/yd6Kkz6bi79T1o8RALUbKK2z8EFBtRdnFbw46g4KB2KEEOHAEOAYsARYaTy/ErjauL8EWC2lbJdSHgWKgDlCiAwgQUr5hVSRuuftzgk4vv3tb7Nx40ZfT0Njx0HDCIwfHn/K+AMLxzIqZQg/e30PrR3dvpgapXUWhidEc+PsbKIjTLz4lU5f7Y3m9i5qWzp6agR645LJwxiRGM2zn2l1UXcwoBGQUlYAfwRKgePASSnle8AwKeVx45jjQLpxSiZQZvcS5cZYpnH/9PEzEEKsEELkCyHya2pqnLsiL3HeeecxdOhQX09DY0dhZRPDEqJIGhJ5ynh0RBj/de1USmotPLr5oE/mVlanip8SYyK4atoI1u2soEkHN8+gr8wge8LDTNxy9ig+P1zbUxeiGTwDqjEZvv4lwGigAVgrhPhWf6f0Mib7GT9zUMongScB8vLy+nf8bXgQKvf0e4jTDJ8KlwZut7Avj9Ty+40FPLZsRr8rqmCjoLKJ8cMTen3unJxUls3O4p+fHOXKs0YwJTPRq3Mrq2tlfm4qAN+cO5I1+eWs23mMb80b6dV5+DulDhgBgJvmZPF/mw/y3GfFPHLdWd6YWtDiiDvoG8BRKWWNlLITeA04B6gyXDwYtzYHXTmQZXe+GeU+Kjfunz6ucTOfHKphR2kDy5/dQl2Lb7NivEVXt5WimuaeoHBvPHTpRIbGRvLTV3Z7tWirrbObysa2nh+2aeZEJo9I4MWvSv2ihsGfcGQnAJA0JJJrZph5fUdFyPwf9xSO6LKWAvOEEEOAVmAhkA+0AMuBR4xbW2ut9cBLQog/ASNQAeAtUspuIUSTEGIe8BVwK/AXl68ggFfsnqK0rpWE6HDK61u5/bmtvHTX3KCX4C2utdDRZT0lKHw6iUMi+M8lk7nnX9t5+tOj3HN+jlfmVtHQCkB2imqKIoTg5rkj+dnre9hR1sDM7OT+Tg8pSussxEeHkxgTMeCxt80fxaotpazaUsp9F+Z6YXbBiSMxga+AV4DtwB7jnCdRP/6LhBCHgEXGY6SU+4A1wH5gI3CflNIWjbsX+CcqWHwY2ODOi9EoSmtbmJaVxGPLprOrvIH7X9pBV5DLFdjkIvrbCQAsnpLBJZOH8edNByn2kvyAzcWRlfz16vaq6SOIjQzjJR0gPgVbeqgj2ePjhsWzIDeVF74o0XIcLuBQdpCU8tdSyglSyilSyluMzJ9aKeVCKeVY47bO7viHpZQ5UsrxUsoNduP5xmvkSCnvlwG8F77ppps4++yzKSwsxGw28/TTT/t6Sj3YvkiLp2Tw2yVT+KCgmp+9vieoXQ8FlU2YBOSmxw147G+XTCEyzMRDr3nn36Q3F0dcVDhXz8jkzV3HOGnRAWIb/dUI9MZt80dR2djGxr2+rwoPVHTF8CBZtWoVx48fp7Ozk/Lycu644w5fTwmAxrZO6i2djExRX6Rb5o3kuxflsia/nD9t8k1mjDc4WNnEqJRYoiPCBjx2WEI0D102kS+O1Hql8rSszkJUuIm0+KhTxr85N5v2LiuvbtfVr6D0lcrtmsk4woXj0xmVMkSni7qANgJBRm8KjD9cNI4b87L4ywdFvBCkvVoLq5r6jQeczrLZWcwZPZTfvb2f6ibPKo2WGumhp7s4Jo9IZHpWEi9t0QFigKqmNjq6rU5ltJlMguXnjGJ7aQO7yho8N7kgRhuBIOPrFLvYnjEhBA9fM4WFE9L51fp9bNwbXNo1bZ3dFNe2nFEk1h8mk+CRa6fS1mXlN+v3eXB2p7ZKPJ2b52ZTVN3MlqN1vT4fSvS2gHGEpbPMxEWFe203UHyixeMLB28SsEbA31dOvppfie2LlHLqFyk8zMRfvzmT6VlJfG/1Tr46UuuL6XmEQ1XNSHlmpfBAjEmL44GFY3lnTyXv7vOMT1lKSXk/fu4rzhpBfHS4riDG8RqB04mPjuD6PDNv7znulbaiy5/dwj0vbPP4+3iLgDQC0dHR1NbW+q0hkFJSW1tLdHT0wAe7mdI6CymxkcRFnZkSGhMZxjPLZ2NOjuHO5/ODptqysKp3uQhHWHHeGCYMj+dX6/Z6ROK5wdJJU3sX5uSYXp+PiQzjuplmNu6tpLa53e3vH0iU1VkwCRiR1Pu/VX98+5xRdFkl//rSs+J8xxpaKam1sL20gW0lwbF7C8jkcbPZTHl5Of4qKQHKUJnN5oEPdDOldS1n7ALsSY6N5Pnb53Dt45/z7We28up3ziFzEF86f6KwspHIcBMjB1EdHRFm4scXj+fO5/PZXX6SeWNS3Do3R1a3N8/N5rnPi3llWzl3e6l2wR8prbOQkRhDZLjza9ORKbEsnJDOi1+V8p0Lcx1KEBgMW4vVD39EmODJj4/wj1sCXzomII1AREQEo0eP9vU0/JKSWguzRvZffGROHsLK2+dww9+/YPkzW3jlnrPP0NsJJAqrmhmbHkd4L/rzjjBphJKaKKpudrsRKKs3agT6MQJjh8UzZ9RQXtpSyl3njsFkCk2FdWfTQ09n+TmjeP/AFj4sqObSqRlunNnX5BfXExsZxi1nj+IfHx+m+EQLo1JjBz7RjwlId5Cmdzq7rRxraHVoRTwxI4Enb82jtNbCHSvzaev0jbqmOyisbGS8E5lBp5ORGM2QyDCKqpvdOCtFT6HYAJ/JzfOyKam18Pnh4InVOEt/AXRHmDcmhSGRYXzpwXjX1uI6Zo5M5vb5o4gwmXj608BPTdVGIIioqG/FKiE7xbGVydk5KTy6bDrbS+sDtqq4wdJBVWP7oOIBNoQQ5KTFcbjG/UagrJ8YjT2LpwwP6YYzlo4uTjS39+vKHIiIMBN5o4by5RHP+OpPtnZSWNXE7FFDSU+IZsn0EazdVkZ9gGsXaSMQRAwmu+KyqRn85srJvH+git9vDLwm6IW2RjIuGAGAnLRYDntgJ1BW14rZgc8jKjyM6/OyeG9/lVcyXPyNsjqlr+Sq6u28MUMprGrySJB9e0k9UkLeKOVuveu8MbR1Wj0ejPY02ggEESWGERjp5Gpq+TmjuHZmJv/6spTm9sBqgu6oZtBA5KbHcexkGy1uvn5n/Nw3zcmm2ypZk1828MFBxmDTQ0/HFtPxRN3F1uI6wk2CGVnKCIwbFs/549JY+UVJQLtTtREIIkprW5Q8QVzUwAefxs1zs2nt7OadPYFVSFZQ2UR8dDjDE1xLx7VpDh2pcZ+oXJcRo8ke6lj21ejUWObnprBqS5lX++d2dlt9nm7tLiMwNTPRY3GBrcV1TMlMJCby68yjFeeN4URzO+t2Vrj9/byFNgJBhG3VOZjskpnZyYxOjeXVbYGlY3OwqokJw+MdUp3sj5w0ZQSKaprcMS0Ajp9so8sqT1EPHYib546koqGVjw56p39ut1Vy8Z8/5v82H/LK+/VFWZ2FuKhwkocMLCHdH56KC7R1drOr7CSzR52aeXdOTgoTMxJ46pOjWAO08b02AkFESe3gU+yEEFw7I5Ovjtb1qF76O1JKCiqd0wzqi5EpsYSZBIer3bcTcLRBij2LJg0jLT7KaxLTO8vqOXqihY8O+rbmpi99pcHgibjA3oqTdHRbmT3q1LoAIQQrzhtNUXWzz/8NB4s2AkGClJKyOotL2RXXzFQtn1/bHhhb28rGNpraulyOBwA9xWbuTBN1pEbgdCLCTNyQZ+aDguqeZjSe5L39VQDsO9ZIe5fv/NpqF+ueokVPxAW2GEVivdXgXHHWCIYnRPPUJ0fc9n7eRBuBIKG2pYOWju5BVc3aMCcP4ewxKby2o9znPmJHKKi0yUX03lfYWXLS3ZsmWlpnIcwkyEh0Ll6xbHY2Enh5i+d3A5v2VRETEUZHl5UDx93nCnMGq9VYwLipH7Yn4gL5xfXkpMWS0ku8LSLMxG3zVeP7vRUn3fae3kIbgSChL+E4Z7lulpmSWgv5JfXumJZHsaWHulIoZk9uehzFtS1uq5corWslMynG6UrmrKFDOH9cGqu3lnm0Y1ZRdTNHTrRw2/xRAOws9c1nXtPcTnuX1W1GwN1xAatVkl9cx5zRfUtELJuTTWxkGP8MwN2ANgJBQlkvEtKD4dIpwxkSGRYQAeKDlU0MT4gm0cVgoo2ctDg6u2VPqq2ruLK6vXnuSKqb2tl8wHMB4vf2K+XUb80byfCEaHb4SI/f0apqZ3BnXOBgdRONbV3kjezbCCTGRLBsTjZv7T7OMS+48dyJNgJBQkmtBSHoU63SUWKjwlk8ZThv7z7u97nPBZVNLheJ2WNLE3VX0VhZnYWsQfq5LxyfRkZitEcriDftr2JqZiIjkmKYkZ3ETl8ZgUH2EegPd8YFtharHdLpQeHTuW3+KCTw3OfFLr+nN9FGIEgoqWtheEK0W9QTl84009Te5TGNfXfQ1W2lqKbZLUFhG2PS1C6qyA1xgZb2LmpbOga9ug0PM3Hj7Cw+OXSi50fSnVQ3trGjtIGLJw0DYHpWEiW1Fp/IWZfWqQVMposLGHvcGRfIL65jWELUgAbdnDyEy6ZmsOqrUpraAqdv9IBGQAgxXgix0+6vUQjxfSHEUCHEJiHEIeM22e6ch4QQRUKIQiHEJXbjs4QQe4znHhPuyAfTAK65Hk5n3pgUMpNieNWPs4SKay10dFndkh5qIyE6gmEJUW5JE7VlBrnymdw4Owsh4JVt7q8g3nRAZQVdPHk4ADOy1dfXF7uBsjoLGQnRRIW7T/7ZnXGB/OJ68kYNdSh99a5zR9PU3sXLWwOn6ntAIyClLJRSTpdSTgdmARbgdeBBYLOUciyw2XiMEGISsAyYDCwGHhdC2D7dJ4AVwFjjb7FbryaEcaVG4HRMJsE1MzL59FANVX6qY+MuuYjTyUmLc8tOwLZ6d6ZQ7HQyEmNYkJvKq9sr3F6ItGl/FdlDhzBumHKBTc1MJMwkfGIEbDUC7sYdcYGKhlYqGlqZPYA8u42zzEnMHT2UZz8r9mhQ35046w5aCByWUpYAS4CVxvhK4Grj/hJgtZSyXUp5FCgC5gghMoAEKeUXUuUfPm93jsYFWju6qW5qd1ozqD+unZmJVcLrO/xzN1BQ2YRJfO3Hdxe56XEcrm52OUXWXTII1+dlUdHQyhduTHdsbu/i86JaLp40rGd1GxMZxoTh8ewobXDb+ziKq30E+sIdcYF8oz5gdj+ZQadz17ljqGhoDRgJFmeNwDJglXF/mJTyOIBxm26MZwL2e6FyYyzTuH/6+BkIIVYIIfKFEPn+3D3MXxhMUdJAjEmLY2Z2Eq9u88+agYOVTYxKiXV7B6nc9Dia27uobnLNN15e30p8VDhJLmYuXTxpGPHR4ax1o6jcR4U1dHRbWWTEA2xMz0piV1mDV+UPbAsYTxgBd8QFthbXERcVzgQnalEumpDOmLRYnvrkiF9+d07HYSMghIgErgLWDnRoL2Oyn/EzB6V8UkqZJ6XMS0tLc3SKIYutRmCkg30EHOW6WWYOVTezxw8LYAqr3CMXcTo9GkIuZgiV1lkwu0EGIToijKumjWDjvkoa3RRsfG9/JUNjI8+ofp2RnUxTe5dH+ir0RXm9e+pbesMdcYGtR+uZOTKZMCf0uEwmwZ0LxrC3otFjvQ3ciTM7gUuB7VLKKuNxleHiwbi1JTSXA1l255mBY8a4uZdxjYvYXA+uVAv3xhVnjSAy3OQ2GYkvj9Ryx3NbXf4xa+vspri2xaVGMn3Rkybq4g9hmRtlEJbOMtPWaeXt3a67Fzq7rXxQUM1FE9LPKGKbkZ0E4NV6AU/UCNjjSlzgpEU1kZkzyrF4gD3XzswkJTYyIIrHnDECN/G1KwhgPbDcuL8cWGc3vkwIESWEGI0KAG8xXEZNQoh5RlbQrXbnaFygtLbFLa6H00mMiWDRpGGs21lBR5drQa76lg6+t2oHmwuqecPFOMOhqmakxCNGID0+iriocJd2AlJKFex0IShsz/SsJHLT43jFDQV8Xx2po6mtqyc11J7RKbEkRId7NS7grthJX7gSF9hWqs7JG6A+oDeiI8K45eyRbC6opqjaN3IcjuKQERBCDAEWAa/ZDT8CLBJCHDKeewRASrkPWAPsBzYC90kpbVVH9wL/RAWLDwMb3HANIU+pIRzniYzbpTPN1Fs6+bBw8JWrUkp+8cZe6i0dmJNjWLWlzCVfaWGVTTPI/UZACOGyhlBNkyGD4CYXhxCC62eZ2VZS7/IOZdP+SqIjTJw79kw3q8kkmJ6d7NUModI6C0Miw0iJjfTI67sSF9hytJ6IMME0c9Kg3vuWeSOJCvf/PsQOGQEppUVKmSKlPGk3ViulXCilHGvc1tk997CUMkdKOV5KucFuPF9KOcV47n4ZCFGTAKDEQ9kVAOeOTSUtPsolGYl1O4/x9p7j/GDROO4+P4cDxxtdijMUVjb2qH56gty0OJd2Ap4I1F8zI5Mwk3BpNyClZNP+Ks4dm3ZKYxR7pmclUVjZ6PYOa31hq2/xVMmQK3GB/F6ayDhDSlwU180y8+r2CmpcTDTwJLpiOMDptkrK61o9ElgDVbl69fQRfFhYTd0gGmpXNLTyy3V7yRuZzN3n5bBk+giiI0ysdqGYprCqmbHpcU4LszlKTnosVY3tg45d9Pi53eQOAkhPiOb8cWm8tr180F3H9h1r5NjJtjOyguyZkZ2EVeK1ZABP1QjYM5i4QFtnN7vLTzJnEK4ge+5YMJrObisv+HEfYm0EApyqxjY6uq2MdFE4rj+um2Wms1uy3skWelar5MdrdmG1Sv50w3TCTIKE6AgunzqC9TuPDXq1WVjZ6Dbl0N7ITXOt1WRprRIQc1XH6XSun2WmqrGdTw4NLm36vX2VmAQsnJDe5zHTDdeHN+ICttiJp3axNgYTF9hdrprIDCYeYE9OWhwLJwzjhS+Kae3wTy0ubQQCnBIPiG+dzoThCUwekeC0jMQznx3liyO1/OrKSafsVJbNyaK5vYu3B1FM02DpoKqx3SPxABs56a6liZbVW9ym42TPRRPTSRoSMWiX0Hv7q8gbObRXTXwbybGRjE6NZYcXZKVrmttp63SfhHRfDCYusNUoEstzsFK4P1acN4Z6Sye3PbfFLxVGtREIcGwS0u6sFu6N62aa2VNxskeuYSAOVjXxh3cL+cbEYdyQl3XKc3kjk8lJi2X1IJqm9PQQ8KARGDl0CBFhYtBB2FIX1EP7Iyo8jKunZ/Le/ipOWpxzVZXVWSiobOLiyX27gmxMz0piR1mDxwudBtN+czAMJi6QX1zH2PQ4kt0QsJ4zeij/s/Qs9pSfZPGjH/PmLv/KjNdGIMApqWshfBDdq5xlyfQRhJuEQwHiji4r31+9k/iocB65buoZQT8hBMtmZ7O9tMFho2LjoAczg2yEh5kYlRI7+J2AB/3cS2eZ6eiysn6Xc7syWxvJ/uIBNmZkJ1HT1M6xk57VjfJ0jYA9zsQFuq2S/JJ6l11B9lyfl8U7D5xLTnoc3121gx++vNNtxX+uoo1AgFNSayEz2fnuVc6SEhfFBePTeX1HxYCdtx59/yD7jzfy39dOJbUP18O1MzOJCBOs3uJcgLigsomE6HCGJ3jW6OWkxQ2qr0B7VzeVjW0eW91OHpHAhOHxTruE3ttXyfhh8Q5VlU/PSgJgp4fjAp6KnfSGM3GBg1VNNLV1MXsQRWL9MTIllrV3n833vzGWdbuOcemjn/S4nXyJNgIBjjslpAdi6axMqpva+bToRJ/HbC2u4+8fHebGvKwemeLeSImL4uJJw3ltR7lTDc4LK5sYPzzeYymFNnLT4yipszhdJFdR34qU7s0MskcIwfV5Wewqd9w1V9/SwdbiOodcQaBiQFHhJo/HBUrrPBM76Q1n4gI9onFu3AnYCA8z8f1vjGPN3WcTZhLc+I8v+J93C3yqOKqNQIDjyRqB07lwggpM9hUgbm7v4odrdpKZHMMvr5w04Ostm5NFg6WTd/dVDXgsqGySwqomj7qCbOSkx9JtlZTUOpch1FMB68EYzdWGa87R3cDmgmqs0jFXEEBkuIkpmYkeLxrz5gLGmbjAluJ6hidEe3SHMmtkMu88cC5LZ5n524eHue6Jz72q2WSPNgIBzMnWThosnR4PCtuICldiZu/1IWb2u7f2U17fyp9umE5cVPiArzc/JxVzcgwvb3UsQHz8ZBtNbV0eTQ+1kZum3sPZL2ZZvXJxePLHLSUuiosmpPPa9gqHVpCb9lcyPCGaqZmJDr/HjKwk9lSc9OgK1Vbp7i3mjh44LiClZOvROvJGJXt8txkXFc4flk7j79+aSWmdhSse+5QXvyrxuvKoNgIBjLeyK+y5bqaZ9q4zxcw27a9i9dYy7jk/x+FttMkkuDEvi8+Kah1acX8tF+G4rO9g6Wk16WRcoKzOQmS4ibR+0jDdwfV5WZxobuejwv5rBto6u/n44AkW2fUOcIQZ2cm0d1kpOO4Z3Zu2Ts/GTnrDkbhARUMrlY1tzHGif4CrLJ6SwcYHzmPWyGR+/vpe7no+36ttPrURCGC+rhHwXKHY6ZxlTiQ3Pe6ULKETze08+OpuJmYk8INvjHPq9ZbmmTEJWOOAXn5PeqgXdgKxUeGMSIx22giU1lrISo7B5IT08GC4YHwaqXGRA7qEPj10gtbObofjATam9yiKeiYuUO6FHdPpnGVOJCai/7jA1/UB3jMCAMMTo3n+9jn88opJfHzoBJc8+gkfFgxer8sZtBEIYLzhfz4dIQTXzTSTX1JP8YkWpJQ8+Ooemtq7ePTG6USGO/dfKiMxhgvHp7M2v3zArKODlU0MT4gm0c1qqX2hhOSciwmU1XvHzx0RZuLq6ZlsLqjqV87jvf2VxEeFM3d0ilOvPyIxmvT4KI9lCJV5MT3UhooLJPcbF9haXE98VLhX4k6nYzIJ7lgwmvX3zyclNpIVL+RT4YXiMm0EvMyfNx3kGTepCpbWtZASG+mQ/92dXDMjE5OA17aXsya/jPcPVPHTS8YP+otz4+wsqpva+XAA10ZBZRPjvPjlzElTaqLOdNryhhaOjaV5Ss6jL2nubqtk84FqLpyQ7rRxFkL0FI15Ak9LSPfFvDEp/cYF8ovrmDXKuSYy7mbC8ATW3T+fZ749m8wkz6fPaiPgRU40t/O3D4t48mP3tJ3zdmDNxvDEaObnprJ6axm/fXM/Z49J4fb5owf9ehdNSCc9PqrfCuKubitFNc1ubyzfH7npcVg6lO/aEU5aOmlq6/LaD9uE4QlMzUzs0yW0vbSe2pYOh7OCTmdGdjJHT7RQPwjhwIEorbMQExFGapxnJKT7or+4QH1LBwermj2SGuos0RFhvcp9ewJtBLzIGzsq6LJKKhvbnHYz9EZJrfdS7E5n6Swz1U3tmITgjzdMc8kHHh5mYuksMx8WVlPZR5Vqca3K2fdES8m+cLbVpG11a/ZQjUBvXJ9nZv/xRvYdO1P18719lUSECS4YP7gfk56isfIGF2bYO6UelpDui/7iAttKVPzDHXpBgYQ2Al5CSskr28p7tnef9VNw5QgdXVaONbR6TFN/IC6eNJxZI5P5/dKz3LJlvXF2FlZJnw3VbYVR3t4JgPNGwJuG+appI4gMM52xG5BS8t7+Ks7OSSU+enAxlLPMiZiEZxRFPSmt0R/9xQW2ltQRGWZimmH8QgVtBLzE3opGCiqbuPeCHLKGxvRbdesIxxpasUrvBtbsiYkM49V7z+GyqRlueb2RKbGck5PCy/llvfrgCyqbMImvf5i9QWpcJIkxEQ7XCnzdTMbzflwbSUMijRagx06pbj5U3UxJraXXNpKOEhsVzrhh8W4vGvOWhHRf9BUX2Hq0jqnmRK9UMPsT2gh4ibXbyogKN3HltBEsyE3ly8O1A2bD9EdJj3qo99JDPc2yOdmU17fy2eEzDeTByiZGpcR69QsqhCAnzXEhudI6C8lDIga98h4sS/PM1LV08EHB15XXm5wQjOuPGdnJ7Cytdyo4PhC1LR1YOrrJ9qKxtKe3uEBbZzd7Kk6S52a9oEBAGwEv0NbZzbqdx7hk8nASYyKYn5tKU3sXu13o3lTqJQlpb3LxpGEkDYnotetYYVWTV+MBNnKdSBP1pgyCPefmppIeH3WKS+i9fZVMy0pimItCezOykmhs6+Kok/IZ/eGL1GZ7eosL7CproLNbutxJLBDRRsALbNpfxcnWTq7PMwNwTk4qAJ+74BIqrW0hyguVqd4kOiKMa2eYeW9f5Slb9bbOboprW3ySu52TFseJ5naH9Pt95ecODzNx7UwzHxbWUN3URuXJNnaVn3TJFWRjhq1ozI1xAV9UutvTW1zAViQ2K8SCwuCgERBCJAkhXhFCFAghDgghzhZCDBVCbBJCHDJuk+2Of0gIUSSEKBRCXGI3PksIscd47jHh7dQAH7F2WzkjEqN7fvyHxkYyeUSCS3EBW2aQpytTvc2yOVl0dktet8t9P1TVjJSe7SHQFz3B4Zr+5RO6rZLy+lafxWiWzjLTbZWs23GMTQeUK8gdRiAnLY74qHB2urFyuLTW+1lUp3N6XGBrcT3jhsWRNMS7Kav+gKM7gf8DNkopJwDTgAPAg8BmKeVYYLPxGCHEJGAZMBlYDDwuhLA5cp8AVgBjjb/FbroOv+X4yVY+OVTD0lnmUwpQFuSmsr2kAUvH4Prs+jKw5knGDYtnZnYSq7aU9tRSFHqhkUxf2IzA4er+3SHHT7bSZZU++0xy0+OYkZ3E2m1lvLevktGpsW4JoptMgmlZSW7dCZTWWRiWEOXTAKx9XKDbKtleUu8X9QG+YEAjIIRIAM4DngaQUnZIKRuAJcBK47CVwNXG/SXAaillu5TyKFAEzBFCZAAJUsovpPp2P293TtDy2vYKpISls05tsTg/N5WObitbi51fYfVkVwRRPMCeZbOzOVzT0pO3XVjZSGS46vblbczJQ4gMN1E0QIZQWZ33tXBO5/pZWRysaubTIucF4/pjRnYSBZVNbmuU7g8LGPu4QEFlI03tXdoI9MMYoAZ4VgixQwjxTyFELDBMSnkcwLhNN47PBOwje+XGWKZx//TxMxBCrBBC5Ash8mtq+pcS8GeklKzNL2Pu6KFn/GDPHjWUyDDToOoFbNkVvqoR8DSXn5VBXFQ4q4yuY4VVzYxNj/NJKX+YSTAmNXbALmM9Wjg+dHFcMS2DqHATUrrHFWRjelYS3VbJHhcSGezxVezEHvu4QL6xEAvFzCBwzAiEAzOBJ6SUM4AWDNdPH/T2TZX9jJ85KOWTUso8KWVeWpp3Sqc9wdbieoprLVx/WqN1UHn2s0Ym8+kh541Aj3pokO4EYqPCuXLaCN7ec4zGtk4KKxt94gqykZMWN+BOoLTOQphJkJHk2baX/ZEQHcGV00aQkRjNjGz3/aDZKofd0Wmsvaub416WkO4LW1zg3X2VjEiM9mmMwpc4YgTKgXIp5VfG41dQRqHKcPFg3FbbHW//q2cGjhnj5l7Gg5a1+WXERoZx2dTe2ywuGJvK/uONTmuHl9Yp/7Q3JaS9zU1zsmjrtPL858VUNbZ7RT66L3LS4yirs9DW2bc7pKzewoikaCI83Ot5IH539RTe+u4Ct+6aUuKiyB46xC1FY7b2m/5iBAA+P1zr1qbygcaA/2OllJVAmRBivDG0ENgPrAeWG2PLgXXG/fXAMiFElBBiNCoAvMVwGTUJIeYZWUG32p0TdLS0d/H2nuNcflYGQyJ7V/mcn2ukih4euO+pPaW1rQjhnQbdvmJqZiITMxJ4/N+HAd8EhW3kpsdhlVDcT658aZ3Fp64gG9ERYaR4IG14RrZ7gsO+Ug/tDVtcAHB7U/lAwtFly3eBF4UQu4HpwH8BjwCLhBCHgEXGY6SU+4A1KEOxEbhPSmlbQt0L/BMVLD4MbHDPZfgf7+w5jqWjmxt6cQXZmJqZSHx0uNNxgZK6Fq816PYVQghumpOFxQhG+tYdNHCXsbK6Vr/4YfMU07OSqGxs4/hJ1/TtfV0jYI8tLgAw24udxPwNh4TopZQ7gbxenlrYx/EPAw/3Mp4PTHFifgHL2m3ljEmN7bf4JMwkOCcnhU8OnUBK6XA2hz8E1rzBkmmZPPz2AaLCTQx3sfLVFcakxiFE32milo4uTjS3B/VnYosx7CxtIGPq4HegpXUWVeQY7x9FjkumZ9LY2sm4dN8tMnyNrhj2AMUnWthytI7rZpkH/GFfkJtKRUNrzzbZEUpqLUGbGWRP4pAI7lgwmiunjfC65LA9MZFhZCbF9BkctqWHBrMRmJgRT2SYyeW4gK8kpPti6Swz6+5fEHRFl87g3ZZUIcIr28oxCdWUfSBscYFPi044JAbX2tFNdVN7UGkG9cdPF0/w9RQAQ0OoD3eQP7k4PEVUeBiTMxNcjguUBrnbLBDROwE3022VvLq9nHPHpjE8cWAXxujUWEYkRjscF/harlh/kbxJblocR0703mqytKdGIHgD9QAzspLZXdEwaPVbKWXIuDIDCW0E3MxnRSc4frKtRyxuIIQQzM9N5fPDtXQ7INdrqxEIJgnpQCAnPY62Tmuvjb9L6yzERoYxNDa4dWemZyfR1mmloLJ/HaW+qLd00tzuvfabGsfQRsDNrN1WTtKQCKd03BeMTaXB0sn+Y40DHutPKXahxNdCcme6hMrr1erWX/zcnmKGrd3kIOMC+v+uf6KNgBs5aenk3X2VLJk2gqhwx9M3beqijqiKlta2EB8VTvIQ7zYuCXVs/YZ7iwuUhoiLw5wcQ2pc5KDjAr7uI6DpHW0E3Mj6XRV0dFl7lYnoj7T4KCYMj3coLlBiCMcF+6rT3xgaG8nQ2MgzWk0qP3doBDuFEEzPSmbHIGWl/UFfSXMm2gi4kbXbypkwPJ7JIxKcPnd+bipbiuv6lSYA/1BgDFV6azV5ormD1s7ukPlMZmQncaSmxaEmO6dTWmshLT6KmMjgLXIMRLQRcBOFlU3sLj/J9XlZg1qlL8hNpaPL2iOf3BvdVkl5XaveTvuI3PS4M4xAT2aQj/rlepueuEB5g9Pn6gWMf6KNgJtYm19GuElw9fQRgzp/zuihhJtEv3GBqsY2Orqt+ovkI3LS4qi3dFLX0tEzFgo1AvZMNScihKocdhZtBPwTbQTcQGe3ldd3VLBwYvqgxbtio8KZmZ3cb1ygJz00iNVD/ZkcW4aQ3W7AZgRCRYY4PjqCcenxTscFOrqsHD/pu/abmr7RRsBASsneipM0tzvf7vGDgmpqWzr6FYtzhPm5qeypOEmDpaPX520S0qFSLexv5NoyhOyCw6V1FtLjfdsq0dtMz0piZ1lDT/tPRzjW0IrVTySkNaeijQBQVN3ETU99yRV/+ZQ5D7/PT9buYmtxncP/ydfml5MWH8X541xrgLNgbApSwhd9SEuX1lkINwkyHKhE1rifzKQYoiNMp+4E6kPPxTEjO4kGSye/fWs/L35VwkcHazhS09xvUoOuEfBfQlo7qLWjm798cIinPjlCTEQYP7tsAoerW3hr97EeFdDr87K4bmYm6X2oWNY0tfNhYTV3LhhNuIsNRc4yJxEXFc6nRSe4dGrGGc+X1FrITI5x+X00g8NkEoxJjTvNHdTK3BCTIT5/fBpj0+P415cldHafulBKj48ia+gQzMkxZCWrW3PyELYbXcm0EfA/QtYIfFBQxa/W7aO8vpVrZ2bys8smkmr483915STe3nOctfll/H5jAX98r5ALx6dxfV4WF01IP6V71Bs7Kui2SodlIvojIszEvDFD+4wL6MCa78lNj+v5QevosnLsZCvmEPtMMhJj2PTD8+m2Sqqb2iira6W83tJzW17fyraSet7affwUKZToCBPpfiIhrfmakDMCxxpa+X9v7uPdfVXkpsexesW8njZzNmKjwrkhL4sb8rI4UtPM2m3lvLqtnPcPVJMaF8m1M83ckGcmJy2ONfllTM9KItdNeuTzc1N5/0B1r0JbpXUWLu9lh6DxHjlpcby5+xitHd1UNbb5TatEXxBmEmQkxpCRGMOcXnZDXd1Wjp9so7xeGYf0hOiQlmz2V0LGCHR2W3n2s6M8+v4hrFLy08XjuXPBGCLD+3etjEmL4z8WT+BHi8bx0cEaXt5axjOfHuXJj48wMSOBQ9XNPHyN+/rkLOhpOXmCG4dm94yfbO2kwdIZsj84/kJuehxSwpETzdQ2qwC+/kx6JzzMRNbQIcZiJmXA4zW+ISSMQH5xHb94Yy8FlU0snJDOb66a7HSqWniYiYUTh7Fw4jBqmtp5Y0cFL+eXMTQ2kiunDa42oDdy0+NIj4/i06Jabpz9tRGwpSLqzCDfkpP+davJpjaVSRYqhWKa4CSojUB9SwePbCjg5fwyRiRG849bZnHxpGEu6+6kxUdx13ljuPPc0XRbpVsDtUIIFuSm8tHBGqxW2bN9ttUIZOsaAZ8yOjUWk4DDNS20d3UTGWZiWLzO1tIELkFpBKxWySvby/nvdw7Q1NbF3eeN4XsLxxIb5d7LFUIQHuZ+H+f83FRe21FBQWUTkwwdohKjRkBLRviWqPAwsocO4XB1MxKJOTlG+7k1AY1DS1ghRLEQYo8QYqcQIt8YGyqE2CSEOGTcJtsd/5AQokgIUSiEuMRufJbxOkVCiMeEh6QwJfDCFyXkpsfx9vfO5aHLJrrdAHgSW8tJ+yyhsjoLKbGRxAXQdQQrOWkqTTRUJKQ1wY0zfowLpZTTpZR5xuMHgc1SyrHAZuMxQohJwDJgMrAYeFwIYSunfAJYAYw1/ha7fglnEmYSPHfbbF5ecTbjh7sna8ebDE+MJjc97hQdoZJa/YPjL+Smx3H0RAsltTplVxP4uOLMXgKsNO6vBK62G18tpWyXUh4FioA5QogMIEFK+YVUpbjP253jdlLiogJ6m74gN5UtR+to71JVmKV1Fh0U9hNy0uLo6LbS1Nalg8KagMdRIyCB94QQ24QQK4yxYVLK4wDGbboxngmU2Z1bboxlGvdPHz8DIcQKIUS+ECK/pqbGwSkGF/NzU2nt7GZHaYMqSmpoZaRedfoFNiE50OmhmsDHUQfzfCnlMSFEOrBJCFHQz7G9Lb9lP+NnDkr5JPAkQF5enuMqVUHE3DFDCTMJPis6wbCEaKwS7Q7yE2xCcqA/E03g49BOQEp5zLitBl4H5gBVhosH47baOLwcsJfTNAPHjHFzL+OaXkiIjmCaOZFPi070iG+NTNHpof5A4pCIHokRbQQ0gc6ARkAIESuEiLfdBy4G9gLrgeXGYcuBdcb99cAyIUSUEGI0KgC8xXAZNQkh5hlZQbfanaPphQW5qewqa2BvxUlAux78idz0WJKGRJAQHeHrqWg0LuGIO2gY8LqRzRkOvCSl3CiE2AqsEULcAZQC1wNIKfcJIdYA+4Eu4D4ppU1j9l7gOSAG2GD8afpgfm4qj31QxNr8MqLCtfiWP/HNuSMprW3x9TQ0GpcZ0AhIKY8A03oZrwUW9nHOw8DDvYznA+4T2glyZmQnExMRRnGthbHpcQGd7RRsXOVGqRCNxpdoYXo/JjLcxNwxSp1Ru4I0Go0n0EbAz7Gpimq5CI1G4wm0EfBzFoxVRmB0qs4M0mg07kcL0fg5E4Yn8My385g7WuuxazQa96ONQABw0YRhvp6CRqMJUrQ7SKPRaEIYbQQ0Go0mhNFGQKPRaEIYbQQ0Go0mhNFGQKPRaEIYbQQ0Go0mhNFGQKPRaEIYbQQ0Go0mhNFGQKPRaEIYbQQ0Go0mhNFGQKPRaEIYbQQ0Go0mhAleI9Dd6esZaDQajd8TnEZASlj9TVj/PWg76evZaDQajd8SnEbA2g3pE2HHC/C3eXDwXV/PSKPRaPwSh42AECJMCLFDCPGW8XioEGKTEOKQcZtsd+xDQogiIUShEOISu/FZQog9xnOPCSE80zk9LBwW/RbufB+iE+GlG+C1u8FS55G302g0mkDFmZ3AA8ABu8cPApullGOBzcZjhBCTgGXAZGAx8LgQIsw45wlgBTDW+Fvs0uwHInMW3P0RnP8fsPcV+Ntc2L/eo2+p0Wg0gYRDRkAIYQYuB/5pN7wEWGncXwlcbTe+WkrZLqU8ChQBc4QQGUCClPILKaUEnrc7x3OER8GFP4MV/4b44bDmFlizHJprPP7WGo1G4+84uhN4FPgpYLUbGyalPA5g3KYb45lAmd1x5cZYpnH/9HHvMHwq3PUBLPwVFL4Df5sDu9eqILJGo9GEKAMaASHEFUC1lHKbg6/Zm59f9jPe23uuEELkCyHya2rcuGIPi4BzfwT3fAopOfDanbDqJmg85r730Gg0mgDCkZ3AfOAqIUQxsBq4SAjxL6DKcPFg3FYbx5cDWXbnm4Fjxri5l/EzkFI+KaXMk1LmpaWlOXE5DpI2Hm5/Fy75Lzjyb5VBtP0FvSvQaDQhx4BGQEr5kJTSLKUchQr4fiCl/BawHlhuHLYcWGfcXw8sE0JECSFGowLAWwyXUZMQYp6RFXSr3TnexxQGZ98H936mXEXr74cXroGTFT6bkkaj0XgbV+oEHgEWCSEOAYuMx0gp9wFrgP3ARuA+KWW3cc69qOByEXAY2ODC+7uHlBxY/iZc/r9QtgX+Ph8KfT8tjUaj8QZC+rkLJC8vT+bn53vnzU4UwSu3QeVumPcd+MZvVHaRRqPRBBhCiG1SyryBjgvOiuHBkpqrCszm3gNfPg5PL4Law76elUaj0XgMbQROJzwKLv09LHsJ6kvgH+epVFKNRqMJQrQR6IsJl38dNH7tTlh3H3S0+HpWGo1G41a0EeiPRDMsfwvO+wnseBGevAAq9/p6VhqNRuM2tBEYiLBwuOgXcOsbSpb6qYtg69O6pkCj0QQF2gg4ypgL4J7PYNQCePuHsOZWaG3w9aw0Go3GJbQRcIa4NLj5FSVTXfgO/P1cKNvq61lpNBrNoNFGwFlMJpj/gJKdEMBzl0PVfl/PSqPRaAaFNgKDxZwHd34A0Qnw+t3Q1eHrGWk0Go3TaCPgCnFpcOX/qQrjj//g69loNBqN02gj4CoTLofpN8Mn/6vjAxqNJuDQRsAdLP5vSMhUbqEOi69no9FoNA6jjYA7iE6Eqx+HusPw/q99PRuNRqNxGG0E3MXo85Ty6JYn4fAHvp6NRqPROIQ2Au5k4a8gdRy8cR+01vt6NhqNRjMg2gi4k4gYuOYf0FwFG/7D17PRaDSaAdFGwN1kzoTzfwq7X4b9vuueqdFoNI6gjYAnOPdHMGIGvPl9aKry9Ww0Go2mT7QR8ARhEcot1GmBNx/QiqMajcZv0UbAU6SNh4W/hoMbYMe/fD0bjUaj6RVtBDzJ3Htg1Lmw8UGoL/b1bDQajeYMBjQCQohoIcQWIcQuIcQ+IcT/M8aHCiE2CSEOGbfJduc8JIQoEkIUCiEusRufJYTYYzz3mBBCeOay/ASTSRWRIeCN74DV6usZaTQazSk4shNoBy6SUk4DpgOLhRDzgAeBzVLKscBm4zFCiEnAMmAysBh4XAgRZrzWE8AKYKzxt9h9l+KnJGWrxvUln8GXj/t6NhqNRnMKAxoBqWg2HkYYfxJYAqw0xlcCVxv3lwCrpZTtUsqjQBEwRwiRASRIKb+QUkrgebtzgpvp34Txl8Pm30L1AV/PRqPRaHpwKCYghAgTQuwEqoFNUsqvgGFSyuMAxm26cXgmUGZ3erkxlmncP328t/dbIYTIF0Lk19TUOHE5fooQSnI6Kh5eW6F7D2g0Gr/BISMgpeyWUk4HzKhV/ZR+Du/Nzy/7Ge/t/Z6UUuZJKfPS0tIcmaL/E5cGVz6qeg+8chsUva+NgSYwsdTBZ49B20lfz0TjBsKdOVhK2SCE+DfKl18lhMiQUh43XD3VxmHlQJbdaWbgmDFu7mU8dJh4JZz7YxUbKHgLohJh3MWqJ0HuIoiK8/UMNYGO1QrdHRAR7ZnXb66G56+G6n1QvhVueF7tdDUBiyPZQWlCiCTjfgzwDaAAWA8sNw5bDtg0EtYDy4QQUUKI0agA8BbDZdQkhJhnZAXdandO6LDwl/DTI3DTamUUijbD2m/DH8bASzfC9ueh5YSvZ6kJRI58BE+cA3+eDKVfuv/1T1bAs5dC/VE4axkcWA/5T7v/fTRexZGdQAaw0sjwMQFrpJRvCSG+ANYIIe4ASoHrAaSU+4QQa4D9QBdwn5Sy23ite4HngBhgg/EXekTEwPhL1V93F5R9CQVvw4G34OBGEA9A1jyYeIXaJSSP8vWMNf5MQxm893OlVZU0UsWeVl4JV/0Fpi1zz3vUHYXnr4LWBvjWa5A1F1pqYOPP1P3hU93zPhqvI6SfSxrk5eXJ/Px8X0/DO0ipYgY2g1C9T40Pn6pkKIZN9u38NP5FZxt8/hfV2hTg3B/COd+FzlZYcysUfwILfggX/VLVrAyWmoPKAHS1KQOQOVONN9fA3xcoo7Pi39qd6WcIIbZJKfMGPE4bAT+m7ogyCJ8+qnYDd2xy7cuscR8V26G1DnK/4f33lhIKN8C7D6lK9ElL4OLfqZoUG10d8M6PlHtx4pVqEREZ6/x7Ve5RMQBhglvfOHMhcuQjeH4JTLsJrnnChYvSuBtHjYD+RfFnho5RK7uLfwcV+UqeWuN7Dr4LzyxWMRxv132cKIIXl8LqmyAsCm5dp4Kz9gYAIDwSrnwMLn5Y7SqfvRQanczDKM+H5y6H8Ci4bUPvO9Ex58N5P4FdL8Gu1YO/Lo3P0EYgEDjrRsjMU/2L25t8PZvQZt/rsPqbkD5BuUHe+qF35EDam2DTr+DxeVC2BS75L7j3MxhzQd/nCAHn3K+SEGoPw1MXwbEdjr1f8adqhR8zVBmA1Ny+jz3/PyD7HPVvceKQU5flc6RU7rMQRhuBQMBkgkv/oDqWffxHX8/ma5oqwdo98HHBws6X4JXblUFe/iYs+i2Ufq5WwZ5CSti9Bv46Gz77PzjrBrg/H86+T0mWO8L4xXD7u2AKh2cuhX1v9H/8offhX9dBQqYyAMkj+z8+LByu+6faMay9TcUqAoGWWnjhGvjjeM9kUwUI2ggECuZZMO2bqsag9rBv59J2Et75CfzvBHjyfCjb6tv5eIMtT8Eb98Lo8+CW1yA6EaZ/S2VxvfdL9YPibpqq4NnL4LW7IG4Y3PG+EiSMH+b8aw2fAnd9oJIM1i6Hj/+n9z4XB96EVcsgdSzc9g4kZDj2+omZcPUTULUH3vuF8/PzNhXb1P/dks/Vju6Fa6H4M1/PyidoIxBIfOPXEBbpuy+ZlGoV+dc56kdx2jL14/f0N2D9d1UlaTDy2f/BOz+GcZfCTS9/HWA1meCKP0N7o3LVuJPuLrXrOLZDSY7c9QFkzXbtNePS1Q5m6vXwwe+UhIn9qn33WlizHEZMh+VvQWyqc68/fjHMuw+2PgX717s2V0+y7TkV00HAHe/Cne8rI/biUhXodjdSqs+x7qhfNphyqmJY42Pih8N5P4b3f6OKzHIXeu+960vU6v/QuzD8LLjpJcicpXzV/34EvnxCBSC/8RuYcUtwZDFJCf/+b/jo9zD5Wrj2yTNdMMMmwdn3w2ePKqHAUfPd894f/g5KPlVZPe7K9QdVSXztU5A6Xr1HfTEsewkK31Fd8EYtgJtWqdXxYPjGb5SLbP39kDFtYFeSN+lsVcZ8x78g5yK47mkYMlQ99+23YeVV8NIN6t/DXd+t9ib177r3VfU4KlHtxoZPhYyz1Hcpbbzjrj0PoFNEA42udhUcNEWowKCn//N0dyoX1L8fAQRc9HOYc7fyA9tTtQ/e/hGUfgHm2XD5n9R/8kBFSrXj+uKvMONbKtPGFNb7sR0WeHwuhMfAPZ+qzBxXKNwIq26Emcvhqsdce63+2Pc6vH6v2tlYTijpkhtfUMWMrlB3BP5+ngqe37bBpz9wPdSXwJpb4Pgulc10wUNnfp4tJ1Qw/MRBuPFFJeniCpV7leut7gic91O1iKvcrdJuK/dClxGQDouE9InKIGRMU7fDJrtcd6HrBIKZwg3Kb7v4EZh3r+fep2wrvPV9qNoL4y9TwemkrL6PlxJ2rVI+8tY6mLMCLvyZ8p8HElYrvP1D2PasMniLHxl4Z3PwXbWKvOiXarc2WOqL4R/nqcrfOzZ5TgPIRsV2ePkW5Wq65h8quOsO9r6q3Fnzvw+L/p97XnOwFL0Pr96pPtdr/6Eq9fvCUgcvXA1V++GGlapi31mkhB0vqJ1zdBIsfVrtsOyxdkNtERzfDZW7lGE4vlt9bwAQkJKj/g/YditOoo1AMCMl/OtaKN8G39vuvO92IFobVO+D/GcgPgMu+x8lYeHw+fWw+T/V+XHpKp1xynWBITTW3QXrvqNqMhb8EBb+yvF5v3wLHHoPvvMlDB3t/Ht3tcMzl0DtEbj736pOxBtYrZ5x363/HmxfCd961TdFdVarqqb+8GFIn6R2OSk5A5/X2qC+X8d3wdJnVDGeo3S0qB3xrlUw+nyVNRWXPvB5oL7XjRWGYditjMS1Tw36e6ONQLBTU6jEwmbcoiSq3YGUsO812PiQ0oWZe49ayQ/WP1yxTX0hju1QvZYv/1/l//RXutrh1TtUhsxgVvQnK+BvcyB7Htz8ivNf3rd/BFv/qVwRzhhdf6XDomoTWmqU6zJ+uPfeu7UBXr9baXFNvV4F152pmG47CS9erwrmrntKLWIGorpAuX9qCuGCB5XbqS8XohfQFcPBTtp45W7Z9pxaObhKfbHKjnjldvVlvesDWPzfgzcAoALHd25W8YHK3fDEfNjwoHIVlOcr7Rl/WYR0tqoisANvKvfPYFw6iZlw0S+U+2H/G86du3utMgDnfDc4DABA5BC4/jm1On7tLu/VlFTuhScvUJ/Dpf+jVtPOSmZEJ6odTPY85UraNUC1/q7V8NSFYKmFW15XRsCHBsAZ9E4gkGltgL/MVJket70zeHfLnlfgze8DUv2Izb7rzMCvqzTXqDTKXas4pZdQxBAleZA0Ut0mj/z6cfJI5VP1tBupvQlW3aSqZK96DGbeOvjX6u5SPwbN1XD/FsfiITWF8OSFKpC+/E3/CKS6k+3PqxTiC38B5//Es++1e41yQ0UnKjmN7LmuvV5Hi4q/Hf0ElhhJAvZ0tirf/44XYOQC5f5xtLbCw2h3UKiQ/6wK3i59xrEtqz0dFtj4oPLbmueoANbpGjTupr0JGkrVX32Jcb9E/dWXQvtp3aqiEmDcJUoW2dWslb7m8+L1Sorh2idh6lLXX7NiGzy1UO3ULvvDAO/frFwmrXVw9yd+8wPiVqRUO4G9r8LNaz0XH9jxoornjJwPS58dXFFdb9h2iYc/gCsehbzb1PiJIuX+qdoL5/4ILviZ+xdPLqCNQKhg7VaVj5Z6uH+r2oI7QnWBamZTcwAW/AAu/Ll/rEBb6081EDUFKq979LmwbJV75YrtDcDSZ2Dy1e577bd/rNw7d33wtfTy6UipCrb2rFUKnf3pAAU67c0q6N1Qpv5N+tMiGgylX6oeCtlnKzeOu/8vd7apFNND78Flf4SYZJX/Hxap3E1jfRD4HgBtBEKJks+VSuT5D8KFD/V/rJTqR/Wdnyg/6bX/8E3mhjPsWq0kG8yz4ZtrICbJ9df0pAEAFVj862wjvvJh7/7hrU+rVFRvuEn8gfoS5SqLGQp3bXZf6nBDmXrdqHgVgxpkSuWAdLUrbaTCt9XjrLnq/06iuf/zfIQODIcSI89RFa2fPapWz33R3qS25evvV3nh937m/wYAVMXs9c+pnPbnr3Jdp8fTBgDUD9zi/1ZphlueOvP5YzuUKy53kXIlhALJI5Wfvv4ovOqmQHFHi4rndLUrSQ9PGQBQNRQ3rFQxs/N+oqqM/dQAOIM2AsHCot8Com8Nm2M7VRHS3leV6+eWN7ybsucqk5aocv7qAqVx31Q1uNfxhgGwMflayFmodHrstfxb61Xnr9h0FYcIBokNRxm1AC79vZIf+eA/XXstqxVev0d14Fv6DKSNc88c+yMsAi7/o0qg8Af3qRsIof99QU5SFiz4vpICKP7063Ep4at/wNOLlF9z+Vtw/k8DJn3tFMZdrAKLDaXw7GLlBnAGbxoAUFlNl/8RrJ1q1Q/GD9e90Hhc7W48uXL1V2bfCbNug0//rDLTBstHj6hm94v+E8Yuct/8QgxtBIKJc74HiVkqF9/arVacL38LNvwUxlyodG3cJXDmK8acr/KwW06oOEjdEcfO87YBsDF0jKo52L8ODr4Hnz8GBzfAJQ+7rgoayFz6B9WIZt19jje6sWfva0rYb/rNqreCZtAMaASEEFlCiA+FEAeEEPuEEA8Y40OFEJuEEIeM22S7cx4SQhQJIQqFEJfYjc8SQuwxnntMiEDQEQggIofAxf+pNN03PgR/P1dp2lz8MHzzZYhN8fUM3UP2XJVP39GimqRUF/R/vK8MgI1zvgep41QsZvNvYfI1Kn00lAmPVPGB2DRYfbOqq3CUYzvhje+owOwVfw4MORI/xpGdQBfwIynlRGAecJ8QYhLwILBZSjkW2Gw8xnhuGTAZWAw8LoSw+R6eAFYAY42/xW68Fg3ApKtV0cqWf6jm4Le/q1oMBtsXZcR0FZhDwnOX9V017WsDACqgeMWfVWe4oaNVzUOwfR6DIS5NxXksdUp3qat94HOaqlTO/pAUuPFf7hO8C2EGNAJSyuNSyu3G/SbgAJAJLAFWGoetBK427i8BVksp26WUR4EiYI4QIgNIkFJ+IVVe6vN252jchRCqsvGCh+CeT1RHsmBl2CQlVRweAyuvOLPDmT8YABujFsA316rG8K5IcQQbGWepbmllXyqt//5S1jvb4OWblZvzplWOC7Np+sWpmIAQYhQwA/gKGCalPA7KUAC2TyQTsI/YlRtjmcb908d7e58VQoh8IUR+TU2NM1PUgFptXvBg4Ek4D4aUHLh9g8o9f+Hqr4Pi/mQAbIy7OChSCt3OlGvh3B8reYne0mlBGYc3H4DyrUryOpB7VfgZDhsBIUQc8CrwfSllY3+H9jIm+xk/c1DKJ6WUeVLKvLS0NEenqAlVkrLVjiAhUzVI3/eG/xkATf9c+HPVs2Ljg723ePz8Mdi9WkkzTLrK+/MLYhwyAkKICJQBeFFK+ZoxXGW4eDBubZGdcsC+84gZOGaMm3sZ12hcJyFDieiljlV6LtoABBYmk1rh2z6/+uKvnyvcCJt+rQLq5//UZ1MMVhzJDhLA08ABKeWf7J5aDyw37i8H1tmNLxNCRAkhRqMCwFsMl1GTEGKe8Zq32p2j0bhObKqqg5h2k2ogog1AYBGdoALFUsKqbyq9oeoDSso54yxY8rgOqHuAAbWDhBALgE+APYDVGP4ZKi6wBsgGSoHrpZR1xjk/B25HZRZ9X0q5wRjPA54DYoANwHflABPQ2kEaTYhx+APl1ht7sRIQ7GxV+kuJvYYQNX2gBeQ0Gk3g8sXj8O5DEBalUoFDubBukDhqBPxH/Fqj0WhszLsXrF2QNkEbAA+jjYBGo/E/hID53/P1LEICrR2k0Wg0IYw2AhqNRhPCaCOg0Wg0IYw2AhqNRhPCaCOg0Wg0IYw2AhqNRhPCaCOg0Wg0IYw2AhqNRhPC+L1shBCiBigZ5OmpwAk3TieQCOVrh9C+/lC+dgjt67e/9pFSygG1+P3eCLiCECLfEe2MYCSUrx1C+/pD+dohtK9/MNeu3UEajUYTwmgjoNFoNCFMsBuBJ309AR8SytcOoX39oXztENrX7/S1B3VMQKPRaDT9E+w7AY1Go9H0gzYCGo1GE8IEpREQQiwWQhQKIYqEEA/6ej7eRghRLITYI4TYKYQI6t6cQohnhBDVQoi9dmNDhRCbhBCHjNtkX87Rk/Rx/b8RQlQYn/9OIcRlvpyjpxBCZAkhPhRCHBBC7BNCPGCMB/3n38+1O/3ZB11MQAgRBhwEFgHlwFbgJinlfp9OzIsIIYqBPCll0BfMCCHOA5qB56WUU4yxPwB1UspHjEVAspTyP3w5T0/Rx/X/BmiWUv7Rl3PzNEKIDCBDSrldCBEPbAOuBr5NkH/+/Vz7DTj52QfjTmAOUCSlPCKl7ABWA0t8PCeNh5BSfgzUnTa8BFhp3F+J+nIEJX1cf0ggpTwupdxu3G8CDgCZhMDn38+1O00wGoFMoMzucTmD/McJYCTwnhBimxBiha8n4wOGSSmPg/qyAOk+no8vuF8IsdtwFwWdO+R0hBCjgBnAV4TY53/atYOTn30wGgHRy1hw+bwGZr6UciZwKXCf4TLQhA5PADnAdOA48L8+nY2HEULEAa8C35dSNvp6Pt6kl2t3+rMPRiNQDmTZPTYDx3w0F58gpTxm3FYDr6NcZKFEleEztflOq308H68ipaySUnZLKa3AUwTx5y+EiED9CL4opXzNGA6Jz7+3ax/MZx+MRmArMFYIMVoIEQksA9b7eE5eQwgRawSKEELEAhcDe/s/K+hYDyw37i8H1vlwLl7H9gNocA1B+vkLIQTwNHBASvknu6eC/vPv69oH89kHXXYQgJEW9SgQBjwjpXzYtzPyHkKIMajVP0A48FIwX78QYhVwAUpCtwr4NfAGsAbIBkqB66WUQRk87eP6L0C5AyRQDNxt85EHE0KIBcAnwB7Aagz/DOUbD+rPv59rvwknP/ugNAIajUajcYxgdAdpNBqNxkG0EdBoNJoQRhsBjUajCWG0EdBoNJoQRhsBjUajCWG0EdBoNJoQRhsBjUajCWH+P/dgt4ll8mKHAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0126.500000135.500000
1122.750000133.250000
2108.375000130.625000
3119.937500125.062500
493.218750123.781250
5129.859375116.140625
6130.429688119.570312
7111.714844122.285156
8117.357422119.642578
9100.928711119.071289
10133.464355114.535645
11135.732178119.267822
1294.616089123.383911
13139.808044116.191956
14131.904022122.095978
15110.452011124.547989
16136.976006121.023994
17101.988003125.011997
1895.744001119.255999
19136.622001113.377999
20132.811000119.189000
21105.405500122.594500
22131.702750118.297250
23118.351375121.648625
24111.175688120.824312
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 126.500000 135.500000\n", + "1 122.750000 133.250000\n", + "2 108.375000 130.625000\n", + "3 119.937500 125.062500\n", + "4 93.218750 123.781250\n", + "5 129.859375 116.140625\n", + "6 130.429688 119.570312\n", + "7 111.714844 122.285156\n", + "8 117.357422 119.642578\n", + "9 100.928711 119.071289\n", + "10 133.464355 114.535645\n", + "11 135.732178 119.267822\n", + "12 94.616089 123.383911\n", + "13 139.808044 116.191956\n", + "14 131.904022 122.095978\n", + "15 110.452011 124.547989\n", + "16 136.976006 121.023994\n", + "17 101.988003 125.011997\n", + "18 95.744001 119.255999\n", + "19 136.622001 113.377999\n", + "20 132.811000 119.189000\n", + "21 105.405500 122.594500\n", + "22 131.702750 118.297250\n", + "23 118.351375 121.648625\n", + "24 111.175688 120.824312" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "learning = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test2-checkpoint.ipynb b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test2-checkpoint.ipynb new file mode 100644 index 0000000..9a03e53 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test2-checkpoint.ipynb @@ -0,0 +1,3054 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.00001,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=2_000_000, discountFactor =0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 actions: tensor([3, 3, 3])\n", + "loss= tensor(7.4946, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6536])\n", + "--------------------------------------------------\n", + "1000 actions: tensor([0, 2, 3])\n", + "loss= tensor(7.3520, grad_fn=) , return= 16033.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5599])\n", + "--------------------------------------------------\n", + "2000 actions: tensor([1, 2, 0])\n", + "loss= tensor(7.4755, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "3000 actions: tensor([2, 2, 3])\n", + "loss= tensor(7.4695, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "4000 actions: tensor([2, 1, 1])\n", + "loss= tensor(7.4843, grad_fn=) , return= 16114.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5679])\n", + "--------------------------------------------------\n", + "5000 actions: tensor([3, 0, 0])\n", + "loss= tensor(7.5159, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "6000 actions: tensor([2, 3, 2])\n", + "loss= tensor(7.4778, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "7000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.3326, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "8000 actions: tensor([1, 2, 2])\n", + "loss= tensor(7.3794, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "9000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.4654, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "10000 actions: tensor([2, 3, 2])\n", + "loss= tensor(7.4747, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "11000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.4314, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 3, 0])\n", + "loss= tensor(7.5233, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "13000 actions: tensor([3, 0, 2])\n", + "loss= tensor(7.4006, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5462])\n", + "--------------------------------------------------\n", + "14000 actions: tensor([3, 2, 3])\n", + "loss= tensor(7.4861, grad_fn=) , return= 16191.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6160])\n", + "--------------------------------------------------\n", + "15000 actions: tensor([2, 3, 3])\n", + "loss= tensor(7.4950, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "16000 actions: tensor([2, 1, 0])\n", + "loss= tensor(7.5389, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "17000 actions: tensor([3, 1, 2])\n", + "loss= tensor(7.4745, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "18000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.4622, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "19000 actions: tensor([1, 1, 1])\n", + "loss= tensor(7.4232, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "20000 actions: tensor([0, 1, 1])\n", + "loss= tensor(7.3781, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5306])\n", + "--------------------------------------------------\n", + "21000 actions: tensor([3, 3, 2])\n", + "loss= tensor(7.4345, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n", + "--------------------------------------------------\n", + "22000 actions: tensor([1, 1, 0])\n", + "loss= tensor(7.4770, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "23000 actions: tensor([1, 3, 1])\n", + "loss= tensor(7.4294, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "24000 actions: tensor([2, 2, 2])\n", + "loss= tensor(7.4575, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "--------------------------------------------------\n", + "25000 actions: tensor([3, 0, 1])\n", + "loss= tensor(7.4054, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5493])\n", + "--------------------------------------------------\n", + "26000 actions: tensor([1, 3, 2])\n", + "loss= tensor(7.4080, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6210])\n", + "--------------------------------------------------\n", + "27000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.3847, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "28000 actions: tensor([2, 3, 0])\n", + "loss= tensor(7.5784, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "29000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.3839, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "30000 actions: tensor([0, 0, 1])\n", + "loss= tensor(7.3111, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4935])\n", + "--------------------------------------------------\n", + "31000 actions: tensor([0, 0, 1])\n", + "loss= tensor(7.3058, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4935])\n", + "--------------------------------------------------\n", + "32000 actions: tensor([0, 2, 3])\n", + "loss= tensor(7.4289, grad_fn=) , return= 16033.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5599])\n", + "--------------------------------------------------\n", + "33000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.5281, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "34000 actions: tensor([0, 2, 0])\n", + "loss= tensor(7.4196, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "35000 actions: tensor([2, 1, 1])\n", + "loss= tensor(7.4963, grad_fn=) , return= 16114.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5679])\n", + "--------------------------------------------------\n", + "36000 actions: tensor([1, 1, 3])\n", + "loss= tensor(7.5065, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5413])\n", + "--------------------------------------------------\n", + "37000 actions: tensor([2, 3, 0])\n", + "loss= tensor(7.5947, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "38000 actions: tensor([2, 0, 1])\n", + "loss= tensor(7.4625, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5306])\n", + "--------------------------------------------------\n", + "39000 actions: tensor([0, 3, 3])\n", + "loss= tensor(7.4438, grad_fn=) , return= 16066.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.5973])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "40000 actions: tensor([1, 3, 2])\n", + "loss= tensor(7.3836, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6210])\n", + "--------------------------------------------------\n", + "41000 actions: tensor([0, 3, 2])\n", + "loss= tensor(7.3028, grad_fn=) , return= 16071.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.6023])\n", + "--------------------------------------------------\n", + "42000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.2890, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "43000 actions: tensor([2, 0, 2])\n", + "loss= tensor(7.4206, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "44000 actions: tensor([2, 1, 1])\n", + "loss= tensor(7.5423, grad_fn=) , return= 16114.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5679])\n", + "--------------------------------------------------\n", + "45000 actions: tensor([1, 1, 2])\n", + "loss= tensor(7.3274, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "46000 actions: tensor([3, 1, 3])\n", + "loss= tensor(7.4829, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5786])\n", + "--------------------------------------------------\n", + "47000 actions: tensor([1, 0, 2])\n", + "loss= tensor(7.3051, grad_fn=) , return= 16022.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5091])\n", + "--------------------------------------------------\n", + "48000 actions: tensor([2, 3, 2])\n", + "loss= tensor(7.4749, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "49000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.5144, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "50000 actions: tensor([3, 2, 1])\n", + "loss= tensor(7.4227, grad_fn=) , return= 16199.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6240])\n", + "--------------------------------------------------\n", + "51000 actions: tensor([0, 1, 0])\n", + "loss= tensor(7.4154, grad_fn=) , return= 16008.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5316])\n", + "--------------------------------------------------\n", + "52000 actions: tensor([0, 2, 1])\n", + "loss= tensor(7.3746, grad_fn=) , return= 16041.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5679])\n", + "--------------------------------------------------\n", + "53000 actions: tensor([1, 1, 2])\n", + "loss= tensor(7.3148, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "54000 actions: tensor([0, 3, 2])\n", + "loss= tensor(7.2998, grad_fn=) , return= 16071.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.6023])\n", + "--------------------------------------------------\n", + "55000 actions: tensor([1, 1, 3])\n", + "loss= tensor(7.4932, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5413])\n", + "--------------------------------------------------\n", + "56000 actions: tensor([2, 2, 0])\n", + "loss= tensor(7.5657, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "57000 actions: tensor([0, 0, 3])\n", + "loss= tensor(7.4221, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4855])\n", + "--------------------------------------------------\n", + "58000 actions: tensor([1, 2, 3])\n", + "loss= tensor(7.4913, grad_fn=) , return= 16088.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5786])\n", + "--------------------------------------------------\n", + "59000 actions: tensor([0, 2, 3])\n", + "loss= tensor(7.4888, grad_fn=) , return= 16033.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5599])\n", + "--------------------------------------------------\n", + "60000 actions: tensor([2, 1, 0])\n", + "loss= tensor(7.5434, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "61000 actions: tensor([2, 2, 0])\n", + "loss= tensor(7.5597, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "62000 actions: tensor([1, 1, 0])\n", + "loss= tensor(7.4035, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "63000 actions: tensor([2, 0, 2])\n", + "loss= tensor(7.4187, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "64000 actions: tensor([0, 1, 1])\n", + "loss= tensor(7.4407, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5306])\n", + "--------------------------------------------------\n", + "65000 actions: tensor([2, 0, 3])\n", + "loss= tensor(7.6284, grad_fn=) , return= 16069.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5226])\n", + "--------------------------------------------------\n", + "66000 actions: tensor([3, 2, 1])\n", + "loss= tensor(7.4327, grad_fn=) , return= 16199.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6240])\n", + "--------------------------------------------------\n", + "67000 actions: tensor([1, 2, 1])\n", + "loss= tensor(7.4291, grad_fn=) , return= 16096.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5866])\n", + "--------------------------------------------------\n", + "68000 actions: tensor([2, 2, 0])\n", + "loss= tensor(7.6038, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "69000 actions: tensor([1, 3, 1])\n", + "loss= tensor(7.4450, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "70000 actions: tensor([3, 1, 0])\n", + "loss= tensor(7.4031, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "71000 actions: tensor([2, 2, 2])\n", + "loss= tensor(7.4546, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "--------------------------------------------------\n", + "72000 actions: tensor([1, 2, 2])\n", + "loss= tensor(7.2591, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "73000 actions: tensor([1, 0, 0])\n", + "loss= tensor(7.3608, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "74000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.4509, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "75000 actions: tensor([2, 0, 1])\n", + "loss= tensor(7.5868, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5306])\n", + "--------------------------------------------------\n", + "76000 actions: tensor([3, 1, 1])\n", + "loss= tensor(7.4120, grad_fn=) , return= 16164.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5866])\n", + "--------------------------------------------------\n", + "77000 actions: tensor([0, 1, 1])\n", + "loss= tensor(7.4779, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5306])\n", + "--------------------------------------------------\n", + "78000 actions: tensor([0, 1, 1])\n", + "loss= tensor(7.4754, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5306])\n", + "--------------------------------------------------\n", + "79000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.5302, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "80000 actions: tensor([0, 3, 0])\n", + "loss= tensor(7.4303, grad_fn=) , return= 16075.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.6063])\n", + "--------------------------------------------------\n", + "81000 actions: tensor([2, 3, 1])\n", + "loss= tensor(7.6838, grad_fn=) , return= 16181.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6428])\n", + "--------------------------------------------------\n", + "82000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.4480, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "83000 actions: tensor([1, 1, 3])\n", + "loss= tensor(7.5448, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5413])\n", + "--------------------------------------------------\n", + "84000 actions: tensor([1, 3, 1])\n", + "loss= tensor(7.4564, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "85000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.3795, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "86000 actions: tensor([1, 0, 2])\n", + "loss= tensor(7.1842, grad_fn=) , return= 16022.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5091])\n", + "--------------------------------------------------\n", + "87000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.2519, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "88000 actions: tensor([1, 0, 2])\n", + "loss= tensor(7.1948, grad_fn=) , return= 16022.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5091])\n", + "--------------------------------------------------\n", + "89000 actions: tensor([1, 1, 2])\n", + "loss= tensor(7.2138, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "90000 actions: tensor([1, 2, 0])\n", + "loss= tensor(7.3775, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "91000 actions: tensor([0, 0, 2])\n", + "loss= tensor(7.2168, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4905])\n", + "--------------------------------------------------\n", + "92000 actions: tensor([1, 0, 1])\n", + "loss= tensor(7.3962, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5121])\n", + "--------------------------------------------------\n", + "93000 actions: tensor([2, 3, 1])\n", + "loss= tensor(7.7166, grad_fn=) , return= 16181.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6428])\n", + "--------------------------------------------------\n", + "94000 actions: tensor([0, 0, 3])\n", + "loss= tensor(7.6060, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4855])\n", + "--------------------------------------------------\n", + "95000 actions: tensor([0, 0, 1])\n", + "loss= tensor(7.4477, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4935])\n", + "--------------------------------------------------\n", + "96000 actions: tensor([3, 3, 2])\n", + "loss= tensor(7.1415, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n", + "--------------------------------------------------\n", + "97000 actions: tensor([0, 2, 1])\n", + "loss= tensor(7.5024, grad_fn=) , return= 16041.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5679])\n", + "--------------------------------------------------\n", + "98000 actions: tensor([1, 0, 0])\n", + "loss= tensor(7.3157, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "99000 actions: tensor([0, 2, 2])\n", + "loss= tensor(7.2530, grad_fn=) , return= 16038.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5649])\n", + "--------------------------------------------------\n", + "100000 actions: tensor([1, 1, 2])\n", + "loss= tensor(7.1584, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "101000 actions: tensor([3, 3, 1])\n", + "loss= tensor(7.3654, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6616])\n", + "--------------------------------------------------\n", + "102000 actions: tensor([2, 0, 2])\n", + "loss= tensor(7.3998, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "103000 actions: tensor([3, 2, 2])\n", + "loss= tensor(7.0144, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6210])\n", + "--------------------------------------------------\n", + "104000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.7336, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "105000 actions: tensor([1, 3, 2])\n", + "loss= tensor(7.1700, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6210])\n", + "--------------------------------------------------\n", + "106000 actions: tensor([0, 2, 2])\n", + "loss= tensor(7.2108, grad_fn=) , return= 16038.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5649])\n", + "--------------------------------------------------\n", + "107000 actions: tensor([1, 2, 2])\n", + "loss= tensor(7.1279, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "108000 actions: tensor([2, 2, 2])\n", + "loss= tensor(7.4386, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "--------------------------------------------------\n", + "109000 actions: tensor([3, 3, 0])\n", + "loss= tensor(7.1988, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "110000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.2103, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "111000 actions: tensor([2, 2, 3])\n", + "loss= tensor(8.1165, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "112000 actions: tensor([0, 3, 1])\n", + "loss= tensor(7.6099, grad_fn=) , return= 16074.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.6053])\n", + "--------------------------------------------------\n", + "113000 actions: tensor([1, 0, 1])\n", + "loss= tensor(7.3865, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5121])\n", + "--------------------------------------------------\n", + "114000 actions: tensor([3, 0, 3])\n", + "loss= tensor(7.5329, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5413])\n", + "--------------------------------------------------\n", + "115000 actions: tensor([1, 3, 0])\n", + "loss= tensor(7.3583, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "116000 actions: tensor([1, 0, 1])\n", + "loss= tensor(7.3855, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5121])\n", + "--------------------------------------------------\n", + "117000 actions: tensor([0, 0, 2])\n", + "loss= tensor(7.1737, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4905])\n", + "--------------------------------------------------\n", + "118000 actions: tensor([0, 2, 1])\n", + "loss= tensor(7.5941, grad_fn=) , return= 16041.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5679])\n", + "--------------------------------------------------\n", + "119000 actions: tensor([2, 2, 3])\n", + "loss= tensor(8.3126, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "120000 actions: tensor([1, 1, 0])\n", + "loss= tensor(7.1817, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "121000 actions: tensor([3, 0, 1])\n", + "loss= tensor(7.0802, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5493])\n", + "--------------------------------------------------\n", + "122000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.3259, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "123000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.4162, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "124000 actions: tensor([3, 0, 3])\n", + "loss= tensor(7.6762, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5413])\n", + "--------------------------------------------------\n", + "125000 actions: tensor([0, 0, 1])\n", + "loss= tensor(7.7056, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4935])\n", + "--------------------------------------------------\n", + "126000 actions: tensor([1, 2, 3])\n", + "loss= tensor(8.1479, grad_fn=) , return= 16088.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5786])\n", + "--------------------------------------------------\n", + "127000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.8314, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "128000 actions: tensor([3, 0, 0])\n", + "loss= tensor(6.5010, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "129000 actions: tensor([0, 2, 0])\n", + "loss= tensor(7.3043, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "130000 actions: tensor([3, 0, 0])\n", + "loss= tensor(6.4224, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "131000 actions: tensor([2, 3, 3])\n", + "loss= tensor(9.2565, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "132000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.4157, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "133000 actions: tensor([3, 0, 0])\n", + "loss= tensor(6.1824, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "134000 actions: tensor([1, 2, 0])\n", + "loss= tensor(6.6063, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "135000 actions: tensor([2, 0, 2])\n", + "loss= tensor(7.1641, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "136000 actions: tensor([3, 0, 0])\n", + "loss= tensor(5.8832, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "137000 actions: tensor([0, 0, 2])\n", + "loss= tensor(7.3097, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4905])\n", + "--------------------------------------------------\n", + "138000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.6926, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "139000 actions: tensor([3, 1, 2])\n", + "loss= tensor(6.2453, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "140000 actions: tensor([0, 1, 2])\n", + "loss= tensor(7.7344, grad_fn=) , return= 16004.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5276])\n", + "--------------------------------------------------\n", + "141000 actions: tensor([0, 0, 0])\n", + "loss= tensor(6.7979, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "142000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.2249, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "143000 actions: tensor([2, 1, 0])\n", + "loss= tensor(6.6106, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "144000 actions: tensor([3, 0, 2])\n", + "loss= tensor(5.8359, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5462])\n", + "--------------------------------------------------\n", + "145000 actions: tensor([0, 1, 0])\n", + "loss= tensor(7.2267, grad_fn=) , return= 16008.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5316])\n", + "--------------------------------------------------\n", + "146000 actions: tensor([1, 1, 1])\n", + "loss= tensor(8.9707, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "147000 actions: tensor([1, 0, 0])\n", + "loss= tensor(4.7024, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "148000 actions: tensor([2, 1, 0])\n", + "loss= tensor(6.1924, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "149000 actions: tensor([2, 2, 3])\n", + "loss= tensor(12.7364, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "150000 actions: tensor([2, 0, 2])\n", + "loss= tensor(6.9155, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "151000 actions: tensor([2, 0, 0])\n", + "loss= tensor(4.4850, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "152000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0177, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "153000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.6499, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "154000 actions: tensor([2, 2, 2])\n", + "loss= tensor(8.4240, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "--------------------------------------------------\n", + "155000 actions: tensor([3, 3, 0])\n", + "loss= tensor(7.1987, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "156000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.3999, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "157000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.3301, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "158000 actions: tensor([0, 2, 0])\n", + "loss= tensor(6.7887, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "159000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4511, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "160000 actions: tensor([1, 3, 0])\n", + "loss= tensor(7.2115, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "161000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.8082, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "162000 actions: tensor([1, 0, 2])\n", + "loss= tensor(8.2124, grad_fn=) , return= 16022.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5091])\n", + "--------------------------------------------------\n", + "163000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1320, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "164000 actions: tensor([0, 2, 0])\n", + "loss= tensor(7.0241, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "165000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0258, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "166000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6967, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "167000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0346, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "168000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.3632, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "169000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.9124, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "170000 actions: tensor([2, 0, 2])\n", + "loss= tensor(8.9059, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "171000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.2193, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "172000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0310, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "173000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1891, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "174000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6947, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "175000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9900, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "176000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.5728, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "177000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.5221, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "178000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9662, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "179000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0375, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "180000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0849, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "181000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9622, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "182000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9639, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "183000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0762, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "184000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4567, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "185000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2131, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "186000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1749, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "187000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0771, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "188000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0844, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "189000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1548, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "190000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0573, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "191000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4161, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "192000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.5258, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "193000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0782, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "194000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2411, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "195000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1337, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "196000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.6740, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "197000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2571, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "198000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1474, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "199000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.5519, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "200000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1849, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "201000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4357, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "202000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.3986, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "203000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1927, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "204000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1870, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "205000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0793, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "206000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1888, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "207000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1637, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "208000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.2211, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "209000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1088, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "210000 actions: tensor([2, 0, 1])\n", + "loss= tensor(9.9202, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5306])\n", + "--------------------------------------------------\n", + "211000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.2128, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "212000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.3343, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "213000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.4597, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "214000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1972, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "215000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.3977, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "216000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4003, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "217000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0751, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "218000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1969, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "219000 actions: tensor([0, 2, 0])\n", + "loss= tensor(7.5404, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "220000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1931, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "221000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0833, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "222000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1476, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "223000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1955, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "224000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1567, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "225000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0704, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "226000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0347, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "227000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1732, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "228000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.3612, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "229000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1615, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "230000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2013, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "231000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0301, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "232000 actions: tensor([3, 1, 2])\n", + "loss= tensor(11.8475, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "233000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1089, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "234000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1158, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "235000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1674, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "236000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1840, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "237000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9873, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "238000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6303, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "239000 actions: tensor([3, 3, 1])\n", + "loss= tensor(14.2472, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6616])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "240000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0768, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "241000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0229, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "242000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.6497, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "243000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2391, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "244000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2319, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "245000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.2337, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "246000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0020, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "247000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4238, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "248000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1405, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "249000 actions: tensor([1, 0, 1])\n", + "loss= tensor(10.2219, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5121])\n", + "--------------------------------------------------\n", + "250000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4415, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "251000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4836, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "252000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1443, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "253000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0447, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "254000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1417, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "255000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.4796, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "256000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1157, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "257000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1964, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "258000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4740, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "259000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.5210, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "260000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1635, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "261000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1012, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "262000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4938, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "263000 actions: tensor([0, 3, 0])\n", + "loss= tensor(8.9625, grad_fn=) , return= 16075.078125\n", + "discReturns/1000= tensor([5.1122, 5.3566, 5.6063])\n", + "--------------------------------------------------\n", + "264000 actions: tensor([0, 2, 0])\n", + "loss= tensor(7.6809, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "265000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0902, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "266000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0870, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "267000 actions: tensor([3, 1, 2])\n", + "loss= tensor(11.9614, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "268000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0110, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "269000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1060, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "270000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.4677, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "271000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0484, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "272000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1263, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "273000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1208, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "274000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0266, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "275000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0239, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "276000 actions: tensor([2, 2, 1])\n", + "loss= tensor(12.5227, grad_fn=) , return= 16148.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6053])\n", + "--------------------------------------------------\n", + "277000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1126, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "278000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1900, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "279000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0836, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "280000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1069, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "281000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0298, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "282000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1586, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "283000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1487, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "284000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0795, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "285000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.7534, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "286000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0961, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "287000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1330, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "288000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1002, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "289000 actions: tensor([3, 0, 2])\n", + "loss= tensor(9.5219, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5462])\n", + "--------------------------------------------------\n", + "290000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.5531, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "291000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.4430, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "292000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1378, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "293000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1220, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "294000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0735, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "295000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.8424, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "296000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.5289, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "297000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.0903, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "298000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.8335, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "299000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9463, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "300000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0612, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "301000 actions: tensor([1, 3, 3])\n", + "loss= tensor(16.8037, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "302000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0560, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "303000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0389, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "304000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6409, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "305000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9213, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "306000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0196, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "307000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.6562, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "308000 actions: tensor([0, 0, 0])\n", + "loss= tensor(5.9321, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "309000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1073, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "310000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0582, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "311000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0355, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "312000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9428, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "313000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0384, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "314000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0287, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "315000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.1116, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "316000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4630, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "317000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0274, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "318000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0332, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "319000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4385, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "320000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1791, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "321000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.5313, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "322000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0858, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "323000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0584, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "324000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9396, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "325000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4439, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "326000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0412, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "327000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0340, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "328000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.5941, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "329000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9388, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "330000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0275, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "331000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.3983, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "332000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0363, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "333000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0461, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "334000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.5444, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "335000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.0228, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "336000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4691, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "337000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0110, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "338000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.9968, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "339000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0306, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "340000 actions: tensor([0, 1, 0])\n", + "loss= tensor(8.7913, grad_fn=) , return= 16008.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5316])\n", + "--------------------------------------------------\n", + "341000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9339, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "342000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0222, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "343000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9371, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "344000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.4877, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "345000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.9001, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "346000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8930, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "347000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.0344, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "348000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9685, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "349000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9878, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "350000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.0098, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "351000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0137, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "352000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.0842, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "353000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.2540, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "354000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.1971, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "355000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.2750, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "356000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1782, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "357000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.3111, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "358000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1135, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "359000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.1429, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "360000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1369, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "361000 actions: tensor([2, 2, 3])\n", + "loss= tensor(14.9093, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "362000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.8364, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "363000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1692, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "364000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.2026, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "365000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0921, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "366000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.1939, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "367000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0970, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "368000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0478, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "369000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.8515, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "370000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.0324, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "371000 actions: tensor([0, 2, 0])\n", + "loss= tensor(8.8044, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5689])\n", + "--------------------------------------------------\n", + "372000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.1185, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "373000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.0498, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "374000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.9324, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "375000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0422, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "376000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0582, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "377000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8894, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "378000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.9351, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "379000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9982, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "380000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8503, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "381000 actions: tensor([3, 0, 1])\n", + "loss= tensor(11.8065, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5493])\n", + "--------------------------------------------------\n", + "382000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.9158, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "383000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.9134, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "384000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.9045, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "385000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0672, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "386000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9198, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "387000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8989, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "388000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8147, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "389000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6549, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "390000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0792, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "391000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0601, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "392000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8057, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "393000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8812, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "394000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8104, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "395000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.4986, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "396000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.5543, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "397000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8864, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "398000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.4112, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "399000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.0544, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "400000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9803, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "401000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0020, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "402000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.9628, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "403000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9377, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "404000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.5608, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "405000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9132, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "406000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0103, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "407000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7937, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "408000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8401, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "409000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8253, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "410000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.6756, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "411000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8458, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "412000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7848, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "413000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8711, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "414000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7538, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "415000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8294, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "416000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7615, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "417000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8393, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "418000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8820, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "419000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7713, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "420000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8622, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "421000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8861, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "422000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7762, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "423000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.0015, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "424000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8289, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "425000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.6721, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "426000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7432, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "427000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8183, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "428000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8231, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "429000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8250, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "430000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.5365, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "431000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8491, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "432000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8186, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "433000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.5463, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "434000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8498, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "435000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8299, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "436000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7512, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "437000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8106, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "438000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0475, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "439000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7761, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "440000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8416, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "441000 actions: tensor([0, 0, 0])\n", + "loss= tensor(7.3065, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([5.1122, 5.3656, 5.4945])\n", + "--------------------------------------------------\n", + "442000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7783, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "443000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.6020, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "444000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7901, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "445000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8246, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "446000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0132, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "447000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8019, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "448000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.6092, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "449000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7585, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "450000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8282, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "451000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.7949, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "452000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8441, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "453000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7651, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "454000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8808, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "455000 actions: tensor([1, 1, 1])\n", + "loss= tensor(15.6892, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "456000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7870, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "457000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8504, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "458000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.9602, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "459000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7951, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "460000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7963, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "461000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.6027, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "462000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.9807, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "463000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8666, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "464000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8595, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "465000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.9861, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "466000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7357, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "467000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0395, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "468000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7343, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "469000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0119, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "470000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.6349, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "471000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.6038, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "472000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8038, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "473000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7902, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "474000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.1098, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "475000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7137, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "476000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7187, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "477000 actions: tensor([3, 2, 0])\n", + "loss= tensor(5.0743, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "478000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7056, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "479000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.7108, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "480000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7664, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "481000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7785, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "482000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7878, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "483000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7868, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "484000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0921, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "485000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7827, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "486000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0846, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "487000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.9925, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "488000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7440, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "489000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7588, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "490000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7757, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "491000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7649, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "492000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6996, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "493000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8093, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "494000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8176, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "495000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.9304, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "496000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7769, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "497000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7056, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "498000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7127, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "499000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6938, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "500000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7411, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "501000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7578, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "502000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6780, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "503000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7456, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "504000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7000, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "505000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6506, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "506000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6607, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "507000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7415, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "508000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6637, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "509000 actions: tensor([2, 3, 0])\n", + "loss= tensor(6.6506, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "510000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.0805, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "511000 actions: tensor([3, 1, 0])\n", + "loss= tensor(5.7903, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "512000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7629, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "513000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0249, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "514000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7144, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "515000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8059, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "516000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8196, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "517000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8567, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "518000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8379, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "519000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8179, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "520000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.6539, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "521000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.9571, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "522000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8021, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "523000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.5606, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "524000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.6118, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "525000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.0393, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "526000 actions: tensor([1, 3, 0])\n", + "loss= tensor(6.3949, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "527000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7464, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "528000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8500, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "529000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.8622, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "530000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8202, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "531000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.9256, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "532000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8156, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "533000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.8438, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "534000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.9838, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "535000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.7035, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "536000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7414, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "537000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7415, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "538000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7168, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "539000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.8592, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "540000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.6891, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "541000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.6823, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "542000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.6967, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "543000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.8441, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "544000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.6952, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "545000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1795, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "546000 actions: tensor([3, 0, 2])\n", + "loss= tensor(12.8450, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5462])\n", + "--------------------------------------------------\n", + "547000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7080, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "548000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6267, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "549000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.1599, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "550000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.6814, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "551000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6359, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "552000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.6405, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "553000 actions: tensor([2, 0, 0])\n", + "loss= tensor(2.7418, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "554000 actions: tensor([3, 3, 0])\n", + "loss= tensor(6.4714, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "555000 actions: tensor([1, 0, 0])\n", + "loss= tensor(2.7759, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "556000 actions: tensor([1, 2, 0])\n", + "loss= tensor(4.8636, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "557000 actions: tensor([3, 0, 0])\n", + "loss= tensor(2.8216, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "558000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.8372, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "559000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.7503, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "560000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.6733, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "561000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.1373, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "562000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1024, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "563000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.1509, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "564000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.3341, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "565000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.3543, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "566000 actions: tensor([3, 3, 0])\n", + "loss= tensor(5.6600, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6626])\n", + "--------------------------------------------------\n", + "567000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.3580, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "568000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.4462, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "569000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.2382, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "570000 actions: tensor([3, 1, 0])\n", + "loss= tensor(4.8630, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "571000 actions: tensor([0, 1, 0])\n", + "loss= tensor(11.2013, grad_fn=) , return= 16008.453125\n", + "discReturns/1000= tensor([5.1122, 5.3646, 5.5316])\n", + "--------------------------------------------------\n", + "572000 actions: tensor([1, 1, 0])\n", + "loss= tensor(4.8489, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "573000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.4258, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "574000 actions: tensor([1, 0, 0])\n", + "loss= tensor(3.5334, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([5.1112, 5.4022, 5.5131])\n", + "--------------------------------------------------\n", + "575000 actions: tensor([2, 1, 0])\n", + "loss= tensor(4.9504, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "576000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.2855, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "577000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.5895, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "578000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.6795, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "579000 actions: tensor([2, 0, 0])\n", + "loss= tensor(3.8128, grad_fn=) , return= 16078.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5316])\n", + "--------------------------------------------------\n", + "580000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.2065, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "581000 actions: tensor([3, 0, 0])\n", + "loss= tensor(3.7395, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "582000 actions: tensor([3, 2, 0])\n", + "loss= tensor(4.1365, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "583000 actions: tensor([1, 1, 0])\n", + "loss= tensor(4.6234, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "584000 actions: tensor([1, 3, 0])\n", + "loss= tensor(5.0823, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "585000 actions: tensor([3, 1, 0])\n", + "loss= tensor(4.5453, grad_fn=) , return= 16165.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5876])\n", + "--------------------------------------------------\n", + "586000 actions: tensor([1, 3, 1])\n", + "loss= tensor(14.1702, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "587000 actions: tensor([3, 0, 0])\n", + "loss= tensor(4.3629, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "588000 actions: tensor([2, 3, 0])\n", + "loss= tensor(4.9347, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "589000 actions: tensor([1, 2, 2])\n", + "loss= tensor(11.7194, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "590000 actions: tensor([2, 3, 0])\n", + "loss= tensor(4.7848, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "591000 actions: tensor([1, 2, 1])\n", + "loss= tensor(12.2408, grad_fn=) , return= 16096.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5866])\n", + "--------------------------------------------------\n", + "592000 actions: tensor([1, 1, 0])\n", + "loss= tensor(4.2116, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "593000 actions: tensor([1, 3, 0])\n", + "loss= tensor(4.4457, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "594000 actions: tensor([2, 2, 0])\n", + "loss= tensor(4.0315, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "595000 actions: tensor([1, 3, 0])\n", + "loss= tensor(4.2619, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6250])\n", + "--------------------------------------------------\n", + "596000 actions: tensor([3, 2, 2])\n", + "loss= tensor(10.2318, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6210])\n", + "--------------------------------------------------\n", + "597000 actions: tensor([2, 3, 0])\n", + "loss= tensor(4.3330, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "598000 actions: tensor([3, 0, 0])\n", + "loss= tensor(6.4966, grad_fn=) , return= 16129.5\n", + "discReturns/1000= tensor([5.1033, 5.4760, 5.5503])\n", + "--------------------------------------------------\n", + "599000 actions: tensor([3, 3, 2])\n", + "loss= tensor(9.0096, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "600000 actions: tensor([2, 2, 3])\n", + "loss= tensor(9.5213, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "601000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.9830, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "602000 actions: tensor([2, 1, 2])\n", + "loss= tensor(7.7767, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "603000 actions: tensor([2, 3, 3])\n", + "loss= tensor(7.6357, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "604000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.4494, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "605000 actions: tensor([2, 3, 2])\n", + "loss= tensor(7.6177, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "606000 actions: tensor([3, 1, 3])\n", + "loss= tensor(7.5247, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5786])\n", + "--------------------------------------------------\n", + "607000 actions: tensor([3, 1, 1])\n", + "loss= tensor(7.6604, grad_fn=) , return= 16164.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5866])\n", + "--------------------------------------------------\n", + "608000 actions: tensor([2, 1, 3])\n", + "loss= tensor(7.2798, grad_fn=) , return= 16106.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5599])\n", + "--------------------------------------------------\n", + "609000 actions: tensor([3, 3, 3])\n", + "loss= tensor(7.4914, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6536])\n", + "--------------------------------------------------\n", + "610000 actions: tensor([2, 2, 1])\n", + "loss= tensor(7.3432, grad_fn=) , return= 16148.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6053])\n", + "--------------------------------------------------\n", + "611000 actions: tensor([2, 2, 3])\n", + "loss= tensor(7.2047, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "612000 actions: tensor([1, 1, 2])\n", + "loss= tensor(7.5415, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "613000 actions: tensor([3, 2, 2])\n", + "loss= tensor(7.7075, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6210])\n", + "--------------------------------------------------\n", + "614000 actions: tensor([2, 2, 2])\n", + "loss= tensor(7.4142, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "--------------------------------------------------\n", + "615000 actions: tensor([3, 2, 3])\n", + "loss= tensor(7.4317, grad_fn=) , return= 16191.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6160])\n", + "--------------------------------------------------\n", + "616000 actions: tensor([2, 3, 3])\n", + "loss= tensor(7.1329, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "617000 actions: tensor([1, 1, 0])\n", + "loss= tensor(6.2848, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "618000 actions: tensor([2, 3, 3])\n", + "loss= tensor(7.0710, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "619000 actions: tensor([1, 3, 1])\n", + "loss= tensor(7.1598, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "620000 actions: tensor([2, 3, 2])\n", + "loss= tensor(7.1316, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "621000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.2834, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "622000 actions: tensor([2, 0, 2])\n", + "loss= tensor(8.9667, grad_fn=) , return= 16074.953125\n", + "discReturns/1000= tensor([5.1083, 5.4391, 5.5276])\n", + "--------------------------------------------------\n", + "623000 actions: tensor([1, 1, 1])\n", + "loss= tensor(7.1914, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "624000 actions: tensor([3, 2, 3])\n", + "loss= tensor(7.2165, grad_fn=) , return= 16191.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6160])\n", + "--------------------------------------------------\n", + "625000 actions: tensor([1, 3, 1])\n", + "loss= tensor(6.9550, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "626000 actions: tensor([3, 3, 2])\n", + "loss= tensor(7.1853, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n", + "--------------------------------------------------\n", + "627000 actions: tensor([3, 3, 1])\n", + "loss= tensor(6.8070, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6616])\n", + "--------------------------------------------------\n", + "628000 actions: tensor([1, 2, 2])\n", + "loss= tensor(7.2490, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "629000 actions: tensor([1, 3, 3])\n", + "loss= tensor(7.0393, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "630000 actions: tensor([3, 2, 3])\n", + "loss= tensor(7.0845, grad_fn=) , return= 16191.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6160])\n", + "--------------------------------------------------\n", + "631000 actions: tensor([1, 3, 1])\n", + "loss= tensor(6.8307, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "632000 actions: tensor([1, 1, 1])\n", + "loss= tensor(7.0294, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "633000 actions: tensor([3, 1, 2])\n", + "loss= tensor(7.2290, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "634000 actions: tensor([2, 3, 3])\n", + "loss= tensor(6.5641, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "635000 actions: tensor([3, 3, 3])\n", + "loss= tensor(6.9194, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6536])\n", + "--------------------------------------------------\n", + "636000 actions: tensor([2, 1, 1])\n", + "loss= tensor(6.6224, grad_fn=) , return= 16114.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5679])\n", + "--------------------------------------------------\n", + "637000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.8991, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "638000 actions: tensor([2, 2, 1])\n", + "loss= tensor(6.5631, grad_fn=) , return= 16148.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6053])\n", + "--------------------------------------------------\n", + "639000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.7443, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "640000 actions: tensor([3, 1, 2])\n", + "loss= tensor(7.0541, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5836])\n", + "--------------------------------------------------\n", + "641000 actions: tensor([2, 3, 3])\n", + "loss= tensor(6.5788, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6348])\n", + "--------------------------------------------------\n", + "642000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.9470, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "643000 actions: tensor([3, 2, 1])\n", + "loss= tensor(6.8375, grad_fn=) , return= 16199.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6240])\n", + "--------------------------------------------------\n", + "644000 actions: tensor([3, 3, 2])\n", + "loss= tensor(6.7883, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n", + "--------------------------------------------------\n", + "645000 actions: tensor([1, 3, 1])\n", + "loss= tensor(6.6349, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6240])\n", + "--------------------------------------------------\n", + "646000 actions: tensor([3, 1, 3])\n", + "loss= tensor(7.0129, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5786])\n", + "--------------------------------------------------\n", + "647000 actions: tensor([1, 1, 0])\n", + "loss= tensor(6.0312, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "648000 actions: tensor([3, 2, 1])\n", + "loss= tensor(6.8310, grad_fn=) , return= 16199.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6240])\n", + "--------------------------------------------------\n", + "649000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.8299, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "650000 actions: tensor([3, 2, 0])\n", + "loss= tensor(6.0214, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6250])\n", + "--------------------------------------------------\n", + "651000 actions: tensor([3, 1, 3])\n", + "loss= tensor(6.9932, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5786])\n", + "--------------------------------------------------\n", + "652000 actions: tensor([2, 3, 2])\n", + "loss= tensor(6.4897, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "653000 actions: tensor([1, 2, 3])\n", + "loss= tensor(6.9109, grad_fn=) , return= 16088.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5786])\n", + "--------------------------------------------------\n", + "654000 actions: tensor([1, 2, 2])\n", + "loss= tensor(6.8421, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "--------------------------------------------------\n", + "655000 actions: tensor([2, 1, 2])\n", + "loss= tensor(6.7258, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "656000 actions: tensor([1, 3, 3])\n", + "loss= tensor(6.6291, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "657000 actions: tensor([1, 1, 2])\n", + "loss= tensor(6.7068, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5462])\n", + "--------------------------------------------------\n", + "658000 actions: tensor([3, 3, 1])\n", + "loss= tensor(6.6820, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6616])\n", + "--------------------------------------------------\n", + "659000 actions: tensor([1, 3, 3])\n", + "loss= tensor(6.6199, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "660000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.9338, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "661000 actions: tensor([2, 1, 2])\n", + "loss= tensor(6.6419, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "662000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.8675, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "663000 actions: tensor([2, 2, 0])\n", + "loss= tensor(5.9231, grad_fn=) , return= 16149.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6063])\n", + "--------------------------------------------------\n", + "664000 actions: tensor([1, 1, 1])\n", + "loss= tensor(6.6676, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5493])\n", + "--------------------------------------------------\n", + "665000 actions: tensor([3, 1, 3])\n", + "loss= tensor(6.9440, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([5.1033, 5.4750, 5.5786])\n", + "--------------------------------------------------\n", + "666000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.8302, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n", + "--------------------------------------------------\n", + "667000 actions: tensor([2, 2, 3])\n", + "loss= tensor(6.7243, grad_fn=) , return= 16140.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.5973])\n", + "--------------------------------------------------\n", + "668000 actions: tensor([3, 3, 2])\n", + "loss= tensor(6.7684, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([5.1033, 5.4670, 5.6586])\n", + "--------------------------------------------------\n", + "669000 actions: tensor([2, 1, 2])\n", + "loss= tensor(6.6581, grad_fn=) , return= 16111.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5649])\n", + "--------------------------------------------------\n", + "670000 actions: tensor([2, 1, 0])\n", + "loss= tensor(5.9082, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([5.1083, 5.4381, 5.5689])\n", + "--------------------------------------------------\n", + "671000 actions: tensor([2, 3, 0])\n", + "loss= tensor(5.7044, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "672000 actions: tensor([2, 3, 0])\n", + "loss= tensor(5.7178, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6438])\n", + "--------------------------------------------------\n", + "673000 actions: tensor([1, 3, 3])\n", + "loss= tensor(6.5408, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "--------------------------------------------------\n", + "674000 actions: tensor([1, 2, 0])\n", + "loss= tensor(5.8945, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5876])\n", + "--------------------------------------------------\n", + "675000 actions: tensor([2, 3, 2])\n", + "loss= tensor(6.4434, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([5.1083, 5.4301, 5.6398])\n", + "--------------------------------------------------\n", + "676000 actions: tensor([1, 1, 0])\n", + "loss= tensor(5.9662, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5503])\n" + ] + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning)):\n", + " learning_2[i] = learning[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(learning,loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test3-checkpoint.ipynb b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test3-checkpoint.ipynb new file mode 100644 index 0000000..b02c6d3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test3-checkpoint.ipynb @@ -0,0 +1,991 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=100_000, discountFactor =0.0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 actions: tensor([3, 2, 2])\n", + "loss= tensor(10.7618, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([9.2445, 8.2825, 5.6210])\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 2, 1])\n", + "loss= tensor(10.4525, grad_fn=) , return= 16199.25\n", + "discReturns/1000= tensor([9.2452, 8.2840, 5.6240])\n", + "--------------------------------------------------\n", + "2000 actions: tensor([3, 2, 0])\n", + "loss= tensor(11.1496, grad_fn=) , return= 16200.25\n", + "discReturns/1000= tensor([9.2455, 8.2845, 5.6250])\n", + "--------------------------------------------------\n", + "3000 actions: tensor([0, 3, 3])\n", + "loss= tensor(4.6165, grad_fn=) , return= 16066.078125\n", + "discReturns/1000= tensor([9.1898, 8.1552, 5.5973])\n", + "--------------------------------------------------\n", + "4000 actions: tensor([2, 0, 3])\n", + "loss= tensor(9.4645, grad_fn=) , return= 16069.953125\n", + "discReturns/1000= tensor([9.2084, 8.2004, 5.5226])\n", + "--------------------------------------------------\n", + "5000 actions: tensor([1, 1, 0])\n", + "loss= tensor(9.7527, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "6000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5805, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "7000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5508, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "8000 actions: tensor([1, 1, 3])\n", + "loss= tensor(2.5555, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([9.1972, 8.1719, 5.5413])\n", + "--------------------------------------------------\n", + "9000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5615, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "10000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5623, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "11000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5659, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "12000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5650, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "13000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5647, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "14000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5629, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "15000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5629, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "16000 actions: tensor([1, 1, 3])\n", + "loss= tensor(2.5606, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([9.1972, 8.1719, 5.5413])\n", + "--------------------------------------------------\n", + "17000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "18000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "19000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "20000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "21000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "22000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "23000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "24000 actions: tensor([1, 1, 2])\n", + "loss= tensor(2.5629, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([9.1984, 8.1744, 5.5462])\n", + "--------------------------------------------------\n", + "25000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "26000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "27000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "28000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "29000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "30000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "31000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "32000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "33000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "34000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "35000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "36000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "37000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "38000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "39000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "40000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "41000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "42000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "43000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "44000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "45000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "46000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "47000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "48000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "49000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "50000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "51000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "52000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "53000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "54000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "55000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "56000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "57000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "58000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "59000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "60000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "61000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "62000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "63000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "64000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "65000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "66000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "67000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "68000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "69000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "70000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "71000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "72000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "73000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "74000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "75000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "76000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "77000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "78000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "79000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "80000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "81000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "82000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "83000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "84000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "85000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "86000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "87000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "88000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "89000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "90000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "91000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "92000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "93000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "94000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "95000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.5643, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([9.1992, 8.1759, 5.5493])\n", + "--------------------------------------------------\n", + "96000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "97000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "98000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n", + "--------------------------------------------------\n", + "99000 actions: tensor([1, 1, 0])\n", + "loss= tensor(2.5648, grad_fn=) , return= 16062.75\n", + "discReturns/1000= tensor([9.1994, 8.1764, 5.5503])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.0200.0
1204.0196.0
2206.0194.0
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.0 200.0\n", + "1 204.0 196.0\n", + "2 206.0 194.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16062.75\n", + "1 11848.75\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05111.254160.25
15401.253906.25
25550.253782.25
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5111.25 4160.25\n", + "1 5401.25 3906.25\n", + "2 5550.25 3782.25" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0127.5135.5
1129.5133.5
2131.5132.5
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 127.5 135.5\n", + "1 129.5 133.5\n", + "2 131.5 132.5" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidIndexError", + "evalue": "(slice(None, None, None), None)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3621\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3620\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 3621\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3622\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:136\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:142\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: '(slice(None, None, None), None)' is an invalid key", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mInvalidIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [19]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlearning\u001b[49m\u001b[43m,\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\pyplot.py:2757\u001b[0m, in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 2755\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mplot)\n\u001b[0;32m 2756\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot\u001b[39m(\u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, scaley\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m-> 2757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m gca()\u001b[38;5;241m.\u001b[39mplot(\n\u001b[0;32m 2758\u001b[0m \u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39mscalex, scaley\u001b[38;5;241m=\u001b[39mscaley,\n\u001b[0;32m 2759\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m\"\u001b[39m: data} \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {}), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_axes.py:1632\u001b[0m, in \u001b[0;36mAxes.plot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1391\u001b[0m \u001b[38;5;124;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[0;32m 1392\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1629\u001b[0m \u001b[38;5;124;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[0;32m 1630\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1631\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m cbook\u001b[38;5;241m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[38;5;241m.\u001b[39mLine2D)\n\u001b[1;32m-> 1632\u001b[0m lines \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_lines(\u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39mdata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)]\n\u001b[0;32m 1633\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[0;32m 1634\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_line(line)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:312\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[1;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 310\u001b[0m this \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 311\u001b[0m args \u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m1\u001b[39m:]\n\u001b[1;32m--> 312\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:487\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[1;34m(self, tup, kwargs, return_kwargs)\u001b[0m\n\u001b[0;32m 484\u001b[0m kw[prop_name] \u001b[38;5;241m=\u001b[39m val\n\u001b[0;32m 486\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(xy) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[1;32m--> 487\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43m_check_1d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxy\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 488\u001b[0m y \u001b[38;5;241m=\u001b[39m _check_1d(xy[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m 489\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\cbook\\__init__.py:1327\u001b[0m, in \u001b[0;36m_check_1d\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m warnings\u001b[38;5;241m.\u001b[39mcatch_warnings(record\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m w:\n\u001b[0;32m 1322\u001b[0m warnings\u001b[38;5;241m.\u001b[39mfilterwarnings(\n\u001b[0;32m 1323\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1324\u001b[0m category\u001b[38;5;241m=\u001b[39m\u001b[38;5;167;01mWarning\u001b[39;00m,\n\u001b[0;32m 1325\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSupport for multi-dimensional indexing\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m-> 1327\u001b[0m ndim \u001b[38;5;241m=\u001b[39m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mndim\n\u001b[0;32m 1328\u001b[0m \u001b[38;5;66;03m# we have definitely hit a pandas index or series object\u001b[39;00m\n\u001b[0;32m 1329\u001b[0m \u001b[38;5;66;03m# cast to a numpy array.\u001b[39;00m\n\u001b[0;32m 1330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(w) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\frame.py:3505\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 3503\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m 3504\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[1;32m-> 3505\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3506\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[0;32m 3507\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3628\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3623\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[0;32m 3624\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[0;32m 3625\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[0;32m 3626\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[0;32m 3627\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m-> 3628\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_check_indexing_error\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3629\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m 3631\u001b[0m \u001b[38;5;66;03m# GH#42269\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:5637\u001b[0m, in \u001b[0;36mIndex._check_indexing_error\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 5633\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_check_indexing_error\u001b[39m(\u001b[38;5;28mself\u001b[39m, key):\n\u001b[0;32m 5634\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_scalar(key):\n\u001b[0;32m 5635\u001b[0m \u001b[38;5;66;03m# if key is not a scalar, directly raise an error (the code below\u001b[39;00m\n\u001b[0;32m 5636\u001b[0m \u001b[38;5;66;03m# would convert to numpy arrays and raise later any way) - GH29926\u001b[39;00m\n\u001b[1;32m-> 5637\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n", + "\u001b[1;31mInvalidIndexError\u001b[0m: (slice(None, None, None), None)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning,loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test4-checkpoint.ipynb b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test4-checkpoint.ipynb new file mode 100644 index 0000000..fd16e2c --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test4-checkpoint.ipynb @@ -0,0 +1,8878 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1_000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 actions: tensor([2, 3, 0])\n", + "loss= tensor(14.3700, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([14.5668, 10.5095, 5.6438])\n", + "actionProbs tensor([[0.3411, 0.3447, 0.3265, 0.3323],\n", + " [0.3336, 0.3344, 0.3327, 0.3331],\n", + " [0.3253, 0.3209, 0.3408, 0.3346]], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 0, 2])\n", + "loss= tensor(15.2851, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([14.5241, 10.4676, 5.5462])\n", + "actionProbs tensor([[0.2986, 0.3239, 0.4163, 0.2936],\n", + " [0.3276, 0.3396, 0.3302, 0.3310],\n", + " [0.3739, 0.3365, 0.2535, 0.3755]], grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([0, 2, 0])\n", + "loss= tensor(14.2920, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([14.4485, 10.3736, 5.5689])\n", + "actionProbs tensor([[0.3501, 0.5101, 0.3013, 0.3593],\n", + " [0.3330, 0.3122, 0.3273, 0.3369],\n", + " [0.3169, 0.1777, 0.3714, 0.3038]], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([2, 2, 1])\n", + "loss= tensor(14.0527, grad_fn=) , return= 16148.578125\n", + "discReturns/1000= tensor([14.5401, 10.4798, 5.6053])\n", + "actionProbs tensor([[0.3331, 0.3801, 0.3867, 0.3945],\n", + " [0.3326, 0.3338, 0.3312, 0.3359],\n", + " [0.3343, 0.2861, 0.2821, 0.2695]], grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([1, 1, 2])\n", + "loss= tensor(13.8139, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([14.4648, 10.3929, 5.5462])\n", + "actionProbs tensor([[0.3823, 0.3647, 0.3374, 0.3419],\n", + " [0.3318, 0.3347, 0.3321, 0.3386],\n", + " [0.2860, 0.3006, 0.3304, 0.3195]], grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([2, 3, 2])\n", + "loss= tensor(14.1625, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([14.5635, 10.5059, 5.6398])\n", + "actionProbs tensor([[0.3565, 0.3334, 0.3533, 0.3651],\n", + " [0.3361, 0.3335, 0.3344, 0.3365],\n", + " [0.3074, 0.3331, 0.3123, 0.2985]], grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([0, 0, 3])\n", + "loss= tensor(14.9211, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[0.2825, 0.2942, 0.3373, 0.3813],\n", + " [0.3325, 0.3331, 0.3331, 0.3309],\n", + " [0.3850, 0.3727, 0.3296, 0.2878]], grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([1, 1, 3])\n", + "loss= tensor(13.2686, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([14.4608, 10.3884, 5.5413])\n", + "actionProbs tensor([[0.4034, 0.3388, 0.3222, 0.2392],\n", + " [0.3422, 0.3375, 0.3311, 0.3078],\n", + " [0.2543, 0.3237, 0.3467, 0.4530]], grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([1, 0, 0])\n", + "loss= tensor(14.1636, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([14.4389, 10.3640, 5.5131])\n", + "actionProbs tensor([[0.3481, 0.3311, 0.3639, 0.3795],\n", + " [0.3882, 0.3500, 0.3242, 0.3022],\n", + " [0.2637, 0.3189, 0.3118, 0.3183]], grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([2, 1, 0])\n", + "loss= tensor(12.4751, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([14.5133, 10.4501, 5.5689])\n", + "actionProbs tensor([[0.0242, 0.1251, 0.2959, 0.7412],\n", + " [0.2700, 0.3417, 0.3357, 0.1711],\n", + " [0.7058, 0.5332, 0.3683, 0.0877]], grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([0, 1, 1])\n", + "loss= tensor(13.1282, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([14.4202, 10.3421, 5.5306])\n", + "actionProbs tensor([[0.3997, 0.3434, 0.3187, 0.2670],\n", + " [0.3856, 0.3535, 0.3327, 0.2959],\n", + " [0.2147, 0.3031, 0.3486, 0.4371]], grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([0, 3, 1])\n", + "loss= tensor(24.0207, grad_fn=) , return= 16074.078125\n", + "discReturns/1000= tensor([14.4734, 10.4013, 5.6053])\n", + "actionProbs tensor([[0.0305, 0.1932, 0.4481, 0.5365],\n", + " [0.1028, 0.2804, 0.3412, 0.3283],\n", + " [0.8667, 0.5264, 0.2107, 0.1352]], grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 1, 2])\n", + "loss= tensor(9.3850, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([14.5534, 10.5002, 5.5836])\n", + "actionProbs tensor([[0.0074, 0.0636, 0.5593, 0.4518],\n", + " [0.9549, 0.7904, 0.1120, 0.1805],\n", + " [0.0377, 0.1461, 0.3287, 0.3677]], grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.7048, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1943e-03, 7.1138e-07, 2.0163e-07, 1.5027e-07],\n", + " [6.3728e-02, 8.1566e-04, 2.5514e-04, 2.3243e-04],\n", + " [9.3408e-01, 9.9918e-01, 9.9974e-01, 9.9977e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5935, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4860e-04, 1.4307e-08, 1.3893e-09, 1.0059e-09],\n", + " [1.6544e-02, 1.1095e-04, 2.0016e-05, 1.8005e-05],\n", + " [9.8331e-01, 9.9989e-01, 9.9998e-01, 9.9998e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5380, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.2894e-04, 6.7207e-10, 3.9580e-11, 2.9530e-11],\n", + " [1.5163e-02, 2.2266e-05, 3.0564e-06, 2.8011e-06],\n", + " [9.8471e-01, 9.9998e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.4510, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[2.0240e-02, 1.4748e-08, 6.5000e-11, 6.7803e-11],\n", + " [1.7072e-01, 8.7669e-05, 3.1515e-06, 3.2808e-06],\n", + " [8.0904e-01, 9.9991e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5313, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.2494e-04, 1.2137e-12, 7.0943e-13, 5.7800e-13],\n", + " [1.6364e-02, 8.9921e-07, 3.7899e-07, 3.5636e-07],\n", + " [9.8351e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5972, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5080e-05, 2.4054e-09, 3.2711e-13, 2.5893e-13],\n", + " [8.9534e-03, 1.1584e-04, 1.3333e-06, 1.1441e-06],\n", + " [9.9103e-01, 9.9988e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5408, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6082e-05, 1.4775e-10, 2.1370e-15, 1.8104e-15],\n", + " [8.8521e-03, 2.5656e-05, 9.1213e-08, 8.0155e-08],\n", + " [9.9113e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5565, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.0538e-05, 6.5032e-10, 5.9195e-15, 4.4514e-15],\n", + " [6.6051e-03, 3.9549e-05, 8.8732e-08, 7.7599e-08],\n", + " [9.9338e-01, 9.9996e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "21000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5565, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5801e-05, 2.4881e-09, 1.1989e-14, 9.3250e-15],\n", + " [1.1208e-02, 8.6259e-05, 1.5281e-07, 1.3481e-07],\n", + " [9.8877e-01, 9.9991e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5456, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8291e-05, 7.9380e-10, 2.7196e-15, 2.6802e-14],\n", + " [1.3511e-02, 5.6811e-05, 8.4469e-08, 2.5516e-07],\n", + " [9.8646e-01, 9.9994e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5636, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9507e-06, 1.7117e-10, 4.6402e-16, 1.0445e-14],\n", + " [5.2006e-03, 2.5885e-05, 3.3190e-08, 1.5132e-07],\n", + " [9.9480e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5750, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2444e-06, 2.7993e-10, 6.1005e-16, 2.5271e-14],\n", + " [4.1440e-03, 3.5661e-05, 4.3352e-08, 2.6298e-07],\n", + " [9.9585e-01, 9.9996e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5351, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0452e-05, 2.0314e-10, 2.7550e-17, 3.4566e-15],\n", + " [1.7656e-02, 3.0928e-05, 9.0952e-09, 9.5844e-08],\n", + " [9.8230e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5457, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7855e-06, 9.7789e-12, 3.2736e-15, 2.2839e-14],\n", + " [2.6971e-03, 2.2512e-06, 1.8368e-08, 5.2754e-08],\n", + " [9.9730e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5407, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1926e-07, 1.8083e-13, 1.5933e-16, 7.7042e-16],\n", + " [6.7652e-04, 1.3856e-07, 1.3235e-09, 3.3401e-09],\n", + " [9.9932e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5397, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.6279e-08, 1.3311e-14, 2.0644e-17, 8.3193e-17],\n", + " [2.6647e-04, 2.1307e-08, 2.1912e-10, 5.2190e-10],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5393, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3618e-08, 1.6099e-15, 3.8478e-18, 1.3724e-17],\n", + " [1.2309e-04, 4.5325e-09, 4.8645e-11, 1.1217e-10],\n", + " [9.9988e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5392, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3089e-09, 2.4618e-16, 8.4663e-19, 2.7542e-18],\n", + " [6.1409e-05, 1.1261e-09, 1.2422e-11, 2.8076e-11],\n", + " [9.9994e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5391, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1308e-09, 4.2768e-17, 2.0071e-19, 6.0834e-19],\n", + " [3.1980e-05, 3.0495e-10, 3.4293e-12, 7.6539e-12],\n", + " [9.9997e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2303e-09, 7.9708e-18, 4.9246e-20, 1.4097e-19],\n", + " [1.7129e-05, 8.7148e-11, 9.9394e-13, 2.2006e-12],\n", + " [9.9998e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8835e-10, 1.4842e-18, 1.2195e-20, 3.2969e-20],\n", + " [9.3048e-06, 2.5782e-11, 2.9746e-13, 6.5498e-13],\n", + " [9.9999e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9739e-10, 2.8820e-19, 3.0783e-21, 7.9096e-21],\n", + " [5.1212e-06, 7.8146e-12, 9.1010e-14, 1.9961e-13],\n", + " [9.9999e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3473e-11, 6.0871e-20, 8.7299e-22, 2.1171e-21],\n", + " [2.8029e-06, 2.3866e-12, 2.8031e-14, 6.1306e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4695e-11, 1.2025e-20, 2.1115e-22, 4.9539e-22],\n", + " [1.5608e-06, 7.4220e-13, 8.7660e-15, 1.9160e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7698e-11, 3.3386e-21, 8.8350e-23, 1.8958e-22],\n", + " [8.7751e-07, 2.3387e-13, 2.7832e-15, 6.0672e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3404e-12, 8.6857e-22, 3.2943e-23, 6.4975e-23],\n", + " [4.9854e-07, 7.5243e-14, 9.0402e-16, 1.9572e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6184e-12, 1.2343e-21, 1.4397e-22, 2.1807e-22],\n", + " [2.8209e-07, 2.7088e-14, 3.2649e-16, 7.0847e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "40000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8167e-12, 2.3500e-22, 2.6903e-23, 4.1757e-23],\n", + " [1.6084e-07, 1.2097e-14, 1.4681e-16, 3.1868e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "41000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5385, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.4076e-09, 4.2209e-20, 3.5140e-22, 8.6742e-22],\n", + " [1.5936e-07, 8.6000e-15, 1.5144e-16, 4.1089e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5507, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6732e-04, 9.5150e-15, 3.2005e-17, 6.8905e-17],\n", + " [8.2168e-03, 7.8889e-10, 6.5889e-12, 1.2909e-11],\n", + " [9.9152e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1320e-06, 2.4679e-17, 2.1126e-19, 3.3816e-19],\n", + " [2.6040e-04, 6.5036e-12, 6.2308e-14, 1.0644e-13],\n", + " [9.9974e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5370, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4575e-06, 3.0842e-17, 2.7249e-19, 4.3387e-19],\n", + " [2.8748e-04, 7.6502e-12, 7.5444e-14, 1.2844e-13],\n", + " [9.9971e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7969e-06, 3.9357e-17, 3.6612e-19, 5.7763e-19],\n", + " [3.1745e-04, 9.4446e-12, 9.8416e-14, 1.6605e-13],\n", + " [9.9968e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5395, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9520e-06, 4.4919e-17, 4.4184e-19, 6.8836e-19],\n", + " [3.3050e-04, 1.0522e-11, 1.1505e-13, 1.9206e-13],\n", + " [9.9967e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5370, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0383e-06, 5.1157e-17, 5.5099e-19, 8.3898e-19],\n", + " [3.3848e-04, 1.1737e-11, 1.3963e-13, 2.2775e-13],\n", + " [9.9966e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5371, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.9885e-07, 1.2128e-17, 1.7896e-19, 2.4433e-19],\n", + " [1.4818e-04, 4.0200e-12, 5.2903e-14, 8.0603e-14],\n", + " [9.9985e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5394, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1240e-06, 4.1339e-17, 8.8502e-19, 1.1335e-18],\n", + " [2.7463e-04, 1.1492e-11, 2.1477e-13, 3.0935e-13],\n", + " [9.9972e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0371e-06, 4.2458e-17, 1.1825e-18, 1.4094e-18],\n", + " [2.6518e-04, 1.1630e-11, 2.5623e-13, 3.5106e-13],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5191, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8355e-03, 5.0034e-16, 1.1666e-18, 1.8665e-18],\n", + " [3.7543e-02, 8.2853e-10, 1.2247e-11, 1.9446e-11],\n", + " [9.6062e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5295, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8180e-04, 7.2007e-17, 2.0745e-19, 2.5587e-19],\n", + " [1.6184e-02, 1.5875e-10, 2.3594e-12, 3.2731e-12],\n", + " [9.8333e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5300, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4585e-04, 2.5924e-17, 7.9633e-20, 9.4305e-20],\n", + " [1.0448e-02, 6.7373e-11, 9.7323e-13, 1.3194e-12],\n", + " [9.8931e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5330, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8955e-04, 2.0647e-17, 6.8307e-20, 7.8137e-20],\n", + " [8.8863e-03, 5.5394e-11, 8.2553e-13, 1.0970e-12],\n", + " [9.9092e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5342, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0863e-04, 1.3087e-17, 5.2045e-20, 5.5105e-20],\n", + " [6.4215e-03, 4.0429e-11, 6.6138e-13, 8.3933e-13],\n", + " [9.9347e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5315, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3666e-04, 4.2585e-17, 3.5450e-19, 2.8690e-19],\n", + " [1.2056e-02, 1.5395e-10, 4.8860e-12, 5.4115e-12],\n", + " [9.8771e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5314, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4311e-04, 6.3380e-17, 5.6089e-19, 4.4252e-19],\n", + " [1.2359e-02, 2.0554e-10, 6.8584e-12, 7.4822e-12],\n", + " [9.8740e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5288, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4021e-04, 7.4797e-17, 6.1756e-19, 4.9190e-19],\n", + " [1.3049e-02, 2.8745e-10, 9.0855e-12, 9.8594e-12],\n", + " [9.8671e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "59000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.0119, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[9.7257e-01, 2.8119e-18, 9.6907e-14, 2.0380e-17],\n", + " [2.7221e-02, 2.2712e-09, 5.3586e-07, 6.6865e-09],\n", + " [2.0959e-04, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.0119, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[9.7797e-01, 4.8010e-19, 4.4624e-14, 5.7223e-18],\n", + " [2.1904e-02, 3.7777e-10, 1.6514e-07, 1.4573e-09],\n", + " [1.2446e-04, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "61000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0089, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8122e-01, 1.7438e-19, 2.0926e-14, 2.1107e-18],\n", + " [1.8702e-02, 1.1688e-10, 6.4833e-08, 4.5457e-10],\n", + " [8.1473e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0089, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8434e-01, 6.4931e-20, 1.0242e-14, 8.1008e-19],\n", + " [1.5611e-02, 4.0401e-11, 2.8383e-08, 1.6031e-10],\n", + " [5.1351e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0088, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8727e-01, 2.4883e-20, 5.2772e-15, 3.2842e-19],\n", + " [1.2695e-02, 1.7229e-11, 1.4993e-08, 7.0661e-11],\n", + " [3.1587e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5396, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2698e-07, 1.1843e-17, 7.5200e-14, 6.6233e-15],\n", + " [2.7211e-04, 6.1369e-11, 1.1710e-08, 2.2705e-09],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5391, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0041e-08, 1.0975e-19, 5.3514e-16, 4.6351e-17],\n", + " [5.4866e-05, 2.7603e-12, 5.0268e-10, 9.6825e-11],\n", + " [9.9995e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4575e-10, 8.3933e-23, 3.2252e-19, 2.5685e-20],\n", + " [2.1456e-06, 9.3031e-15, 1.5729e-12, 2.8050e-13],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7096e-10, 2.7267e-23, 1.9684e-20, 1.5955e-21],\n", + " [5.4067e-07, 2.0903e-15, 9.0301e-14, 1.6161e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4127e-10, 2.1993e-23, 7.3411e-21, 6.2481e-22],\n", + " [2.9197e-07, 7.6030e-16, 1.4778e-14, 2.7326e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3753e-10, 1.5451e-23, 3.9870e-21, 3.4757e-22],\n", + " [1.5875e-07, 4.9522e-16, 7.7530e-15, 1.4650e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6619e-11, 6.0161e-24, 1.2789e-21, 1.1296e-22],\n", + " [6.3712e-08, 2.3749e-16, 3.3676e-15, 6.4431e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6714e-11, 8.4956e-24, 1.9482e-21, 1.7239e-22],\n", + " [5.8626e-08, 2.4323e-16, 3.4712e-15, 6.6434e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.6660e-11, 9.9376e-24, 2.2346e-21, 1.9785e-22],\n", + " [5.8249e-08, 2.4088e-16, 3.4142e-15, 6.5358e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8695e-11, 1.3604e-23, 3.0038e-21, 2.6613e-22],\n", + " [5.8033e-08, 2.4679e-16, 3.5068e-15, 6.7172e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4690e-10, 2.3297e-23, 4.9595e-21, 4.3901e-22],\n", + " [5.7700e-08, 2.5128e-16, 3.5590e-15, 6.8234e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0253e-10, 5.0918e-23, 1.2434e-20, 1.0583e-21],\n", + " [5.7913e-08, 2.6890e-16, 3.8413e-15, 7.3659e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6722e-10, 1.0569e-22, 2.9025e-20, 2.3995e-21],\n", + " [5.8839e-08, 2.9938e-16, 4.2965e-15, 8.2364e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3414e-10, 3.6227e-22, 1.1247e-19, 8.9823e-21],\n", + " [5.5982e-08, 3.4013e-16, 4.8414e-15, 9.2798e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "78000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8431e-09, 1.1870e-21, 2.9112e-19, 2.4474e-20],\n", + " [5.3006e-08, 3.4858e-16, 4.7103e-15, 9.2659e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9290e-09, 4.6894e-21, 8.1369e-19, 7.7490e-20],\n", + " [5.4457e-08, 3.5464e-16, 4.4496e-15, 9.3179e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.6900e-09, 2.7067e-20, 2.8606e-18, 3.1693e-19],\n", + " [4.9789e-08, 4.2031e-16, 4.8899e-15, 1.0624e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "81000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.6490e-09, 2.9137e-20, 2.8760e-18, 3.3301e-19],\n", + " [5.1331e-08, 3.5602e-16, 3.7994e-15, 8.6239e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1274e-09, 4.8394e-20, 3.8664e-18, 4.8595e-19],\n", + " [4.8591e-08, 5.1280e-16, 4.3413e-15, 1.0748e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3645e-09, 4.7192e-20, 3.0698e-18, 4.0658e-19],\n", + " [4.3816e-08, 6.6829e-16, 3.5214e-15, 1.0134e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.9998e-09, 1.0830e-19, 3.9019e-18, 5.2114e-19],\n", + " [4.0573e-08, 5.3614e-16, 2.4320e-15, 7.2312e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0218e-10, 4.3768e-23, 8.8902e-22, 1.5935e-22],\n", + " [1.8348e-08, 4.3821e-17, 1.9317e-16, 7.1918e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8536e-11, 3.4322e-24, 6.4018e-23, 1.1812e-23],\n", + " [1.3832e-08, 2.7261e-17, 1.2697e-16, 4.7988e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3131e-11, 2.6812e-24, 5.0087e-23, 9.2606e-24],\n", + " [1.3735e-08, 2.6678e-17, 1.2474e-16, 4.7172e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0738e-11, 2.3772e-24, 4.4357e-23, 8.2125e-24],\n", + " [1.3691e-08, 2.6400e-17, 1.2365e-16, 4.6776e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.6490e-11, 1.8651e-24, 3.4554e-23, 6.4188e-24],\n", + " [1.3603e-08, 2.5810e-17, 1.2132e-16, 4.5921e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.7429e-11, 5.8619e-24, 1.1453e-22, 2.0808e-23],\n", + " [1.5250e-08, 3.0425e-17, 1.4189e-16, 5.3328e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2133e-11, 2.2351e-24, 4.2119e-23, 7.7587e-24],\n", + " [1.4115e-08, 2.6375e-17, 1.2471e-16, 4.7094e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8447e-12, 3.3629e-26, 4.6730e-25, 9.5360e-26],\n", + " [1.1891e-08, 1.6650e-17, 8.4162e-17, 3.1954e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2863e-12, 1.7339e-26, 2.3495e-25, 4.8236e-26],\n", + " [1.1669e-08, 1.5065e-17, 7.6909e-17, 2.9215e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5627e-16, 1.5132e-30, 6.1297e-30, 1.6511e-30],\n", + " [4.8974e-09, 5.2784e-18, 2.8634e-17, 1.1017e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.2601e-16, 8.6587e-31, 3.3285e-30, 9.0483e-31],\n", + " [4.6606e-09, 4.9468e-18, 2.6761e-17, 1.0315e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.0167e-16, 1.3875e-30, 5.5059e-30, 1.4868e-30],\n", + " [5.0424e-09, 5.2101e-18, 2.8532e-17, 1.0953e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "97000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0010e-17, 1.0136e-31, 4.0564e-31, 1.1089e-31],\n", + " [3.0856e-09, 3.0812e-18, 1.6048e-17, 6.2980e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0195e-16, 1.0599e-31, 4.1565e-31, 1.1358e-31],\n", + " [3.3036e-09, 3.1126e-18, 1.6494e-17, 6.4431e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.7582e-17, 2.7968e-32, 1.1112e-31, 3.0347e-32],\n", + " [2.3332e-09, 2.1215e-18, 1.0812e-17, 4.2994e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5040e-17, 2.0073e-32, 7.9130e-32, 2.1548e-32],\n", + " [2.2588e-09, 1.9224e-18, 9.8447e-18, 3.9131e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "101000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3478e-17, 1.6645e-32, 6.5621e-32, 1.7829e-32],\n", + " [2.2824e-09, 1.8043e-18, 9.1530e-18, 3.6385e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8950e-17, 8.3065e-33, 3.1846e-32, 8.7932e-33],\n", + " [1.8152e-09, 1.4947e-18, 7.4671e-18, 3.0031e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5429e-17, 5.9841e-33, 2.2727e-32, 6.3043e-33],\n", + " [1.6987e-09, 1.3612e-18, 6.7323e-18, 2.7188e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0905e-17, 7.8191e-33, 3.0274e-32, 8.3126e-33],\n", + " [1.9530e-09, 1.4523e-18, 7.2250e-18, 2.8990e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9801e-17, 7.0244e-33, 2.7175e-32, 7.4732e-33],\n", + " [1.9217e-09, 1.4087e-18, 6.9976e-18, 2.8115e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2171e-17, 7.6177e-33, 2.9729e-32, 8.1461e-33],\n", + " [2.0268e-09, 1.4354e-18, 7.1518e-18, 2.8670e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1661e-17, 4.1438e-33, 1.5129e-32, 4.2897e-33],\n", + " [1.6027e-09, 1.4031e-18, 6.6789e-18, 2.7464e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7098e-17, 5.1068e-33, 1.9727e-32, 5.4509e-33],\n", + " [1.8484e-09, 1.2919e-18, 6.3878e-18, 2.5771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8047e-17, 5.1424e-33, 2.0009e-32, 5.5208e-33],\n", + " [1.8975e-09, 1.2879e-18, 6.3920e-18, 2.5764e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1009e-17, 5.7941e-33, 2.2820e-32, 6.2671e-33],\n", + " [2.0321e-09, 1.3242e-18, 6.6073e-18, 2.6550e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8348e-17, 4.9049e-33, 1.9104e-32, 5.2842e-33],\n", + " [1.9404e-09, 1.3023e-18, 6.4473e-18, 2.6048e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6838e-17, 4.5847e-33, 1.7623e-32, 4.9116e-33],\n", + " [1.8896e-09, 1.3362e-18, 6.5499e-18, 2.6614e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3304e-17, 3.8334e-33, 1.4173e-32, 4.0236e-33],\n", + " [1.7651e-09, 1.4231e-18, 6.7588e-18, 2.7863e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8651e-17, 4.5554e-33, 1.7689e-32, 4.9097e-33],\n", + " [2.0129e-09, 1.3260e-18, 6.5001e-18, 2.6361e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8311e-17, 4.3911e-33, 1.6995e-32, 4.7341e-33],\n", + " [2.0140e-09, 1.3451e-18, 6.5703e-18, 2.6722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "116000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6872e-17, 4.1089e-33, 1.5704e-32, 4.4068e-33],\n", + " [1.9643e-09, 1.3787e-18, 6.6706e-18, 2.7281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5727e-17, 3.8111e-33, 1.4389e-32, 4.0670e-33],\n", + " [1.9361e-09, 1.4137e-18, 6.7652e-18, 2.7826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6097e-17, 3.6799e-33, 1.3883e-32, 3.9250e-33],\n", + " [1.9920e-09, 1.4205e-18, 6.7555e-18, 2.7818e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2811e-17, 3.0941e-33, 1.1252e-32, 3.2401e-33],\n", + " [1.8597e-09, 1.5108e-18, 6.9797e-18, 2.9152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5639e-17, 3.4061e-33, 1.2757e-32, 3.6281e-33],\n", + " [2.0115e-09, 1.4555e-18, 6.8544e-18, 2.8371e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "121000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5150e-17, 3.2314e-33, 1.2021e-32, 3.4336e-33],\n", + " [2.0123e-09, 1.4799e-18, 6.9163e-18, 2.8731e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5259e-17, 3.1830e-33, 1.1850e-32, 3.3886e-33],\n", + " [2.0278e-09, 1.4874e-18, 6.9484e-18, 2.8892e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7833e-17, 3.4196e-33, 1.3028e-32, 3.6907e-33],\n", + " [2.1587e-09, 1.4476e-18, 6.8638e-18, 2.8347e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3489e-17, 2.8417e-33, 1.0380e-32, 3.0046e-33],\n", + " [1.9595e-09, 1.5517e-18, 7.1403e-18, 2.9969e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3551e-17, 2.7103e-33, 9.8627e-33, 2.8597e-33],\n", + " [2.0037e-09, 1.5661e-18, 7.1460e-18, 3.0058e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5407e-17, 2.8598e-33, 1.0606e-32, 3.0529e-33],\n", + " [2.1122e-09, 1.5336e-18, 7.0819e-18, 2.9633e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2658e-17, 2.5383e-33, 9.1068e-33, 2.6653e-33],\n", + " [1.9824e-09, 1.6437e-18, 7.4071e-18, 3.1386e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5479e-17, 2.7506e-33, 1.0203e-32, 2.9463e-33],\n", + " [2.1394e-09, 1.5556e-18, 7.1691e-18, 3.0077e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9910e-17, 3.1098e-33, 1.1977e-32, 3.4048e-33],\n", + " [2.3633e-09, 1.4868e-18, 7.0215e-18, 2.9124e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3163e-17, 2.5591e-33, 9.0955e-33, 2.6846e-33],\n", + " [2.0856e-09, 1.8168e-18, 8.0777e-18, 3.4486e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1370e-17, 3.0403e-33, 1.1805e-32, 3.3535e-33],\n", + " [2.4771e-09, 1.4939e-18, 7.0587e-18, 2.9287e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3837e-17, 3.1657e-33, 1.2493e-32, 3.5290e-33],\n", + " [2.5964e-09, 1.4736e-18, 7.0317e-18, 2.9059e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0266e-17, 2.7676e-33, 1.0638e-32, 3.0463e-33],\n", + " [2.4759e-09, 1.5383e-18, 7.1860e-18, 3.0011e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6169e-17, 2.5542e-33, 9.3189e-33, 2.7330e-33],\n", + " [2.3383e-09, 1.8005e-18, 8.0746e-18, 3.4360e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "135000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5919e-17, 2.5639e-33, 9.2557e-33, 2.7297e-33],\n", + " [2.3596e-09, 1.9065e-18, 8.4633e-18, 3.6186e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1051e-17, 2.6123e-33, 1.0077e-32, 2.8944e-33],\n", + " [2.5729e-09, 1.5658e-18, 7.2917e-18, 3.0548e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6139e-17, 2.5701e-33, 9.1236e-33, 2.7139e-33],\n", + " [2.4718e-09, 2.1160e-18, 9.1980e-18, 3.9647e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8577e-17, 2.5620e-33, 9.3491e-33, 2.7518e-33],\n", + " [2.6219e-09, 1.9729e-18, 8.7161e-18, 3.7287e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8676e-17, 2.5621e-33, 9.2430e-33, 2.7341e-33],\n", + " [2.6978e-09, 2.1006e-18, 9.1483e-18, 3.9328e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2759e-17, 2.5665e-33, 9.7289e-33, 2.8277e-33],\n", + " [2.8661e-09, 1.8312e-18, 8.2705e-18, 3.5069e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "141000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1985e-17, 2.5753e-33, 9.5950e-33, 2.8132e-33],\n", + " [2.8885e-09, 1.9939e-18, 8.8626e-18, 3.7855e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8553e-17, 2.5842e-33, 9.0883e-33, 2.7323e-33],\n", + " [2.8321e-09, 2.4955e-18, 1.0570e-17, 4.6080e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9687e-17, 2.5810e-33, 9.1124e-33, 2.7380e-33],\n", + " [2.9519e-09, 2.5336e-18, 1.0706e-17, 4.6692e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0454e-17, 2.5878e-33, 9.1565e-33, 2.7556e-33],\n", + " [3.0350e-09, 2.6024e-18, 1.0983e-17, 4.7976e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8664e-17, 2.5925e-33, 8.8503e-33, 2.7084e-33],\n", + " [3.0336e-09, 3.0374e-18, 1.2422e-17, 5.5021e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1178e-17, 2.6005e-33, 9.1435e-33, 2.7712e-33],\n", + " [3.1700e-09, 2.8337e-18, 1.1831e-17, 5.2014e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2448e-17, 2.6237e-33, 1.0400e-32, 3.0143e-33],\n", + " [3.5499e-09, 1.9984e-18, 9.1328e-18, 3.8771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0758e-17, 2.5930e-33, 8.8767e-33, 2.7276e-33],\n", + " [3.3021e-09, 3.2794e-18, 1.3295e-17, 5.9170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9952e-17, 2.5926e-33, 8.7108e-33, 2.7024e-33],\n", + " [3.3257e-09, 3.5908e-18, 1.4306e-17, 6.4180e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2528e-17, 2.5926e-33, 8.8963e-33, 2.7400e-33],\n", + " [3.5247e-09, 3.4578e-18, 1.3921e-17, 6.2152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5091e-17, 2.5901e-33, 9.0324e-33, 2.7679e-33],\n", + " [3.7327e-09, 3.3951e-18, 1.3752e-17, 6.1216e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9351e-17, 2.5654e-33, 8.2284e-33, 2.6112e-33],\n", + " [3.5726e-09, 4.5646e-18, 1.7261e-17, 7.9040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2052e-17, 2.5718e-33, 8.4637e-33, 2.6717e-33],\n", + " [3.7997e-09, 4.4754e-18, 1.7178e-17, 7.8381e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "154000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4396e-17, 2.5722e-33, 8.6057e-33, 2.7036e-33],\n", + " [4.0011e-09, 4.3935e-18, 1.6986e-17, 7.7278e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9451e-17, 2.5996e-33, 9.1243e-33, 2.8191e-33],\n", + " [4.2457e-09, 3.8907e-18, 1.5574e-17, 6.9944e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5797e-17, 2.5371e-33, 8.3666e-33, 2.6500e-33],\n", + " [4.3366e-09, 4.9150e-18, 1.8523e-17, 8.5009e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3186e-17, 2.5256e-33, 7.9848e-33, 2.5767e-33],\n", + " [4.3092e-09, 5.7860e-18, 2.1005e-17, 9.7902e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9847e-17, 2.4869e-33, 7.3570e-33, 2.4376e-33],\n", + " [4.2999e-09, 7.2961e-18, 2.4921e-17, 1.1879e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3578e-17, 2.5330e-33, 8.6243e-33, 2.7154e-33],\n", + " [5.1077e-09, 5.0568e-18, 1.9130e-17, 8.7661e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7760e-17, 2.4256e-33, 6.6924e-33, 2.2844e-33],\n", + " [4.4927e-09, 9.6660e-18, 3.0741e-17, 1.5042e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "161000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4257e-17, 2.4573e-33, 7.3908e-33, 2.4542e-33],\n", + " [4.9814e-09, 7.9801e-18, 2.7042e-17, 1.2952e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8821e-17, 2.4602e-33, 7.6790e-33, 2.5202e-33],\n", + " [5.3851e-09, 7.4807e-18, 2.5905e-17, 1.2305e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2014e-17, 2.4051e-33, 6.8514e-33, 2.3329e-33],\n", + " [5.1248e-09, 1.0063e-17, 3.2274e-17, 1.5798e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7387e-17, 2.4306e-33, 7.3322e-33, 2.4508e-33],\n", + " [5.5468e-09, 8.9138e-18, 2.9761e-17, 1.4365e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7957e-17, 2.3793e-33, 7.0270e-33, 2.3673e-33],\n", + " [5.8874e-09, 9.7943e-18, 3.1738e-17, 1.5447e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3933e-17, 2.2976e-33, 6.2955e-33, 2.1835e-33],\n", + " [5.9781e-09, 1.2666e-17, 3.8160e-17, 1.9050e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6971e-17, 2.3072e-33, 6.4992e-33, 2.2422e-33],\n", + " [6.3248e-09, 1.2465e-17, 3.8162e-17, 1.8985e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3308e-17, 2.2599e-33, 6.0422e-33, 2.1328e-33],\n", + " [6.2099e-09, 1.5032e-17, 4.3950e-17, 2.2281e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9389e-17, 2.2943e-33, 6.5263e-33, 2.2646e-33],\n", + " [6.7852e-09, 1.3607e-17, 4.1505e-17, 2.0773e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8107e-17, 2.1137e-33, 5.0559e-33, 1.8727e-33],\n", + " [6.2884e-09, 2.2673e-17, 5.9512e-17, 3.1442e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9012e-17, 2.0766e-33, 4.9351e-33, 1.8367e-33],\n", + " [6.6765e-09, 2.4275e-17, 6.2640e-17, 3.3281e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1735e-17, 2.0909e-33, 5.1385e-33, 1.8989e-33],\n", + " [7.0881e-09, 2.3619e-17, 6.2199e-17, 3.2886e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "173000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5877e-17, 2.2031e-33, 6.2669e-33, 2.2094e-33],\n", + " [8.3331e-09, 1.7316e-17, 5.0818e-17, 2.5900e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0148e-17, 2.0162e-33, 4.7376e-33, 1.7957e-33],\n", + " [7.3738e-09, 2.9896e-17, 7.4819e-17, 4.0454e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3733e-17, 1.8766e-33, 3.8647e-33, 1.5417e-33],\n", + " [6.8902e-09, 4.4195e-17, 9.8729e-17, 5.5681e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "176000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.5883e-18, 1.6948e-33, 2.9373e-33, 1.2449e-33],\n", + " [6.4133e-09, 6.9869e-17, 1.3425e-16, 7.9651e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "177000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4353e-17, 1.7684e-33, 3.5422e-33, 1.4333e-33],\n", + " [7.6864e-09, 5.2182e-17, 1.1118e-16, 6.3661e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "178000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8149e-18, 1.5796e-33, 2.7384e-33, 1.1670e-33],\n", + " [7.4235e-09, 7.8103e-17, 1.4600e-16, 8.7349e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "179000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3919e-17, 1.6396e-33, 3.1438e-33, 1.3002e-33],\n", + " [8.3871e-09, 6.5156e-17, 1.3085e-16, 7.6510e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "180000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.8745e-18, 1.4895e-33, 2.3948e-33, 1.0591e-33],\n", + " [7.2644e-09, 1.0521e-16, 1.8319e-16, 1.1305e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "181000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.1580e-18, 1.4521e-33, 2.3187e-33, 1.0311e-33],\n", + " [7.6564e-09, 1.1257e-16, 1.9262e-16, 1.1961e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "182000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.0084e-18, 1.2922e-33, 1.7468e-33, 8.2467e-34],\n", + " [7.0179e-09, 1.7553e-16, 2.6043e-16, 1.6988e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "183000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.4347e-18, 1.3960e-33, 2.2740e-33, 1.0122e-33],\n", + " [8.6402e-09, 1.2112e-16, 2.0601e-16, 1.2839e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "184000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.6202e-18, 1.3348e-33, 2.0832e-33, 9.4518e-34],\n", + " [8.7771e-09, 1.4237e-16, 2.3138e-16, 1.4668e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "185000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9313e-20, 3.5155e-38, 1.0407e-37, 5.5990e-38],\n", + " [7.0221e-10, 9.1095e-19, 2.1832e-18, 1.4709e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "186000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9006e-20, 3.4938e-38, 1.0322e-37, 5.5585e-38],\n", + " [6.9973e-10, 9.1111e-19, 2.1791e-18, 1.4691e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "187000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9869e-20, 3.5398e-38, 1.0515e-37, 5.6495e-38],\n", + " [7.0695e-10, 9.0975e-19, 2.1873e-18, 1.4722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "188000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8219e-20, 3.4359e-38, 1.0096e-37, 5.4506e-38],\n", + " [6.9369e-10, 9.1264e-19, 2.1698e-18, 1.4659e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "189000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4013e-20, 3.2183e-38, 9.1366e-38, 5.0050e-38],\n", + " [6.6097e-10, 9.4354e-19, 2.1648e-18, 1.4797e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "190000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7437e-20, 3.3929e-38, 9.8899e-38, 5.3594e-38],\n", + " [6.9011e-10, 9.2534e-19, 2.1801e-18, 1.4775e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "191000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.6251e-20, 3.3797e-38, 9.7125e-38, 5.2939e-38],\n", + " [6.8534e-10, 9.5684e-19, 2.2205e-18, 1.5122e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "192000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0325e-20, 3.4623e-38, 1.0329e-37, 5.5485e-38],\n", + " [7.1046e-10, 8.9432e-19, 2.1555e-18, 1.4504e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "193000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5643e-20, 3.4007e-38, 9.6573e-38, 5.2907e-38],\n", + " [6.8717e-10, 9.9506e-19, 2.2782e-18, 1.5585e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "194000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8339e-20, 3.4314e-38, 1.0016e-37, 5.4297e-38],\n", + " [7.0335e-10, 9.4133e-19, 2.2156e-18, 1.5025e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "195000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6973e-20, 3.4215e-38, 9.8264e-38, 5.3624e-38],\n", + " [6.9818e-10, 9.7900e-19, 2.2649e-18, 1.5446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "196000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9600e-20, 3.5101e-38, 1.1278e-37, 5.8923e-38],\n", + " [7.5462e-10, 7.6341e-19, 1.9821e-18, 1.3031e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "197000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9437e-20, 3.4423e-38, 1.0115e-37, 5.4736e-38],\n", + " [7.1404e-10, 9.3681e-19, 2.2164e-18, 1.5010e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "198000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8559e-20, 3.4363e-38, 9.9924e-38, 5.4310e-38],\n", + " [7.1147e-10, 9.6201e-19, 2.2503e-18, 1.5297e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "199000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9717e-20, 3.4455e-38, 1.0121e-37, 5.4808e-38],\n", + " [7.1905e-10, 9.4389e-19, 2.2298e-18, 1.5111e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "200000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7774e-20, 3.4321e-38, 9.8661e-38, 5.3895e-38],\n", + " [7.1127e-10, 9.9402e-19, 2.2949e-18, 1.5669e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "201000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2308e-20, 3.4644e-38, 1.0400e-37, 5.5876e-38],\n", + " [7.3506e-10, 9.0605e-19, 2.1859e-18, 1.4718e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "202000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6594e-20, 3.4242e-38, 9.6807e-38, 5.3262e-38],\n", + " [7.0945e-10, 1.0400e-18, 2.3567e-18, 1.6191e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "203000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9682e-20, 3.4480e-38, 1.0054e-37, 5.4671e-38],\n", + " [7.2728e-10, 9.7473e-19, 2.2787e-18, 1.5502e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "204000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7470e-20, 3.4323e-38, 9.7663e-38, 5.3630e-38],\n", + " [7.1781e-10, 1.0325e-18, 2.3524e-18, 1.6138e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "205000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9903e-20, 3.4510e-38, 1.0049e-37, 5.4707e-38],\n", + " [7.3272e-10, 9.8573e-19, 2.2978e-18, 1.5650e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "206000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9257e-20, 3.4471e-38, 9.9560e-38, 5.4391e-38],\n", + " [7.3144e-10, 1.0072e-18, 2.3268e-18, 1.5896e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "207000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8126e-20, 3.4391e-38, 9.8039e-38, 5.3847e-38],\n", + " [7.2731e-10, 1.0400e-18, 2.3691e-18, 1.6259e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "208000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3890e-20, 3.4801e-38, 1.0472e-37, 5.6330e-38],\n", + " [7.5679e-10, 9.2560e-19, 2.2279e-18, 1.5024e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "209000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7721e-20, 3.5074e-38, 1.0868e-37, 5.7821e-38],\n", + " [7.7554e-10, 8.7034e-19, 2.1575e-18, 1.4417e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "210000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.7687e-20, 3.5079e-38, 1.0850e-37, 5.7782e-38],\n", + " [7.7745e-10, 8.7704e-19, 2.1687e-18, 1.4504e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "211000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0732e-20, 3.4606e-38, 1.0060e-37, 5.4901e-38],\n", + " [7.4869e-10, 1.0112e-18, 2.3439e-18, 1.6004e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "212000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5289e-20, 3.4923e-38, 1.0562e-37, 5.6774e-38],\n", + " [7.7160e-10, 9.2928e-19, 2.2423e-18, 1.5117e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "213000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2762e-20, 3.4760e-38, 1.0266e-37, 5.5713e-38],\n", + " [7.6238e-10, 9.8340e-19, 2.3140e-18, 1.5728e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "214000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4867e-20, 3.4909e-38, 1.0487e-37, 5.6552e-38],\n", + " [7.7382e-10, 9.5004e-19, 2.2738e-18, 1.5372e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "215000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9613e-20, 3.5246e-38, 1.0968e-37, 5.8366e-38],\n", + " [7.9638e-10, 8.8194e-19, 2.1869e-18, 1.4623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "216000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0194e-20, 3.4592e-38, 9.9217e-38, 5.4512e-38],\n", + " [7.5601e-10, 1.0605e-18, 2.4168e-18, 1.6601e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "217000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9715e-20, 3.5267e-38, 1.0948e-37, 5.8349e-38],\n", + " [8.0086e-10, 8.9267e-19, 2.2055e-18, 1.4768e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "218000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4760e-20, 3.4924e-38, 1.0406e-37, 5.6370e-38],\n", + " [7.8261e-10, 9.8314e-19, 2.3266e-18, 1.5794e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "219000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.1248e-20, 3.4685e-38, 9.9950e-38, 5.4870e-38],\n", + " [7.6816e-10, 1.0625e-18, 2.4278e-18, 1.6669e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "220000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3401e-20, 3.4842e-38, 1.0224e-37, 5.5750e-38],\n", + " [7.8079e-10, 1.0250e-18, 2.3843e-18, 1.6279e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "221000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6444e-20, 3.5062e-38, 1.0540e-37, 5.6951e-38],\n", + " [7.9658e-10, 9.7475e-19, 2.3231e-18, 1.5741e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "222000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8517e-20, 3.5215e-38, 1.0737e-37, 5.7721e-38],\n", + " [8.0802e-10, 9.4841e-19, 2.2918e-18, 1.5463e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "223000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4831e-20, 3.4953e-38, 1.0332e-37, 5.6232e-38],\n", + " [7.9411e-10, 1.0202e-18, 2.3864e-18, 1.6270e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "224000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6441e-20, 3.5080e-38, 1.0487e-37, 5.6847e-38],\n", + " [8.0389e-10, 9.9928e-19, 2.3627e-18, 1.6056e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "225000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8903e-20, 3.5263e-38, 1.0727e-37, 5.7774e-38],\n", + " [8.1668e-10, 9.6462e-19, 2.3205e-18, 1.5686e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "226000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7078e-20, 3.5139e-38, 1.0519e-37, 5.7029e-38],\n", + " [8.1165e-10, 1.0046e-18, 2.3750e-18, 1.6145e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "227000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4367e-20, 3.4944e-38, 1.0214e-37, 5.5907e-38],\n", + " [8.0137e-10, 1.0628e-18, 2.4503e-18, 1.6792e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "228000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8651e-20, 3.5258e-38, 1.0648e-37, 5.7569e-38],\n", + " [8.2289e-10, 9.9227e-19, 2.3641e-18, 1.6036e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "229000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4793e-20, 3.4986e-38, 1.0220e-37, 5.5998e-38],\n", + " [8.0902e-10, 1.0745e-18, 2.4715e-18, 1.6955e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "230000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8031e-20, 3.5231e-38, 1.0543e-37, 5.7250e-38],\n", + " [8.2619e-10, 1.0227e-18, 2.4095e-18, 1.6407e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "231000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2282e-20, 3.4822e-38, 9.9102e-38, 5.4891e-38],\n", + " [8.0167e-10, 1.1474e-18, 2.5656e-18, 1.7765e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "232000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.0882e-20, 3.5446e-38, 1.0791e-37, 5.8252e-38],\n", + " [8.4378e-10, 9.9332e-19, 2.3781e-18, 1.6116e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "233000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6389e-20, 3.5123e-38, 1.0315e-37, 5.6484e-38],\n", + " [8.2685e-10, 1.0805e-18, 2.4911e-18, 1.7086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "234000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0979e-20, 3.4726e-38, 9.6998e-38, 5.4183e-38],\n", + " [8.0319e-10, 1.2122e-18, 2.6522e-18, 1.8501e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "235000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7792e-20, 3.5238e-38, 1.0414e-37, 5.6937e-38],\n", + " [8.3970e-10, 1.0769e-18, 2.4940e-18, 1.7088e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "236000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9909e-20, 3.4648e-38, 9.5369e-38, 5.3619e-38],\n", + " [8.0286e-10, 1.2634e-18, 2.7184e-18, 1.9070e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "237000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2054e-20, 3.4823e-38, 9.7649e-38, 5.4527e-38],\n", + " [8.1707e-10, 1.2190e-18, 2.6709e-18, 1.8631e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "238000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6260e-20, 3.5138e-38, 1.0197e-37, 5.6210e-38],\n", + " [8.4107e-10, 1.1366e-18, 2.5773e-18, 1.7786e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "239000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8069e-20, 3.5950e-38, 1.1304e-37, 6.0436e-38],\n", + " [8.9362e-10, 9.5640e-19, 2.3526e-18, 1.5826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "240000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9430e-20, 3.5382e-38, 1.0478e-37, 5.7353e-38],\n", + " [8.6134e-10, 1.0970e-18, 2.5352e-18, 1.7396e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "241000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9392e-20, 3.5384e-38, 1.0456e-37, 5.7300e-38],\n", + " [8.6382e-10, 1.1069e-18, 2.5506e-18, 1.7520e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "242000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9635e-20, 3.5407e-38, 1.0455e-37, 5.7339e-38],\n", + " [8.6851e-10, 1.1151e-18, 2.5649e-18, 1.7632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "243000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4522e-20, 3.5749e-38, 1.0897e-37, 5.9060e-38],\n", + " [8.9242e-10, 1.0445e-18, 2.4800e-18, 1.6882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "244000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3303e-20, 3.5674e-38, 1.0763e-37, 5.8587e-38],\n", + " [8.9051e-10, 1.0736e-18, 2.5202e-18, 1.7220e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "245000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0922e-20, 3.5510e-38, 1.0518e-37, 5.7684e-38],\n", + " [8.8302e-10, 1.1228e-18, 2.5844e-18, 1.7771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "246000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3756e-20, 3.5714e-38, 1.0770e-37, 5.8676e-38],\n", + " [8.9758e-10, 1.0835e-18, 2.5383e-18, 1.7359e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "247000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6724e-20, 3.5202e-38, 1.0067e-37, 5.6001e-38],\n", + " [8.6864e-10, 1.2225e-18, 2.7107e-18, 1.8865e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "248000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9910e-20, 3.5451e-38, 1.0364e-37, 5.7191e-38],\n", + " [8.8677e-10, 1.1705e-18, 2.6523e-18, 1.8336e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "249000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7779e-20, 3.5286e-38, 1.0131e-37, 5.6317e-38],\n", + " [8.7986e-10, 1.2238e-18, 2.7196e-18, 1.8920e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "250000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3633e-20, 3.4967e-38, 9.6836e-38, 5.4605e-38],\n", + " [8.6135e-10, 1.3287e-18, 2.8438e-18, 2.0024e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "251000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0679e-20, 3.5513e-38, 1.0377e-37, 5.7338e-38],\n", + " [8.9909e-10, 1.1880e-18, 2.6837e-18, 1.8579e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "252000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2297e-20, 3.5635e-38, 1.0509e-37, 5.7885e-38],\n", + " [9.0955e-10, 1.1700e-18, 2.6657e-18, 1.8409e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "253000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8943e-20, 3.5388e-38, 1.0169e-37, 5.6595e-38],\n", + " [8.9686e-10, 1.2435e-18, 2.7568e-18, 1.9205e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "254000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6198e-20, 3.5910e-38, 1.0820e-37, 5.9157e-38],\n", + " [9.3260e-10, 1.1269e-18, 2.6200e-18, 1.7984e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "255000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6912e-20, 3.5963e-38, 1.0865e-37, 5.9362e-38],\n", + " [9.3845e-10, 1.1254e-18, 2.6215e-18, 1.7987e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "256000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4112e-20, 3.5776e-38, 1.0587e-37, 5.8338e-38],\n", + " [9.3061e-10, 1.1844e-18, 2.6983e-18, 1.8647e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "257000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.2611e-20, 3.5671e-38, 1.0428e-37, 5.7755e-38],\n", + " [9.2709e-10, 1.2220e-18, 2.7472e-18, 1.9068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "258000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3179e-20, 3.6364e-38, 1.1310e-37, 6.1196e-38],\n", + " [9.7502e-10, 1.0746e-18, 2.5705e-18, 1.7500e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "259000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.9383e-20, 3.6137e-38, 1.0974e-37, 5.9954e-38],\n", + " [9.6368e-10, 1.1377e-18, 2.6536e-18, 1.8213e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "260000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3230e-20, 3.5717e-38, 1.0405e-37, 5.7791e-38],\n", + " [9.4151e-10, 1.2529e-18, 2.7976e-18, 1.9471e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "261000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7960e-20, 3.6049e-38, 1.0797e-37, 5.9362e-38],\n", + " [9.6604e-10, 1.1864e-18, 2.7225e-18, 1.8790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "262000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7236e-20, 3.6005e-38, 1.0709e-37, 5.9063e-38],\n", + " [9.6699e-10, 1.2117e-18, 2.7577e-18, 1.9086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "263000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7359e-20, 3.6016e-38, 1.0696e-37, 5.9053e-38],\n", + " [9.7106e-10, 1.2219e-18, 2.7741e-18, 1.9218e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "264000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.7675e-20, 3.6661e-38, 1.1508e-37, 6.2223e-38],\n", + " [1.0155e-09, 1.0894e-18, 2.6146e-18, 1.7803e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "265000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3157e-20, 3.5721e-38, 1.0275e-37, 5.7482e-38],\n", + " [9.5993e-10, 1.3241e-18, 2.9038e-18, 2.0345e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "266000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0024e-20, 3.5361e-38, 9.9251e-38, 5.6085e-38],\n", + " [9.4924e-10, 1.4005e-18, 2.9926e-18, 2.1145e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "267000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2654e-20, 3.6376e-38, 1.1035e-37, 6.0544e-38],\n", + " [1.0086e-09, 1.1934e-18, 2.7576e-18, 1.9013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "268000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9182e-20, 3.6145e-38, 1.0723e-37, 5.9363e-38],\n", + " [9.9810e-10, 1.2590e-18, 2.8408e-18, 1.9737e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "269000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6202e-20, 3.5937e-38, 1.0448e-37, 5.8314e-38],\n", + " [9.8823e-10, 1.3210e-18, 2.9176e-18, 2.0411e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "270000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5595e-20, 3.5872e-38, 1.0364e-37, 5.8016e-38],\n", + " [9.8927e-10, 1.3453e-18, 2.9496e-18, 2.0687e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "271000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2960e-20, 3.5533e-38, 1.0071e-37, 5.6818e-38],\n", + " [9.8046e-10, 1.4038e-18, 3.0158e-18, 2.1291e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "272000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5739e-20, 3.6565e-38, 1.1154e-37, 6.1198e-38],\n", + " [1.0392e-09, 1.2096e-18, 2.7976e-18, 1.9300e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "273000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.7497e-20, 3.5977e-38, 1.0452e-37, 5.8457e-38],\n", + " [1.0083e-09, 1.3481e-18, 2.9645e-18, 2.0783e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "274000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6146e-20, 3.5788e-38, 1.0290e-37, 5.7808e-38],\n", + " [1.0056e-09, 1.3817e-18, 3.0042e-18, 2.1141e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "275000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.9001e-20, 3.6757e-38, 1.1329e-37, 6.1989e-38],\n", + " [1.0625e-09, 1.2003e-18, 2.7980e-18, 1.9265e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "276000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6903e-20, 3.5787e-38, 1.0289e-37, 5.7862e-38],\n", + " [1.0171e-09, 1.3957e-18, 3.0283e-18, 2.1333e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "277000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5049e-20, 3.5544e-38, 1.0081e-37, 5.7013e-38],\n", + " [1.0119e-09, 1.4400e-18, 3.0787e-18, 2.1793e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "278000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.7341e-20, 3.5753e-38, 1.0259e-37, 5.7790e-38],\n", + " [1.0271e-09, 1.4152e-18, 3.0581e-18, 2.1580e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "279000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9036e-20, 3.5902e-38, 1.0384e-37, 5.8342e-38],\n", + " [1.0384e-09, 1.3994e-18, 3.0456e-18, 2.1446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "280000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8933e-20, 3.6756e-38, 1.1174e-37, 6.1630e-38],\n", + " [1.0855e-09, 1.2752e-18, 2.9147e-18, 2.0215e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "281000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0894e-20, 3.5985e-38, 1.0448e-37, 5.8700e-38],\n", + " [1.0587e-09, 1.4093e-18, 3.0700e-18, 2.1625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "282000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.3299e-20, 3.6184e-38, 1.0618e-37, 5.9445e-38],\n", + " [1.0739e-09, 1.3881e-18, 3.0529e-18, 2.1445e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "283000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8323e-20, 3.5608e-38, 1.0130e-37, 5.7427e-38],\n", + " [1.0568e-09, 1.4842e-18, 3.1596e-18, 2.2430e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "284000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.1801e-20, 3.7485e-38, 1.1940e-37, 6.4834e-38],\n", + " [1.1529e-09, 1.1857e-18, 2.8280e-18, 1.9370e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "285000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2299e-20, 3.5943e-38, 1.0409e-37, 5.8668e-38],\n", + " [1.0835e-09, 1.4482e-18, 3.1323e-18, 2.2134e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "286000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3639e-20, 3.6036e-38, 1.0487e-37, 5.9024e-38],\n", + " [1.0938e-09, 1.4419e-18, 3.1308e-18, 2.2101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "287000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3833e-20, 3.6010e-38, 1.0462e-37, 5.8954e-38],\n", + " [1.0997e-09, 1.4552e-18, 3.1506e-18, 2.2267e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "288000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.4855e-20, 3.6065e-38, 1.0506e-37, 5.9178e-38],\n", + " [1.1091e-09, 1.4561e-18, 3.1573e-18, 2.2309e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "289000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0626e-20, 3.6576e-38, 1.0939e-37, 6.1027e-38],\n", + " [1.1377e-09, 1.3907e-18, 3.0934e-18, 2.1685e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "290000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3739e-20, 3.4745e-38, 9.4338e-38, 5.4658e-38],\n", + " [1.0661e-09, 1.6891e-18, 3.4032e-18, 2.4623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "291000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5359e-20, 3.5971e-38, 1.0427e-37, 5.8938e-38],\n", + " [1.1254e-09, 1.4941e-18, 3.2129e-18, 2.2776e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "292000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2595e-20, 3.5631e-38, 1.0145e-37, 5.7780e-38],\n", + " [1.1192e-09, 1.5580e-18, 3.2855e-18, 2.3442e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "293000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1492e-20, 3.5470e-38, 1.0010e-37, 5.7241e-38],\n", + " [1.1191e-09, 1.5941e-18, 3.3279e-18, 2.3826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "294000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.8099e-20, 3.6990e-38, 1.1289e-37, 6.2669e-38],\n", + " [1.1929e-09, 1.3769e-18, 3.1073e-18, 2.1710e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "295000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7107e-20, 3.4868e-38, 9.5342e-38, 5.5256e-38],\n", + " [1.1090e-09, 1.7169e-18, 3.4624e-18, 2.5076e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "296000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6752e-20, 3.7587e-38, 1.1811e-37, 6.4911e-38],\n", + " [1.2350e-09, 1.3169e-18, 3.0533e-18, 2.1162e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "297000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.9762e-20, 3.6066e-38, 1.0505e-37, 5.9489e-38],\n", + " [1.1774e-09, 1.5362e-18, 3.2943e-18, 2.3410e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "298000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.8819e-20, 3.5907e-38, 1.0378e-37, 5.8985e-38],\n", + " [1.1796e-09, 1.5700e-18, 3.3357e-18, 2.3781e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "299000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6408e-20, 3.4540e-38, 9.2970e-38, 5.4342e-38],\n", + " [1.1263e-09, 1.8121e-18, 3.5791e-18, 2.6119e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "300000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8253e-20, 3.5742e-38, 1.0244e-37, 5.8483e-38],\n", + " [1.1880e-09, 1.6144e-18, 3.3932e-18, 2.4286e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "301000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5225e-20, 3.6348e-38, 1.0742e-37, 6.0633e-38],\n", + " [1.2215e-09, 1.5288e-18, 3.3108e-18, 2.3477e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "302000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0196e-20, 3.5851e-38, 1.0332e-37, 5.8909e-38],\n", + " [1.2044e-09, 1.6113e-18, 3.3994e-18, 2.4310e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "303000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.2415e-20, 3.5997e-38, 1.0453e-37, 5.9463e-38],\n", + " [1.2197e-09, 1.5980e-18, 3.3926e-18, 2.4220e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "304000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.0759e-20, 3.5783e-38, 1.0282e-37, 5.8763e-38],\n", + " [1.2182e-09, 1.6402e-18, 3.4413e-18, 2.4665e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "305000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7332e-20, 3.4310e-38, 9.1431e-38, 5.3829e-38],\n", + " [1.1605e-09, 1.9085e-18, 3.7061e-18, 2.7230e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "306000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.9258e-20, 3.7228e-38, 1.1483e-37, 6.3949e-38],\n", + " [1.3033e-09, 1.4511e-18, 3.2609e-18, 2.2882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "307000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8797e-20, 3.7866e-38, 1.2043e-37, 6.6320e-38],\n", + " [1.3410e-09, 1.3757e-18, 3.1847e-18, 2.2144e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "308000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5762e-20, 3.5984e-38, 1.0456e-37, 5.9654e-38],\n", + " [1.2634e-09, 1.6459e-18, 3.4743e-18, 2.4881e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "309000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8232e-20, 3.5205e-38, 9.8455e-38, 5.7042e-38],\n", + " [1.2369e-09, 1.7823e-18, 3.6149e-18, 2.6224e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "310000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7071e-20, 3.5031e-38, 9.7143e-38, 5.6496e-38],\n", + " [1.2367e-09, 1.8211e-18, 3.6582e-18, 2.6626e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "311000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.5262e-20, 3.6596e-38, 1.0961e-37, 6.1931e-38],\n", + " [1.3202e-09, 1.5838e-18, 3.4327e-18, 2.4398e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "312000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8087e-20, 3.5926e-38, 1.0420e-37, 5.9645e-38],\n", + " [1.2983e-09, 1.6946e-18, 3.5513e-18, 2.5519e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "313000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5848e-20, 3.5657e-38, 1.0210e-37, 5.8774e-38],\n", + " [1.2956e-09, 1.7480e-18, 3.6112e-18, 2.6074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "314000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2425e-20, 3.5259e-38, 9.9078e-38, 5.7490e-38],\n", + " [1.2877e-09, 1.8243e-18, 3.6928e-18, 2.6844e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "315000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3139e-20, 3.4258e-38, 9.1603e-38, 5.4211e-38],\n", + " [1.2495e-09, 2.0175e-18, 3.8796e-18, 2.8673e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "316000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1244e-20, 3.4999e-38, 9.7162e-38, 5.6724e-38],\n", + " [1.2963e-09, 1.8935e-18, 3.7750e-18, 2.7591e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "317000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2532e-20, 3.5059e-38, 9.7649e-38, 5.6970e-38],\n", + " [1.3081e-09, 1.8929e-18, 3.7816e-18, 2.7628e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "318000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7510e-20, 3.5440e-38, 1.0057e-37, 5.8301e-38],\n", + " [1.3380e-09, 1.8418e-18, 3.7429e-18, 2.7207e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "319000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0515e-20, 3.6452e-38, 1.0853e-37, 6.1812e-38],\n", + " [1.3980e-09, 1.6948e-18, 3.6088e-18, 2.5855e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "320000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8598e-20, 3.5385e-38, 1.0023e-37, 5.8229e-38],\n", + " [1.3570e-09, 1.8739e-18, 3.7902e-18, 2.7609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "321000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8717e-20, 3.5310e-38, 9.9733e-38, 5.8047e-38],\n", + " [1.3650e-09, 1.8975e-18, 3.8211e-18, 2.7881e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "322000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8814e-20, 3.4295e-38, 9.2289e-38, 5.4761e-38],\n", + " [1.3262e-09, 2.0922e-18, 4.0076e-18, 2.9719e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "323000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.4115e-20, 3.4725e-38, 9.5463e-38, 5.6229e-38],\n", + " [1.3597e-09, 2.0261e-18, 3.9585e-18, 2.9181e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "324000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5332e-20, 3.4754e-38, 9.5744e-38, 5.6390e-38],\n", + " [1.3728e-09, 2.0324e-18, 3.9732e-18, 2.9293e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "325000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5792e-20, 3.4725e-38, 9.5571e-38, 5.6348e-38],\n", + " [1.3818e-09, 2.0496e-18, 3.9972e-18, 2.9501e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "326000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.8448e-20, 3.6492e-38, 1.0911e-37, 6.2366e-38],\n", + " [1.4828e-09, 1.7690e-18, 3.7428e-18, 2.6928e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "327000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0174e-20, 3.5783e-38, 1.0360e-37, 5.9999e-38],\n", + " [1.4596e-09, 1.8932e-18, 3.8720e-18, 2.8169e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "328000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9049e-20, 3.4770e-38, 9.6071e-38, 5.6686e-38],\n", + " [1.4198e-09, 2.0794e-18, 4.0524e-18, 2.9944e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "329000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.4806e-20, 3.5193e-38, 9.9248e-38, 5.8142e-38],\n", + " [1.4519e-09, 2.0143e-18, 4.0015e-18, 2.9397e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "330000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.8401e-20, 3.6184e-38, 1.0682e-37, 6.1530e-38],\n", + " [1.5138e-09, 1.8627e-18, 3.8682e-18, 2.8029e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "331000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6817e-20, 3.5963e-38, 1.0515e-37, 6.0854e-38],\n", + " [1.5185e-09, 1.9142e-18, 3.9295e-18, 2.8589e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "332000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8570e-20, 3.6017e-38, 1.0561e-37, 6.1094e-38],\n", + " [1.5330e-09, 1.9175e-18, 3.9415e-18, 2.8673e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "333000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7321e-20, 3.6542e-38, 1.0973e-37, 6.2957e-38],\n", + " [1.5749e-09, 1.8504e-18, 3.8884e-18, 2.8100e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "334000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2723e-20, 3.4568e-38, 9.5015e-38, 5.6434e-38],\n", + " [1.4844e-09, 2.1935e-18, 4.2128e-18, 3.1334e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "335000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.7423e-20, 3.5659e-38, 1.0307e-37, 6.0100e-38],\n", + " [1.5552e-09, 2.0150e-18, 4.0629e-18, 2.9768e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "336000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0894e-20, 3.5064e-38, 9.8758e-38, 5.8202e-38],\n", + " [1.5367e-09, 2.1280e-18, 4.1748e-18, 3.0863e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "337000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.9427e-20, 3.4822e-38, 9.7114e-38, 5.7506e-38],\n", + " [1.5417e-09, 2.1880e-18, 4.2416e-18, 3.1488e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "338000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.9207e-20, 3.4709e-38, 9.6378e-38, 5.7213e-38],\n", + " [1.5497e-09, 2.2227e-18, 4.2829e-18, 3.1867e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "339000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0352e-20, 3.3868e-38, 9.0509e-38, 5.4569e-38],\n", + " [1.5185e-09, 2.4043e-18, 4.4510e-18, 3.3553e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "340000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4346e-20, 3.4134e-38, 9.2399e-38, 5.5476e-38],\n", + " [1.5455e-09, 2.3654e-18, 4.4288e-18, 3.3276e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "341000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4934e-20, 3.4083e-38, 9.2089e-38, 5.5382e-38],\n", + " [1.5587e-09, 2.3952e-18, 4.4678e-18, 3.3623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "342000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9296e-20, 3.5078e-38, 9.9271e-38, 5.8720e-38],\n", + " [1.6343e-09, 2.2257e-18, 4.3375e-18, 3.2208e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "343000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.1680e-20, 3.4406e-38, 9.4585e-38, 5.6611e-38],\n", + " [1.6096e-09, 2.3611e-18, 4.4639e-18, 3.3475e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "344000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.7479e-20, 3.3955e-38, 9.1529e-38, 5.5248e-38],\n", + " [1.6015e-09, 2.4693e-18, 4.5692e-18, 3.4513e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "345000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9132e-20, 3.4744e-38, 9.7114e-38, 5.7878e-38],\n", + " [1.6656e-09, 2.3372e-18, 4.4734e-18, 3.3446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "346000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0608e-19, 3.5834e-38, 1.0506e-37, 6.1532e-38],\n", + " [1.7417e-09, 2.1610e-18, 4.3304e-18, 3.1921e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "347000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3905e-20, 3.3331e-38, 8.7618e-38, 5.3538e-38],\n", + " [1.6137e-09, 2.6487e-18, 4.7540e-18, 3.6298e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "348000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.5908e-20, 3.4215e-38, 9.3668e-38, 5.6402e-38],\n", + " [1.6790e-09, 2.4811e-18, 4.6292e-18, 3.4927e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "349000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8032e-20, 3.4999e-38, 9.9231e-38, 5.9011e-38],\n", + " [1.7401e-09, 2.3491e-18, 4.5302e-18, 3.3837e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "350000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1479e-20, 3.2824e-38, 8.4514e-38, 5.2187e-38],\n", + " [1.6304e-09, 2.8176e-18, 4.9280e-18, 3.7977e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "351000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1621e-19, 3.5965e-38, 1.0634e-37, 6.2352e-38],\n", + " [1.8326e-09, 2.2203e-18, 4.4466e-18, 3.2843e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "352000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1472e-19, 3.5732e-38, 1.0478e-37, 6.1699e-38],\n", + " [1.8405e-09, 2.2754e-18, 4.5100e-18, 3.3436e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "353000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4310e-20, 3.3526e-38, 8.9497e-38, 5.4664e-38],\n", + " [1.7260e-09, 2.7114e-18, 4.8871e-18, 3.7350e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "354000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9761e-20, 3.3835e-38, 9.1695e-38, 5.5729e-38],\n", + " [1.7601e-09, 2.6582e-18, 4.8558e-18, 3.6967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "355000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.2804e-20, 3.3937e-38, 9.2509e-38, 5.6151e-38],\n", + " [1.7850e-09, 2.6542e-18, 4.8672e-18, 3.7021e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "356000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1512e-19, 3.5273e-38, 1.0188e-37, 6.0574e-38],\n", + " [1.8917e-09, 2.4256e-18, 4.6983e-18, 3.5143e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "357000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2009e-19, 3.5447e-38, 1.0320e-37, 6.1237e-38],\n", + " [1.9243e-09, 2.4175e-18, 4.7087e-18, 3.5174e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "358000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4332e-20, 3.3650e-38, 9.0929e-38, 5.5555e-38],\n", + " [1.8315e-09, 2.7793e-18, 5.0190e-18, 3.8414e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "359000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0942e-20, 3.2508e-38, 8.3642e-38, 5.2117e-38],\n", + " [1.7801e-09, 3.0585e-18, 5.2506e-18, 4.0852e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "360000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8789e-20, 3.2988e-38, 8.6813e-38, 5.3689e-38],\n", + " [1.8318e-09, 2.9699e-18, 5.2019e-18, 4.0236e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "361000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0896e-20, 3.2264e-38, 8.2329e-38, 5.1562e-38],\n", + " [1.8031e-09, 3.1599e-18, 5.3589e-18, 4.1891e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "362000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4771e-20, 3.3125e-38, 8.7996e-38, 5.4358e-38],\n", + " [1.8890e-09, 2.9862e-18, 5.2537e-18, 4.0622e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "363000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0801e-20, 3.1930e-38, 8.0594e-38, 5.0816e-38],\n", + " [1.8333e-09, 3.2971e-18, 5.5029e-18, 4.3283e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "364000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0651e-19, 3.3606e-38, 9.1478e-38, 5.6122e-38],\n", + " [1.9721e-09, 2.9265e-18, 5.2481e-18, 4.0374e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "365000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7101e-20, 3.0434e-38, 7.2097e-38, 4.6673e-38],\n", + " [1.7815e-09, 3.7549e-18, 5.8596e-18, 4.7126e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "366000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1328e-19, 3.3775e-38, 9.2875e-38, 5.6876e-38],\n", + " [2.0267e-09, 2.9289e-18, 5.2836e-18, 4.0606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "367000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1322e-19, 3.3654e-38, 9.2171e-38, 5.6585e-38],\n", + " [2.0392e-09, 2.9760e-18, 5.3368e-18, 4.1108e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "368000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.0024e-20, 3.0315e-38, 7.1898e-38, 4.6641e-38],\n", + " [1.8291e-09, 3.8290e-18, 5.9530e-18, 4.7989e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "369000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.3922e-20, 3.1349e-38, 7.8030e-38, 4.9766e-38],\n", + " [1.9249e-09, 3.5691e-18, 5.8020e-18, 4.6138e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "370000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.2392e-20, 3.1878e-38, 8.1320e-38, 5.1432e-38],\n", + " [1.9803e-09, 3.4503e-18, 5.7357e-18, 4.5307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "371000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1486e-20, 3.1686e-38, 8.0270e-38, 5.0954e-38],\n", + " [1.9887e-09, 3.5250e-18, 5.8076e-18, 4.6025e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "372000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6412e-20, 3.1165e-38, 7.7288e-38, 4.9515e-38],\n", + " [1.9766e-09, 3.6941e-18, 5.9462e-18, 4.7496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "373000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3381e-20, 3.1538e-38, 7.9626e-38, 5.0730e-38],\n", + " [2.0288e-09, 3.6240e-18, 5.9220e-18, 4.7101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "374000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.5043e-20, 3.0770e-38, 7.5251e-38, 4.8582e-38],\n", + " [1.9985e-09, 3.8642e-18, 6.1060e-18, 4.9109e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "375000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2113e-19, 3.3075e-38, 8.9385e-38, 5.5620e-38],\n", + " [2.1870e-09, 3.2928e-18, 5.7279e-18, 4.4706e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "376000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6477e-20, 3.0624e-38, 7.4665e-38, 4.8355e-38],\n", + " [2.0324e-09, 3.9565e-18, 6.2074e-18, 5.0079e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "377000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1921e-19, 3.2700e-38, 8.7218e-38, 5.4661e-38],\n", + " [2.2090e-09, 3.4369e-18, 5.8753e-18, 4.6152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "378000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3754e-19, 3.3579e-38, 9.2941e-38, 5.7516e-38],\n", + " [2.3045e-09, 3.2697e-18, 5.7806e-18, 4.4955e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "379000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1073e-20, 3.0488e-38, 7.4373e-38, 4.8320e-38],\n", + " [2.1026e-09, 4.0751e-18, 6.3542e-18, 5.1443e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "380000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0303e-19, 3.1180e-38, 7.8547e-38, 5.0486e-38],\n", + " [2.1829e-09, 3.9091e-18, 6.2713e-18, 5.0341e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "381000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9697e-20, 3.0792e-38, 7.6457e-38, 4.9471e-38],\n", + " [2.1825e-09, 4.0490e-18, 6.3884e-18, 5.1579e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "382000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2136e-19, 3.2022e-38, 8.3904e-38, 5.3256e-38],\n", + " [2.3026e-09, 3.7373e-18, 6.2022e-18, 4.9304e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "383000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.1950e-20, 2.8835e-38, 6.5703e-38, 4.3835e-38],\n", + " [2.0984e-09, 4.6650e-18, 6.8189e-18, 5.6462e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "384000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8818e-20, 2.9233e-38, 6.8117e-38, 4.5170e-38],\n", + " [2.1618e-09, 4.5752e-18, 6.7961e-18, 5.6019e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "385000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4646e-20, 2.8645e-38, 6.5053e-38, 4.3553e-38],\n", + " [2.1486e-09, 4.7919e-18, 6.9533e-18, 5.7776e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "386000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.9916e-20, 2.8931e-38, 6.6773e-38, 4.4518e-38],\n", + " [2.1986e-09, 4.7327e-18, 6.9455e-18, 5.7535e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "387000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0900e-19, 3.0368e-38, 7.5033e-38, 4.8963e-38],\n", + " [2.3289e-09, 4.3408e-18, 6.7289e-18, 5.4804e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "388000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.2784e-20, 2.8822e-38, 6.6464e-38, 4.4414e-38],\n", + " [2.2448e-09, 4.8277e-18, 7.0529e-18, 5.8567e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "389000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1292e-19, 3.0264e-38, 7.4760e-38, 4.8896e-38],\n", + " [2.3827e-09, 4.4313e-18, 6.8397e-18, 5.5842e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "390000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.6563e-20, 2.7871e-38, 6.1737e-38, 4.1893e-38],\n", + " [2.2315e-09, 5.2050e-18, 7.3251e-18, 6.1619e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "391000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6848e-20, 2.7658e-38, 6.0879e-38, 4.1445e-38],\n", + " [2.2496e-09, 5.3058e-18, 7.4108e-18, 6.2524e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "392000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.5932e-20, 2.8289e-38, 6.4307e-38, 4.3360e-38],\n", + " [2.3244e-09, 5.1197e-18, 7.3313e-18, 6.1393e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "393000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4651e-20, 2.6153e-38, 5.3619e-38, 3.7438e-38],\n", + " [2.1861e-09, 5.9667e-18, 7.8270e-18, 6.7430e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "394000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.5584e-20, 2.6976e-38, 5.7858e-38, 3.9851e-38],\n", + " [2.2842e-09, 5.6624e-18, 7.6940e-18, 6.5583e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "395000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1683e-19, 2.9245e-38, 7.0068e-38, 4.6609e-38],\n", + " [2.5075e-09, 4.9293e-18, 7.3207e-18, 6.0707e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "396000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.2599e-20, 2.7168e-38, 5.9184e-38, 4.0654e-38],\n", + " [2.3665e-09, 5.6617e-18, 7.7580e-18, 6.6029e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "397000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3223e-19, 2.9871e-38, 7.4023e-38, 4.8811e-38],\n", + " [2.6284e-09, 4.8048e-18, 7.3062e-18, 6.0202e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "398000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9470e-20, 2.7307e-38, 6.0218e-38, 4.1301e-38],\n", + " [2.4486e-09, 5.6964e-18, 7.8477e-18, 6.6761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "399000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4603e-19, 3.0292e-38, 7.6869e-38, 5.0417e-38],\n", + " [2.7390e-09, 4.7561e-18, 7.3420e-18, 6.0278e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "400000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0153e-19, 2.7013e-38, 5.9134e-38, 4.0753e-38],\n", + " [2.4985e-09, 5.8822e-18, 8.0171e-18, 6.8512e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "401000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.0615e-20, 2.5905e-38, 5.3870e-38, 3.7803e-38],\n", + " [2.4395e-09, 6.3782e-18, 8.3117e-18, 7.2093e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "402000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0276e-19, 2.6649e-38, 5.7695e-38, 4.0010e-38],\n", + " [2.5444e-09, 6.1119e-18, 8.2137e-18, 7.0597e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "403000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6345e-20, 2.5987e-38, 5.4352e-38, 3.8176e-38],\n", + " [2.5200e-09, 6.4883e-18, 8.4521e-18, 7.3421e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "404000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3978e-20, 2.6607e-38, 5.1535e-38, 3.7150e-38],\n", + " [2.4183e-09, 7.2070e-18, 8.8352e-18, 7.8281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "405000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0882e-19, 2.6412e-38, 5.7077e-38, 3.9764e-38],\n", + " [2.6442e-09, 6.3502e-18, 8.4572e-18, 7.3042e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "406000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2583e-19, 2.7367e-38, 6.2106e-38, 4.2630e-38],\n", + " [2.7708e-09, 6.0101e-18, 8.3152e-18, 7.0990e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "407000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0270e-19, 2.6501e-38, 5.4593e-38, 3.8731e-38],\n", + " [2.6293e-09, 6.9090e-18, 8.8218e-18, 7.7313e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "408000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3192e-19, 2.7141e-38, 6.1472e-38, 4.2364e-38],\n", + " [2.8620e-09, 6.2135e-18, 8.5273e-18, 7.3105e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "409000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0196e-19, 2.6898e-38, 5.3760e-38, 3.8630e-38],\n", + " [2.6553e-09, 7.3518e-18, 9.1267e-18, 8.0817e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "410000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.7543e-20, 2.7219e-38, 5.2628e-38, 3.8275e-38],\n", + " [2.6302e-09, 7.7441e-18, 9.3520e-18, 8.3595e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "411000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0320e-19, 2.7227e-38, 5.3501e-38, 3.8757e-38],\n", + " [2.6942e-09, 7.6773e-18, 9.3671e-18, 8.3510e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "412000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1583e-20, 2.8604e-38, 4.6484e-38, 3.5857e-38],\n", + " [2.3973e-09, 9.8116e-18, 1.0324e-17, 9.6523e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "413000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0040e-19, 2.7723e-38, 5.2364e-38, 3.8534e-38],\n", + " [2.7016e-09, 8.2649e-18, 9.7354e-18, 8.7891e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "414000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1532e-19, 2.7480e-38, 5.4901e-38, 3.9726e-38],\n", + " [2.8446e-09, 7.8041e-18, 9.5764e-18, 8.5400e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "415000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0113e-19, 2.8071e-38, 5.1977e-38, 3.8600e-38],\n", + " [2.7373e-09, 8.6643e-18, 1.0007e-17, 9.1030e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "416000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.5741e-20, 2.8440e-38, 5.0612e-38, 3.8130e-38],\n", + " [2.7035e-09, 9.2098e-18, 1.0292e-17, 9.4679e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "417000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3090e-19, 2.7713e-38, 5.6783e-38, 4.0927e-38],\n", + " [3.0182e-09, 7.8525e-18, 9.7560e-18, 8.6844e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "418000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4901e-19, 2.7548e-38, 5.9410e-38, 4.2178e-38],\n", + " [3.1699e-09, 7.4735e-18, 9.6342e-18, 8.4825e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "419000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2654e-19, 2.8155e-38, 5.5343e-38, 4.0545e-38],\n", + " [3.0185e-09, 8.4581e-18, 1.0130e-17, 9.1355e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "420000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2744e-19, 2.8313e-38, 5.5165e-38, 4.0590e-38],\n", + " [3.0427e-09, 8.6520e-18, 1.0268e-17, 9.2935e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "421000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.9341e-20, 2.9273e-38, 4.9782e-38, 3.8340e-38],\n", + " [2.8175e-09, 1.0349e-17, 1.1034e-17, 1.0339e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "422000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0189e-19, 2.9359e-38, 4.9991e-38, 3.8535e-38],\n", + " [2.8558e-09, 1.0443e-17, 1.1122e-17, 1.0432e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "423000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0751e-19, 2.9366e-38, 5.0803e-38, 3.9008e-38],\n", + " [2.9214e-09, 1.0350e-17, 1.1136e-17, 1.0418e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "424000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0323e-19, 2.9687e-38, 4.9645e-38, 3.8606e-38],\n", + " [2.9003e-09, 1.0932e-17, 1.1428e-17, 1.0798e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "425000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.7811e-20, 3.0315e-38, 4.6344e-38, 3.7150e-38],\n", + " [2.7605e-09, 1.2311e-17, 1.1987e-17, 1.1592e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "426000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3250e-19, 2.9378e-38, 5.4151e-38, 4.0923e-38],\n", + " [3.1899e-09, 9.9715e-18, 1.1177e-17, 1.0346e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "427000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0716e-19, 3.0168e-38, 4.9486e-38, 3.8897e-38],\n", + " [2.9877e-09, 1.1618e-17, 1.1878e-17, 1.1328e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "428000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8183e-20, 3.0924e-38, 4.5561e-38, 3.7134e-38],\n", + " [2.8139e-09, 1.3383e-17, 1.2570e-17, 1.2323e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "429000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2214e-19, 3.0245e-38, 5.1454e-38, 4.0101e-38],\n", + " [3.1617e-09, 1.1437e-17, 1.1959e-17, 1.1343e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "430000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1144e-19, 3.0628e-38, 4.9344e-38, 3.9186e-38],\n", + " [3.0792e-09, 1.2323e-17, 1.2335e-17, 1.1869e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "431000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.1900e-20, 3.1597e-38, 4.3284e-38, 3.6282e-38],\n", + " [2.7907e-09, 1.5123e-17, 1.3334e-17, 1.3366e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "432000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.2642e-20, 3.1732e-38, 4.3130e-38, 3.6299e-38],\n", + " [2.8150e-09, 1.5448e-17, 1.3505e-17, 1.3585e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "433000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.5930e-20, 3.1556e-38, 4.5401e-38, 3.7595e-38],\n", + " [2.9812e-09, 1.4662e-17, 1.3347e-17, 1.3269e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "434000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3448e-19, 3.0812e-38, 5.1647e-38, 4.0777e-38],\n", + " [3.3597e-09, 1.2372e-17, 1.2631e-17, 1.2123e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "435000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.3553e-20, 3.1875e-38, 4.4395e-38, 3.7257e-38],\n", + " [2.9831e-09, 1.5542e-17, 1.3743e-17, 1.3806e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "436000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3086e-19, 4.1341e-38, 6.2034e-38, 5.0956e-38],\n", + " [3.5506e-09, 1.8225e-17, 1.6879e-17, 1.6745e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "437000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.9005e-20, 3.2484e-38, 3.8352e-38, 3.4055e-38],\n", + " [2.6791e-09, 1.8361e-17, 1.4313e-17, 1.4979e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "438000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1615e-19, 3.8388e-38, 5.4409e-38, 4.5665e-38],\n", + " [3.3753e-09, 1.8281e-17, 1.6187e-17, 1.6307e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "439000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2872e-19, 3.9167e-38, 5.7262e-38, 4.7668e-38],\n", + " [3.5357e-09, 1.8274e-17, 1.6505e-17, 1.6539e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "440000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4538e-19, 4.0239e-38, 6.1099e-38, 5.0343e-38],\n", + " [3.7349e-09, 1.8270e-17, 1.6912e-17, 1.6835e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "441000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9276e-20, 3.4439e-38, 4.5128e-38, 3.9045e-38],\n", + " [3.1592e-09, 1.8336e-17, 1.5248e-17, 1.5700e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "442000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0633e-19, 3.4757e-38, 4.6424e-38, 3.9985e-38],\n", + " [3.2592e-09, 1.8330e-17, 1.5421e-17, 1.5833e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "443000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1884e-19, 3.5567e-38, 4.9159e-38, 4.1952e-38],\n", + " [3.4265e-09, 1.8316e-17, 1.5754e-17, 1.6079e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "444000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4227e-20, 3.0873e-38, 3.7350e-38, 3.3316e-38],\n", + " [2.9464e-09, 1.8378e-17, 1.4345e-17, 1.5095e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "445000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3592e-19, 3.6115e-38, 5.1777e-38, 4.3818e-38],\n", + " [3.6429e-09, 1.8304e-17, 1.6089e-17, 1.6337e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "446000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.4691e-20, 2.9992e-38, 3.5900e-38, 3.2236e-38],\n", + " [2.9590e-09, 1.8400e-17, 1.4195e-17, 1.5015e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "447000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6503e-20, 3.0966e-38, 3.8672e-38, 3.4305e-38],\n", + " [3.1370e-09, 1.8371e-17, 1.4580e-17, 1.5299e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "448000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6556e-19, 3.6916e-38, 5.5943e-38, 4.6725e-38],\n", + " [3.9835e-09, 1.8230e-17, 1.6572e-17, 1.6692e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "449000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1580e-19, 3.1981e-38, 4.2150e-38, 3.6877e-38],\n", + " [3.4061e-09, 1.8350e-17, 1.5067e-17, 1.5671e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "450000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7634e-20, 2.9613e-38, 3.6428e-38, 3.2629e-38],\n", + " [3.1620e-09, 1.8389e-17, 1.4347e-17, 1.5168e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "451000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1558e-20, 2.4811e-38, 2.5597e-38, 2.4291e-38],\n", + " [2.5812e-09, 1.8524e-17, 1.2721e-17, 1.3998e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "452000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1574e-20, 2.7996e-38, 3.3201e-38, 3.0190e-38],\n", + " [3.0794e-09, 1.8414e-17, 1.3936e-17, 1.4896e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "453000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.6942e-20, 2.4846e-38, 2.6165e-38, 2.4737e-38],\n", + " [2.6831e-09, 1.8510e-17, 1.2855e-17, 1.4115e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "454000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6544e-20, 2.5748e-38, 2.8351e-38, 2.6456e-38],\n", + " [2.8485e-09, 1.8477e-17, 1.3227e-17, 1.4397e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "455000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8156e-20, 2.6651e-38, 3.0717e-38, 2.8291e-38],\n", + " [3.0344e-09, 1.8449e-17, 1.3616e-17, 1.4693e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "456000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0605e-19, 2.7959e-38, 3.4264e-38, 3.0999e-38],\n", + " [3.2953e-09, 1.8401e-17, 1.4156e-17, 1.5095e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "457000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1674e-20, 2.2964e-38, 2.2883e-38, 2.2148e-38],\n", + " [2.5962e-09, 1.8663e-17, 1.2359e-17, 1.3809e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "458000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.1965e-20, 2.3760e-38, 2.4935e-38, 2.3778e-38],\n", + " [2.7825e-09, 1.8581e-17, 1.2747e-17, 1.4099e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "459000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8154e-20, 2.2954e-38, 2.3446e-38, 2.2589e-38],\n", + " [2.7188e-09, 1.8617e-17, 1.2500e-17, 1.3929e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "460000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3956e-20, 2.3259e-38, 2.4348e-38, 2.3311e-38],\n", + " [2.8210e-09, 1.8591e-17, 1.2680e-17, 1.4072e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "461000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.6049e-20, 2.5104e-38, 2.8755e-38, 2.6790e-38],\n", + " [3.1688e-09, 1.8520e-17, 1.3441e-17, 1.4646e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "462000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4858e-20, 2.1779e-38, 2.1460e-38, 2.1000e-38],\n", + " [2.6661e-09, 1.8729e-17, 1.2186e-17, 1.3737e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "463000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.4641e-20, 2.1458e-38, 2.0991e-38, 2.0617e-38],\n", + " [2.6643e-09, 1.8748e-17, 1.2111e-17, 1.3692e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "464000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.5715e-20, 2.2277e-38, 2.3008e-38, 2.2246e-38],\n", + " [2.8597e-09, 1.8656e-17, 1.2511e-17, 1.3994e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "465000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.2306e-20, 1.9630e-38, 1.7481e-38, 1.7744e-38],\n", + " [2.4294e-09, 1.9008e-17, 1.1424e-17, 1.3224e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "466000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.1338e-20, 2.1230e-38, 2.1160e-38, 2.0755e-38],\n", + " [2.7906e-09, 1.8746e-17, 1.2202e-17, 1.3793e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "467000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2251e-20, 2.1085e-38, 2.1008e-38, 2.0635e-38],\n", + " [2.8084e-09, 1.8765e-17, 1.2191e-17, 1.3797e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "468000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.4275e-20, 2.0108e-38, 1.9060e-38, 1.9043e-38],\n", + " [2.6685e-09, 1.8885e-17, 1.1814e-17, 1.3533e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "469000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2569e-20, 1.7448e-38, 1.3995e-38, 1.4776e-38],\n", + " [2.2248e-09, 1.9299e-17, 1.0664e-17, 1.2705e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "470000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5054e-20, 1.9621e-38, 1.8459e-38, 1.8543e-38],\n", + " [2.6870e-09, 1.8905e-17, 1.1718e-17, 1.3481e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "471000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.0021e-20, 2.1430e-38, 2.2637e-38, 2.1958e-38],\n", + " [3.1047e-09, 1.8699e-17, 1.2571e-17, 1.4120e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "472000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6715e-20, 1.8316e-38, 1.6141e-38, 1.6605e-38],\n", + " [2.5323e-09, 1.9079e-17, 1.1232e-17, 1.3148e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "473000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6400e-20, 1.8054e-38, 1.5774e-38, 1.6297e-38],\n", + " [2.5283e-09, 1.9124e-17, 1.1167e-17, 1.3114e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "474000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0362e-20, 1.8224e-38, 1.6265e-38, 1.6711e-38],\n", + " [2.6075e-09, 1.9083e-17, 1.1298e-17, 1.3219e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "475000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3762e-20, 1.9911e-38, 2.0059e-38, 1.9857e-38],\n", + " [3.0163e-09, 1.8787e-17, 1.2128e-17, 1.3827e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "476000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.3746e-20, 1.8104e-38, 1.6338e-38, 1.6767e-38],\n", + " [2.6750e-09, 1.9060e-17, 1.1342e-17, 1.3264e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "477000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7673e-20, 2.0442e-38, 2.1580e-38, 2.1100e-38],\n", + " [3.2322e-09, 1.8724e-17, 1.2456e-17, 1.4089e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "478000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7732e-20, 1.7191e-38, 1.4771e-38, 1.5437e-38],\n", + " [2.5637e-09, 1.9215e-17, 1.0996e-17, 1.3030e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "479000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0942e-20, 1.6411e-38, 1.3361e-38, 1.4224e-38],\n", + " [2.4272e-09, 1.9398e-17, 1.0655e-17, 1.2795e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "480000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4715e-20, 1.6525e-38, 1.3743e-38, 1.4555e-38],\n", + " [2.5074e-09, 1.9345e-17, 1.0771e-17, 1.2890e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "481000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3111e-20, 1.6225e-38, 1.3275e-38, 1.4149e-38],\n", + " [2.4761e-09, 1.9409e-17, 1.0662e-17, 1.2820e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "482000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6041e-20, 1.6266e-38, 1.3511e-38, 1.4350e-38],\n", + " [2.5378e-09, 1.9366e-17, 1.0738e-17, 1.2882e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "483000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9229e-20, 1.7110e-38, 1.5350e-38, 1.5927e-38],\n", + " [2.7886e-09, 1.9148e-17, 1.1213e-17, 1.3235e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "484000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8334e-20, 1.5260e-38, 1.1851e-38, 1.2891e-38],\n", + " [2.3797e-09, 1.9582e-17, 1.0307e-17, 1.2579e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "485000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7499e-20, 1.5878e-38, 1.3124e-38, 1.4011e-38],\n", + " [2.5719e-09, 1.9412e-17, 1.0675e-17, 1.2861e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "486000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6157e-20, 1.5132e-38, 1.1457e-38, 1.2601e-38],\n", + " [2.3497e-09, 2.0173e-17, 1.0435e-17, 1.2825e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "487000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3284e-20, 1.7169e-38, 1.5469e-38, 1.6120e-38],\n", + " [2.8876e-09, 1.9723e-17, 1.1564e-17, 1.3685e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "488000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5848e-20, 1.6440e-38, 1.4141e-38, 1.4973e-38],\n", + " [2.7561e-09, 1.9863e-17, 1.1242e-17, 1.3456e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "489000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0230e-20, 1.6780e-38, 1.4737e-38, 1.5526e-38],\n", + " [2.8458e-09, 2.0044e-17, 1.1520e-17, 1.3735e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "490000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.1454e-20, 1.5920e-38, 1.3199e-38, 1.4183e-38],\n", + " [2.6844e-09, 2.0216e-17, 1.1121e-17, 1.3449e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "491000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.7182e-20, 1.8133e-38, 1.7856e-38, 1.8193e-38],\n", + " [3.2899e-09, 1.9782e-17, 1.2310e-17, 1.4347e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "492000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9765e-20, 1.6203e-38, 1.3973e-38, 1.4864e-38],\n", + " [2.8434e-09, 2.0142e-17, 1.1366e-17, 1.3654e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "493000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7051e-20, 1.5984e-38, 1.3523e-38, 1.4494e-38],\n", + " [2.8030e-09, 2.0394e-17, 1.1352e-17, 1.3705e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "494000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6668e-20, 1.6742e-38, 1.4858e-38, 1.5711e-38],\n", + " [2.9876e-09, 2.0589e-17, 1.1875e-17, 1.4195e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "495000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4379e-20, 1.4108e-38, 1.0087e-38, 1.1440e-38],\n", + " [2.3490e-09, 2.1303e-17, 1.0491e-17, 1.3175e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "496000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5369e-20, 1.5724e-38, 1.3004e-38, 1.4101e-38],\n", + " [2.7947e-09, 2.0987e-17, 1.1482e-17, 1.3968e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "497000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8584e-20, 1.4408e-38, 1.0580e-38, 1.1931e-38],\n", + " [2.4572e-09, 2.1556e-17, 1.0816e-17, 1.3524e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "498000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0408e-20, 1.6540e-38, 1.4666e-38, 1.5603e-38],\n", + " [3.0749e-09, 2.1036e-17, 1.2081e-17, 1.4504e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "499000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4137e-20, 1.4490e-38, 1.0971e-38, 1.2287e-38],\n", + " [2.5818e-09, 2.1471e-17, 1.0976e-17, 1.3663e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "500000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.8285e-20, 1.4670e-38, 1.1377e-38, 1.2660e-38],\n", + " [2.6695e-09, 2.1419e-17, 1.1126e-17, 1.3790e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "501000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3469e-20, 1.4136e-38, 1.0550e-38, 1.1899e-38],\n", + " [2.5708e-09, 2.1536e-17, 1.0860e-17, 1.3592e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "502000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8226e-20, 1.5176e-38, 1.2397e-38, 1.3606e-38],\n", + " [2.8738e-09, 2.1490e-17, 1.1572e-17, 1.4204e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "503000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2682e-20, 1.5580e-38, 1.2993e-38, 1.4194e-38],\n", + " [2.9711e-09, 2.1835e-17, 1.1950e-17, 1.4612e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "504000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3373e-20, 1.5594e-38, 1.3006e-38, 1.4225e-38],\n", + " [2.9909e-09, 2.2002e-17, 1.2040e-17, 1.4731e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "505000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1594e-20, 1.5681e-38, 1.2922e-38, 1.4213e-38],\n", + " [2.9781e-09, 2.2562e-17, 1.2266e-17, 1.5054e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "506000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3863e-20, 1.5627e-38, 1.2954e-38, 1.4243e-38],\n", + " [3.0220e-09, 2.2569e-17, 1.2297e-17, 1.5094e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "507000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5260e-20, 1.3292e-38, 9.0677e-39, 1.0620e-38],\n", + " [2.4326e-09, 2.3122e-17, 1.0917e-17, 1.4012e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "508000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6953e-20, 1.5606e-38, 1.3014e-38, 1.4327e-38],\n", + " [3.0912e-09, 2.2826e-17, 1.2471e-17, 1.5320e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "509000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.4250e-20, 1.6392e-38, 1.4677e-38, 1.5829e-38],\n", + " [3.3849e-09, 2.2674e-17, 1.3010e-17, 1.5761e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "510000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0327e-20, 1.4056e-38, 1.0553e-38, 1.2045e-38],\n", + " [2.7781e-09, 2.3082e-17, 1.1642e-17, 1.4676e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "511000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.5463e-20, 1.3731e-38, 9.9471e-39, 1.1498e-38],\n", + " [2.6852e-09, 2.3454e-17, 1.1532e-17, 1.4663e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "512000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.8046e-20, 1.5393e-38, 1.2684e-38, 1.4101e-38],\n", + " [3.1431e-09, 2.3564e-17, 1.2741e-17, 1.5750e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "513000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0059e-20, 1.5333e-38, 1.2691e-38, 1.4109e-38],\n", + " [3.1811e-09, 2.3574e-17, 1.2763e-17, 1.5782e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "514000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6201e-20, 1.4952e-38, 1.2097e-38, 1.3559e-38],\n", + " [3.1137e-09, 2.3633e-17, 1.2569e-17, 1.5635e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "515000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1515e-20, 1.3805e-38, 1.0233e-38, 1.1806e-38],\n", + " [2.8327e-09, 2.3854e-17, 1.1888e-17, 1.5093e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "516000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6649e-20, 1.3557e-38, 9.6966e-39, 1.1336e-38],\n", + " [2.7458e-09, 2.4422e-17, 1.1873e-17, 1.5205e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "517000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8502e-20, 1.4124e-38, 1.0805e-38, 1.2387e-38],\n", + " [2.9902e-09, 2.4211e-17, 1.2331e-17, 1.5581e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "518000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8773e-20, 1.4030e-38, 1.0697e-38, 1.2295e-38],\n", + " [3.0013e-09, 2.4344e-17, 1.2357e-17, 1.5642e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "519000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8375e-20, 1.3164e-38, 9.3735e-39, 1.1023e-38],\n", + " [2.7915e-09, 2.4519e-17, 1.1823e-17, 1.5213e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "520000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.4362e-20, 1.9613e-38, 1.4929e-38, 1.7209e-38],\n", + " [3.4419e-09, 3.2442e-17, 1.6331e-17, 2.0753e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "521000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1357e-20, 1.5447e-38, 1.0729e-38, 1.2753e-38],\n", + " [2.9109e-09, 2.8055e-17, 1.3312e-17, 1.7242e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "522000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1429e-19, 2.3343e-38, 1.9398e-38, 2.1836e-38],\n", + " [4.0389e-09, 3.6341e-17, 1.9393e-17, 2.4263e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "523000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0110e-20, 1.6348e-38, 1.1839e-38, 1.3949e-38],\n", + " [3.1340e-09, 2.9353e-17, 1.4376e-17, 1.8483e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "524000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1155e-20, 1.4360e-38, 9.9852e-39, 1.1941e-38],\n", + " [2.9087e-09, 2.7093e-17, 1.2907e-17, 1.6753e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "525000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2171e-20, 1.4116e-38, 9.8627e-39, 1.1800e-38],\n", + " [2.9305e-09, 2.6844e-17, 1.2828e-17, 1.6652e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "526000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4634e-20, 1.4013e-38, 9.8940e-39, 1.1819e-38],\n", + " [2.9823e-09, 2.6701e-17, 1.2830e-17, 1.6640e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "527000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5331e-20, 1.3707e-38, 9.7019e-39, 1.1600e-38],\n", + " [2.9915e-09, 2.6320e-17, 1.2653e-17, 1.6420e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "528000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6823e-20, 1.6371e-38, 1.2570e-38, 1.4670e-38],\n", + " [3.4707e-09, 2.9405e-17, 1.4902e-17, 1.9045e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "529000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.4874e-20, 1.1655e-38, 7.8382e-39, 9.5533e-39],\n", + " [2.7235e-09, 2.3857e-17, 1.1087e-17, 1.4562e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "530000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.4594e-20, 1.1527e-38, 7.7521e-39, 9.4641e-39],\n", + " [2.7217e-09, 2.3799e-17, 1.1082e-17, 1.4560e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "531000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2859e-20, 1.0951e-38, 7.2901e-39, 8.9428e-39],\n", + " [2.6695e-09, 2.3049e-17, 1.0650e-17, 1.4036e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "532000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1193e-19, 1.7770e-38, 1.4649e-38, 1.6820e-38],\n", + " [3.9441e-09, 3.1018e-17, 1.6432e-17, 2.0784e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "533000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0822e-20, 1.1624e-38, 8.0731e-39, 9.8071e-39],\n", + " [2.8797e-09, 2.4093e-17, 1.1481e-17, 1.5018e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "534000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4115e-20, 9.0448e-39, 5.7180e-39, 7.1705e-39],\n", + " [2.4273e-09, 2.0654e-17, 9.2471e-18, 1.2343e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "535000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1320e-20, 9.9320e-39, 6.5673e-39, 8.1304e-39],\n", + " [2.6314e-09, 2.1949e-17, 1.0135e-17, 1.3410e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "536000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6477e-20, 1.2620e-38, 9.3530e-39, 1.1185e-38],\n", + " [3.2340e-09, 2.5399e-17, 1.2612e-17, 1.6330e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "537000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.5613e-20, 9.8859e-39, 6.6808e-39, 8.2392e-39],\n", + " [2.7310e-09, 2.1851e-17, 1.0212e-17, 1.3481e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "538000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4965e-20, 1.1021e-38, 7.8110e-39, 9.5039e-39],\n", + " [2.9770e-09, 2.3535e-17, 1.1390e-17, 1.4890e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "539000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.0194e-20, 1.0176e-38, 7.0486e-39, 8.6521e-39],\n", + " [2.8538e-09, 2.2398e-17, 1.0669e-17, 1.4026e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "540000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8022e-20, 8.5363e-39, 5.5351e-39, 6.9484e-39],\n", + " [2.5303e-09, 2.0104e-17, 9.1649e-18, 1.2222e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "541000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9835e-20, 9.5671e-39, 6.6058e-39, 8.1421e-39],\n", + " [2.8310e-09, 2.1534e-17, 1.0214e-17, 1.3465e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "542000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6352e-20, 1.1161e-38, 8.2656e-39, 9.9768e-39],\n", + " [3.2182e-09, 2.3733e-17, 1.1787e-17, 1.5332e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "543000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.8566e-20, 1.1270e-38, 8.4215e-39, 1.0152e-38],\n", + " [3.2723e-09, 2.3976e-17, 1.1999e-17, 1.5585e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "544000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0303e-20, 7.0605e-39, 4.3524e-39, 5.5833e-39],\n", + " [2.3043e-09, 1.7996e-17, 7.9459e-18, 1.0733e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "545000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.3314e-20, 7.1784e-39, 4.5140e-39, 5.7633e-39],\n", + " [2.3866e-09, 1.8165e-17, 8.1152e-18, 1.0930e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "546000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7205e-20, 8.3930e-39, 5.7154e-39, 7.1247e-39],\n", + " [2.7537e-09, 1.9970e-17, 9.3861e-18, 1.2452e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "547000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6468e-20, 8.4168e-39, 5.7253e-39, 7.1489e-39],\n", + " [2.7497e-09, 2.0159e-17, 9.5080e-18, 1.2611e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "548000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8882e-20, 7.4286e-39, 4.8423e-39, 6.1386e-39],\n", + " [2.5437e-09, 1.8663e-17, 8.5529e-18, 1.1455e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "549000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6716e-20, 8.1504e-39, 5.5517e-39, 6.9487e-39],\n", + " [2.7537e-09, 1.9821e-17, 9.3622e-18, 1.2430e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "550000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0907e-20, 9.1767e-39, 6.6569e-39, 8.1819e-39],\n", + " [3.0864e-09, 2.1301e-17, 1.0465e-17, 1.3740e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "551000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9989e-20, 8.9467e-39, 6.4705e-39, 7.9752e-39],\n", + " [3.0675e-09, 2.1039e-17, 1.0328e-17, 1.3577e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "552000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9149e-20, 5.9619e-39, 3.6458e-39, 4.7444e-39],\n", + " [2.2606e-09, 1.6404e-17, 7.2184e-18, 9.8195e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "553000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1471e-19, 1.1940e-38, 9.9234e-39, 1.1743e-38],\n", + " [3.9574e-09, 2.5133e-17, 1.3468e-17, 1.7266e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "554000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4887e-20, 5.2174e-39, 3.0825e-39, 4.0689e-39],\n", + " [2.1315e-09, 1.5238e-17, 6.5762e-18, 9.0167e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "555000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8405e-20, 5.4667e-39, 3.3210e-39, 4.3511e-39],\n", + " [2.2284e-09, 1.5574e-17, 6.8160e-18, 9.3095e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "556000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5462e-20, 5.9676e-39, 3.8042e-39, 4.9152e-39],\n", + " [2.4304e-09, 1.6438e-17, 7.4202e-18, 1.0045e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "557000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2865e-20, 7.1855e-39, 5.0252e-39, 6.3141e-39],\n", + " [2.8719e-09, 1.8401e-17, 8.8109e-18, 1.1720e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "558000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5917e-20, 6.5661e-39, 4.4420e-39, 5.6476e-39],\n", + " [2.7027e-09, 1.7452e-17, 8.1863e-18, 1.0966e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "559000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2192e-20, 6.2535e-39, 4.1519e-39, 5.3173e-39],\n", + " [2.6132e-09, 1.7015e-17, 7.9016e-18, 1.0626e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "560000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1721e-20, 6.8306e-39, 4.7562e-39, 6.0067e-39],\n", + " [2.8471e-09, 1.7949e-17, 8.5894e-18, 1.1450e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "561000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.5814e-20, 8.4278e-39, 6.4472e-39, 7.9200e-39],\n", + " [3.3873e-09, 2.0518e-17, 1.0447e-17, 1.3682e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "562000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6515e-20, 5.5296e-39, 3.5536e-39, 4.6182e-39],\n", + " [2.4613e-09, 1.5876e-17, 7.2320e-18, 9.8058e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "563000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9335e-20, 4.8941e-39, 2.9976e-39, 3.9602e-39],\n", + " [2.2545e-09, 1.4751e-17, 6.5145e-18, 8.9238e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "564000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.0126e-20, 6.2901e-39, 4.3501e-39, 5.5370e-39],\n", + " [2.8073e-09, 1.7185e-17, 8.2034e-18, 1.0976e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "565000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0682e-20, 5.5688e-39, 3.6680e-39, 4.7471e-39],\n", + " [2.5703e-09, 1.5994e-17, 7.4062e-18, 1.0010e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "566000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7466e-20, 5.8841e-39, 4.0160e-39, 5.1466e-39],\n", + " [2.7382e-09, 1.6528e-17, 7.8241e-18, 1.0510e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "567000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9286e-20, 6.5337e-39, 4.6984e-39, 5.9298e-39],\n", + " [3.0138e-09, 1.7622e-17, 8.6189e-18, 1.1470e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "568000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.3999e-20, 5.3822e-39, 3.6025e-39, 4.6570e-39],\n", + " [2.6401e-09, 1.5633e-17, 7.2943e-18, 9.8535e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "569000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.7363e-20, 6.8103e-39, 5.0539e-39, 6.3346e-39],\n", + " [3.1922e-09, 1.8151e-17, 9.0683e-18, 1.2009e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "570000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3104e-20, 5.1923e-39, 3.4613e-39, 4.4921e-39],\n", + " [2.6185e-09, 1.5353e-17, 7.1547e-18, 9.6825e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "571000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6589e-20, 4.7295e-39, 3.0378e-39, 3.9940e-39],\n", + " [2.4478e-09, 1.4538e-17, 6.6204e-18, 9.0297e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "572000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1379e-20, 4.3170e-39, 2.6798e-39, 3.5659e-39],\n", + " [2.3006e-09, 1.3770e-17, 6.1359e-18, 8.4307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "573000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5470e-20, 4.4895e-39, 2.8619e-39, 3.7808e-39],\n", + " [2.4121e-09, 1.4094e-17, 6.3840e-18, 8.7320e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "574000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2401e-20, 5.4285e-39, 3.7885e-39, 4.8699e-39],\n", + " [2.8442e-09, 1.5856e-17, 7.6171e-18, 1.0239e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "575000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6676e-20, 6.1002e-39, 4.5094e-39, 5.7000e-39],\n", + " [3.1611e-09, 1.7029e-17, 8.4798e-18, 1.1282e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "576000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.2900e-20, 4.7056e-39, 3.1327e-39, 4.0974e-39],\n", + " [2.6054e-09, 1.4546e-17, 6.7780e-18, 9.2075e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "577000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1670e-20, 4.6025e-39, 3.0461e-39, 3.9971e-39],\n", + " [2.5782e-09, 1.4405e-17, 6.6990e-18, 9.1128e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "578000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1490e-20, 5.0420e-39, 3.5042e-39, 4.5335e-39],\n", + " [2.8176e-09, 1.5226e-17, 7.3005e-18, 9.8446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "579000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3179e-20, 4.4764e-39, 2.9830e-39, 3.9152e-39],\n", + " [2.6072e-09, 1.4146e-17, 6.5963e-18, 8.9756e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "580000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.7363e-20, 4.0340e-39, 2.5978e-39, 3.4522e-39],\n", + " [2.4484e-09, 1.3263e-17, 6.0423e-18, 8.2877e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "581000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9277e-20, 5.1038e-39, 3.6621e-39, 4.7098e-39],\n", + " [2.9848e-09, 1.5348e-17, 7.4986e-18, 1.0075e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "582000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6064e-20, 3.9342e-39, 2.5183e-39, 3.3607e-39],\n", + " [2.4220e-09, 1.3156e-17, 5.9901e-18, 8.2282e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "583000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2272e-20, 4.2448e-39, 2.8200e-39, 3.7234e-39],\n", + " [2.5905e-09, 1.3822e-17, 6.4562e-18, 8.8045e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "584000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.7049e-20, 5.9052e-39, 4.5345e-39, 5.7302e-39],\n", + " [3.3870e-09, 1.7020e-17, 8.7414e-18, 1.1594e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "585000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6289e-20, 4.3138e-39, 2.9273e-39, 3.8494e-39],\n", + " [2.6931e-09, 1.4019e-17, 6.6475e-18, 9.0362e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "586000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2592e-20, 4.0313e-39, 2.6809e-39, 3.5522e-39],\n", + " [2.5944e-09, 1.3441e-17, 6.2861e-18, 8.5862e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "587000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3521e-20, 3.9753e-39, 2.6550e-39, 3.5178e-39],\n", + " [2.6126e-09, 1.3318e-17, 6.2397e-18, 8.5233e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "588000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0524e-20, 4.6468e-39, 3.3515e-39, 4.3414e-39],\n", + " [3.0100e-09, 1.4653e-17, 7.2039e-18, 9.7054e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "589000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6717e-20, 3.4761e-39, 2.2294e-39, 2.9994e-39],\n", + " [2.4245e-09, 1.2255e-17, 5.5827e-18, 7.7013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "590000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7014e-20, 2.9191e-39, 1.7495e-39, 2.4081e-39],\n", + " [2.1430e-09, 1.1008e-17, 4.7948e-18, 6.7111e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "591000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0569e-20, 3.9541e-39, 2.7295e-39, 3.5985e-39],\n", + " [2.7719e-09, 1.3293e-17, 6.3502e-18, 8.6463e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "592000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0098e-20, 3.8791e-39, 2.6719e-39, 3.5292e-39],\n", + " [2.7608e-09, 1.3161e-17, 6.2822e-18, 8.5614e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "593000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8359e-20, 3.3083e-39, 2.1412e-39, 2.8869e-39],\n", + " [2.4615e-09, 1.1930e-17, 5.4676e-18, 7.5477e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "594000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6613e-20, 2.7561e-39, 1.6473e-39, 2.2794e-39],\n", + " [2.1359e-09, 1.0719e-17, 4.6731e-18, 6.5528e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "595000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2453e-20, 3.4324e-39, 2.2771e-39, 3.0534e-39],\n", + " [2.5734e-09, 1.2269e-17, 5.7270e-18, 7.8712e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "596000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8406e-20, 3.6009e-39, 2.4606e-39, 3.2732e-39],\n", + " [2.7165e-09, 1.2629e-17, 6.0024e-18, 8.2102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "597000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9894e-20, 2.7548e-39, 1.6859e-39, 2.3235e-39],\n", + " [2.2268e-09, 1.0726e-17, 4.7441e-18, 6.6337e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "598000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6495e-20, 3.4156e-39, 2.3120e-39, 3.0919e-39],\n", + " [2.6676e-09, 1.2253e-17, 5.7904e-18, 7.9431e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "599000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2467e-20, 3.5697e-39, 2.4840e-39, 3.2974e-39],\n", + " [2.8057e-09, 1.2584e-17, 6.0475e-18, 8.2589e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "600000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.1890e-20, 3.8793e-39, 2.8108e-39, 3.6903e-39],\n", + " [3.0225e-09, 1.3291e-17, 6.5633e-18, 8.8981e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "601000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1564e-20, 3.0654e-39, 2.0226e-39, 2.7375e-39],\n", + " [2.5416e-09, 1.1515e-17, 5.3586e-18, 7.4007e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "602000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0001e-20, 3.3621e-39, 2.3165e-39, 3.0969e-39],\n", + " [2.7534e-09, 1.2225e-17, 5.8557e-18, 8.0222e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "603000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5726e-20, 2.7753e-39, 1.7644e-39, 2.4153e-39],\n", + " [2.4035e-09, 1.0918e-17, 4.9654e-18, 6.8964e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "604000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0078e-20, 2.5360e-39, 1.5403e-39, 2.1259e-39],\n", + " [2.2865e-09, 1.0474e-17, 4.6293e-18, 6.4432e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "605000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8394e-20, 2.8141e-39, 1.8196e-39, 2.4832e-39],\n", + " [2.4756e-09, 1.1043e-17, 5.0829e-18, 7.0425e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "606000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1849e-20, 2.8508e-39, 1.8817e-39, 2.5591e-39],\n", + " [2.5492e-09, 1.1088e-17, 5.1649e-18, 7.1457e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "607000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8763e-20, 2.4050e-39, 1.4391e-39, 1.9915e-39],\n", + " [2.2860e-09, 1.0318e-17, 4.5307e-18, 6.2940e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "608000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6277e-20, 2.6030e-39, 1.6494e-39, 2.2597e-39],\n", + " [2.4539e-09, 1.0675e-17, 4.8528e-18, 6.7198e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "609000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1346e-20, 2.3849e-39, 1.4520e-39, 2.0039e-39],\n", + " [2.3529e-09, 1.0247e-17, 4.5416e-18, 6.3000e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "610000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1277e-20, 2.3837e-39, 1.4501e-39, 2.0008e-39],\n", + " [2.3688e-09, 1.0328e-17, 4.5874e-18, 6.3527e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "611000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2698e-20, 2.9915e-39, 2.0855e-39, 2.8081e-39],\n", + " [2.8017e-09, 1.1468e-17, 5.5341e-18, 7.6062e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "612000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5087e-20, 2.4034e-39, 1.5000e-39, 2.0609e-39],\n", + " [2.4614e-09, 1.0338e-17, 4.6589e-18, 6.4391e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "613000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5142e-20, 2.6780e-39, 1.7867e-39, 2.4257e-39],\n", + " [2.6752e-09, 1.0896e-17, 5.1225e-18, 7.0481e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "614000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6664e-20, 2.3822e-39, 1.4998e-39, 2.0577e-39],\n", + " [2.5101e-09, 1.0320e-17, 4.6785e-18, 6.4554e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "615000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5275e-20, 2.3215e-39, 1.4456e-39, 1.9870e-39],\n", + " [2.4929e-09, 1.0242e-17, 4.6171e-18, 6.3675e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "616000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3412e-20, 2.5014e-39, 1.6434e-39, 2.2377e-39],\n", + " [2.6653e-09, 1.0581e-17, 4.9268e-18, 6.7728e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "617000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5599e-20, 2.5000e-39, 1.6612e-39, 2.2576e-39],\n", + " [2.7133e-09, 1.0562e-17, 4.9488e-18, 6.7966e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "618000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2999e-20, 2.6649e-39, 1.8434e-39, 2.4878e-39],\n", + " [2.8654e-09, 1.0928e-17, 5.2533e-18, 7.1937e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "619000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5038e-20, 2.4146e-39, 1.5944e-39, 2.1694e-39],\n", + " [2.7226e-09, 1.0432e-17, 4.8725e-18, 6.6840e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "620000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9845e-20, 2.2739e-39, 1.4517e-39, 1.9867e-39],\n", + " [2.6369e-09, 1.0227e-17, 4.6893e-18, 6.4340e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "621000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.6485e-20, 2.3878e-39, 1.5865e-39, 2.1562e-39],\n", + " [2.7755e-09, 1.0440e-17, 4.9027e-18, 6.7101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "622000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4591e-20, 2.0388e-39, 1.2488e-39, 1.7224e-39],\n", + " [2.5335e-09, 9.7053e-18, 4.3320e-18, 5.9534e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "623000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1745e-20, 1.9415e-39, 1.1620e-39, 1.6091e-39],\n", + " [2.4796e-09, 9.5223e-18, 4.1943e-18, 5.7656e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "624000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0154e-20, 2.1425e-39, 1.3626e-39, 1.8663e-39],\n", + " [2.6812e-09, 1.0011e-17, 4.5851e-18, 6.2738e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "625000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2121e-20, 2.1495e-39, 1.3826e-39, 1.8901e-39],\n", + " [2.7266e-09, 1.0014e-17, 4.6156e-18, 6.3099e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "626000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7818e-20, 2.2325e-39, 1.4842e-39, 2.0173e-39],\n", + " [2.8458e-09, 1.0173e-17, 4.7819e-18, 6.5234e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "627000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4369e-20, 1.8988e-39, 1.1538e-39, 1.5936e-39],\n", + " [2.5778e-09, 9.4971e-18, 4.2304e-18, 5.7925e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "628000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9008e-20, 2.2341e-39, 1.4938e-39, 2.0277e-39],\n", + " [2.9009e-09, 1.0284e-17, 4.8675e-18, 6.6218e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "629000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1865e-20, 2.2921e-39, 1.5569e-39, 2.1070e-39],\n", + " [2.9742e-09, 1.0476e-17, 5.0178e-18, 6.8104e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "630000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1999e-20, 2.0200e-39, 1.2913e-39, 1.7671e-39],\n", + " [2.7822e-09, 9.8735e-18, 4.5527e-18, 6.1979e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "631000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9429e-20, 2.1213e-39, 1.4150e-39, 1.9220e-39],\n", + " [2.9407e-09, 1.0079e-17, 4.7659e-18, 6.4699e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "632000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6551e-20, 2.4053e-39, 1.7418e-39, 2.3328e-39],\n", + " [3.2569e-09, 1.0666e-17, 5.2976e-18, 7.1615e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "633000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4020e-20, 1.9276e-39, 1.2409e-39, 1.6967e-39],\n", + " [2.8505e-09, 9.6595e-18, 4.4686e-18, 6.0704e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "634000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1218e-20, 1.8236e-39, 1.1507e-39, 1.5793e-39],\n", + " [2.7968e-09, 9.4039e-18, 4.2938e-18, 5.8374e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "635000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0685e-20, 2.0339e-39, 1.3601e-39, 1.8464e-39],\n", + " [3.0229e-09, 1.0016e-17, 4.7612e-18, 6.4358e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "636000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.2713e-20, 2.3849e-39, 1.7644e-39, 2.3538e-39],\n", + " [3.4249e-09, 1.0768e-17, 5.4375e-18, 7.3119e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "637000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6149e-20, 2.5994e-39, 2.0197e-39, 2.6719e-39],\n", + " [3.6571e-09, 1.1280e-17, 5.8779e-18, 7.8781e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "638000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5956e-20, 1.6171e-39, 9.7952e-40, 1.3541e-39],\n", + " [2.7353e-09, 9.0359e-18, 4.0424e-18, 5.4833e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "639000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0046e-19, 2.5559e-39, 2.0085e-39, 2.6526e-39],\n", + " [3.7460e-09, 1.1205e-17, 5.8775e-18, 7.8636e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "640000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1901e-20, 1.6763e-39, 1.0550e-39, 1.4485e-39],\n", + " [2.8958e-09, 9.2270e-18, 4.2306e-18, 5.7158e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "641000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1876e-20, 1.4330e-39, 8.3703e-40, 1.1651e-39],\n", + " [2.6654e-09, 8.5708e-18, 3.7501e-18, 5.0860e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "642000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1563e-20, 1.5928e-39, 9.9652e-40, 1.3702e-39],\n", + " [2.9068e-09, 9.0142e-18, 4.1162e-18, 5.5562e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "643000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4551e-20, 1.8365e-39, 1.2408e-39, 1.6817e-39],\n", + " [3.2168e-09, 9.7674e-18, 4.6997e-18, 6.2984e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "644000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0659e-20, 1.7265e-39, 1.1399e-39, 1.5517e-39],\n", + " [3.1441e-09, 9.4791e-18, 4.4937e-18, 6.0281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "645000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7175e-20, 1.6255e-39, 1.0500e-39, 1.4353e-39],\n", + " [3.0764e-09, 9.2051e-18, 4.3020e-18, 5.7766e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "646000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8386e-20, 1.7695e-39, 1.2125e-39, 1.6402e-39],\n", + " [3.3095e-09, 9.5583e-18, 4.6283e-18, 6.1919e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "647000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0259e-20, 1.8968e-39, 1.3697e-39, 1.8356e-39],\n", + " [3.5345e-09, 9.8521e-18, 4.9222e-18, 6.5631e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "648000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0527e-19, 2.2397e-39, 1.7692e-39, 2.3346e-39],\n", + " [3.9690e-09, 1.0752e-17, 5.6876e-18, 7.5413e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "649000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1070e-19, 2.2577e-39, 1.8103e-39, 2.3832e-39],\n", + " [4.0574e-09, 1.0781e-17, 5.7496e-18, 7.6161e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "650000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6409e-20, 1.7456e-39, 1.2351e-39, 1.6618e-39],\n", + " [3.5065e-09, 9.5363e-18, 4.7124e-18, 6.2754e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "651000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5975e-20, 1.5873e-39, 1.0680e-39, 1.4501e-39],\n", + " [3.3260e-09, 9.1775e-18, 4.4051e-18, 5.8757e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "652000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5431e-20, 1.5400e-39, 1.0314e-39, 1.4018e-39],\n", + " [3.3215e-09, 9.0363e-18, 4.3213e-18, 5.7636e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "653000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5701e-20, 1.2263e-39, 7.2675e-40, 1.0101e-39],\n", + " [2.8963e-09, 8.1779e-18, 3.6335e-18, 4.8761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "654000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4503e-20, 1.4661e-39, 9.7442e-40, 1.3266e-39],\n", + " [3.3292e-09, 8.8626e-18, 4.2211e-18, 5.6237e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "655000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0570e-20, 1.3879e-39, 9.0198e-40, 1.2331e-39],\n", + " [3.2635e-09, 8.6715e-18, 4.0776e-18, 5.4342e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "656000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.2894e-20, 1.6327e-39, 1.1783e-39, 1.5807e-39],\n", + " [3.7067e-09, 9.3302e-18, 4.6747e-18, 6.1882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "657000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1231e-20, 1.0563e-39, 6.0100e-40, 8.4227e-40],\n", + " [2.8181e-09, 7.6649e-18, 3.3255e-18, 4.4625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "658000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6916e-20, 1.1463e-39, 6.8166e-40, 9.4734e-40],\n", + " [2.9867e-09, 8.0179e-18, 3.5809e-18, 4.7849e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "659000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2808e-20, 1.0566e-39, 6.0803e-40, 8.5035e-40],\n", + " [2.8849e-09, 7.7093e-18, 3.3713e-18, 4.5127e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "660000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6668e-20, 1.6149e-39, 1.1810e-39, 1.5802e-39],\n", + " [3.8565e-09, 9.4665e-18, 4.8123e-18, 6.3353e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "661000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4573e-20, 1.3152e-39, 8.6837e-40, 1.1842e-39],\n", + " [3.4356e-09, 8.5969e-18, 4.1006e-18, 5.4308e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "662000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7630e-20, 1.3168e-39, 8.8159e-40, 1.1996e-39],\n", + " [3.5056e-09, 8.5862e-18, 4.1269e-18, 5.4597e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "663000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0847e-20, 1.1078e-39, 6.7356e-40, 9.3271e-40],\n", + " [3.1535e-09, 8.0039e-18, 3.6387e-18, 4.8335e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "664000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0875e-20, 1.1049e-39, 6.7205e-40, 9.3041e-40],\n", + " [3.1796e-09, 8.0664e-18, 3.6800e-18, 4.8794e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "665000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5446e-20, 1.1268e-39, 7.0414e-40, 9.7036e-40],\n", + " [3.2978e-09, 8.1223e-18, 3.7631e-18, 4.9800e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "666000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8680e-20, 1.1406e-39, 7.2554e-40, 9.9685e-40],\n", + " [3.3782e-09, 8.1559e-18, 3.8173e-18, 5.0451e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "667000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0268e-20, 1.1289e-39, 7.2337e-40, 9.9283e-40],\n", + " [3.4204e-09, 8.1028e-18, 3.8061e-18, 5.0268e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "668000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1583e-20, 9.9931e-40, 6.0635e-40, 8.4090e-40],\n", + " [3.2185e-09, 7.6435e-18, 3.4692e-18, 4.5965e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "669000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0592e-20, 1.0757e-39, 6.8820e-40, 9.4539e-40],\n", + " [3.4387e-09, 7.8962e-18, 3.6990e-18, 4.8839e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "670000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.0671e-20, 1.2764e-39, 9.0040e-40, 1.2147e-39],\n", + " [3.8831e-09, 8.6095e-18, 4.2927e-18, 5.6250e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "671000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5545e-20, 9.0299e-40, 5.2486e-40, 7.3363e-40],\n", + " [3.1074e-09, 7.3911e-18, 3.2813e-18, 4.3452e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "672000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0029e-20, 1.0280e-39, 6.5442e-40, 8.9990e-40],\n", + " [3.4789e-09, 7.8269e-18, 3.6695e-18, 4.8305e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "673000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.2490e-20, 1.1723e-39, 7.7087e-40, 1.0258e-39],\n", + " [4.0236e-09, 8.7520e-18, 4.2098e-18, 5.3879e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "674000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6293e-20, 7.3171e-40, 3.8833e-40, 5.4882e-40],\n", + " [2.8499e-09, 6.7211e-18, 2.8337e-18, 3.7625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "675000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4034e-20, 1.0233e-39, 6.4905e-40, 8.7568e-40],\n", + " [3.7683e-09, 8.0952e-18, 3.8050e-18, 4.9117e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "676000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9225e-20, 9.7101e-40, 6.0269e-40, 8.1910e-40],\n", + " [3.6311e-09, 7.8907e-18, 3.6674e-18, 4.7529e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "677000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0295e-20, 9.4170e-40, 5.8774e-40, 7.9916e-40],\n", + " [3.6526e-09, 7.7363e-18, 3.6018e-18, 4.6704e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "678000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4593e-20, 8.8207e-40, 5.3538e-40, 7.3462e-40],\n", + " [3.4822e-09, 7.4849e-18, 3.4326e-18, 4.4737e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "679000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4354e-20, 9.7059e-40, 6.2047e-40, 8.4002e-40],\n", + " [3.7998e-09, 7.9651e-18, 3.7846e-18, 4.8861e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "680000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9411e-20, 9.9305e-40, 6.4970e-40, 8.7491e-40],\n", + " [3.9428e-09, 8.0668e-18, 3.8857e-18, 4.9999e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "681000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0984e-20, 8.8513e-40, 5.5673e-40, 7.5935e-40],\n", + " [3.6790e-09, 7.5242e-18, 3.5293e-18, 4.5800e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "682000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0137e-20, 7.7166e-40, 4.5598e-40, 6.3244e-40],\n", + " [3.3470e-09, 6.9890e-18, 3.1520e-18, 4.1305e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "683000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9557e-20, 7.4263e-40, 4.3630e-40, 6.0637e-40],\n", + " [3.3281e-09, 6.8414e-18, 3.0693e-18, 4.0264e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "684000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.8157e-20, 9.8433e-40, 6.6998e-40, 8.9717e-40],\n", + " [4.1860e-09, 8.0743e-18, 3.9919e-18, 5.1137e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "685000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9240e-20, 7.2926e-40, 4.2789e-40, 5.9543e-40],\n", + " [3.3426e-09, 6.8472e-18, 3.0792e-18, 4.0360e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "686000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.4619e-20, 9.1364e-40, 6.1400e-40, 8.2752e-40],\n", + " [4.0801e-09, 7.7347e-18, 3.7911e-18, 4.8757e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "687000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6706e-20, 9.0460e-40, 6.1308e-40, 8.2541e-40],\n", + " [4.1294e-09, 7.6813e-18, 3.7807e-18, 4.8598e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "688000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.7715e-20, 7.3740e-40, 4.5477e-40, 6.2717e-40],\n", + " [3.5944e-09, 6.8572e-18, 3.1716e-18, 4.1361e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "689000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9652e-20, 5.8768e-40, 3.1899e-40, 4.5270e-40],\n", + " [3.0328e-09, 6.1321e-18, 2.6157e-18, 3.4632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "690000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4676e-20, 7.6203e-40, 4.8814e-40, 6.6837e-40],\n", + " [3.8013e-09, 6.9993e-18, 3.3186e-18, 4.3072e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "691000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8297e-20, 6.2868e-40, 3.6401e-40, 5.0990e-40],\n", + " [3.3207e-09, 6.3328e-18, 2.8095e-18, 3.6929e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "692000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.3686e-20, 7.2621e-40, 4.6198e-40, 6.3424e-40],\n", + " [3.7814e-09, 6.8373e-18, 3.2249e-18, 4.1896e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "693000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2422e-20, 4.8195e-40, 2.4342e-40, 3.5177e-40],\n", + " [2.7811e-09, 5.5734e-18, 2.2709e-18, 3.0324e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "694000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2226e-20, 6.9781e-40, 4.4032e-40, 6.0627e-40],\n", + " [3.7636e-09, 6.7511e-18, 3.1740e-18, 4.1248e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "695000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3114e-20, 7.6193e-40, 5.0836e-40, 6.9176e-40],\n", + " [4.0703e-09, 7.1017e-18, 3.4677e-18, 4.4734e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "696000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3720e-20, 5.4960e-40, 3.0713e-40, 4.3484e-40],\n", + " [3.2085e-09, 5.9957e-18, 2.6074e-18, 3.4384e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "697000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9178e-20, 5.7723e-40, 3.3561e-40, 4.7138e-40],\n", + " [3.3967e-09, 6.1686e-18, 2.7538e-18, 3.6132e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "698000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8120e-20, 6.8682e-40, 4.4623e-40, 6.1199e-40],\n", + " [3.9564e-09, 6.7603e-18, 3.2434e-18, 4.1978e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "699000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7746e-20, 6.6187e-40, 4.2833e-40, 5.8834e-40],\n", + " [3.9445e-09, 6.6217e-18, 3.1646e-18, 4.0991e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "700000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8264e-20, 5.3899e-40, 3.1073e-40, 4.3801e-40],\n", + " [3.3827e-09, 5.9844e-18, 2.6579e-18, 3.4904e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "701000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2296e-20, 4.1683e-40, 2.0941e-40, 3.0446e-40],\n", + " [2.8086e-09, 5.2374e-18, 2.1257e-18, 2.8398e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "702000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.5533e-20, 5.5465e-40, 3.3447e-40, 4.6743e-40],\n", + " [3.6072e-09, 6.0562e-18, 2.7618e-18, 3.6093e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "703000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6943e-20, 5.4820e-40, 3.3296e-40, 4.6488e-40],\n", + " [3.6483e-09, 6.0115e-18, 2.7505e-18, 3.5925e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "704000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4947e-20, 7.2712e-40, 5.2609e-40, 7.0719e-40],\n", + " [4.6286e-09, 6.9636e-18, 3.5682e-18, 4.5616e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "705000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7954e-20, 5.9434e-40, 3.8365e-40, 5.2915e-40],\n", + " [3.9857e-09, 6.3234e-18, 3.0168e-18, 3.9080e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "706000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9320e-20, 4.3406e-40, 2.3284e-40, 3.3463e-40],\n", + " [3.1100e-09, 5.4206e-18, 2.3010e-18, 3.0466e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "707000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4527e-20, 5.1074e-40, 3.0572e-40, 4.2918e-40],\n", + " [3.6164e-09, 5.8846e-18, 2.6776e-18, 3.4994e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "708000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9156e-20, 5.2204e-40, 3.2089e-40, 4.4815e-40],\n", + " [3.7542e-09, 5.9428e-18, 2.7472e-18, 3.5799e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "709000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8477e-20, 3.9953e-40, 2.1194e-40, 3.0589e-40],\n", + " [3.0766e-09, 5.1753e-18, 2.1733e-18, 2.8842e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "710000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6313e-20, 4.9276e-40, 2.9768e-40, 4.1778e-40],\n", + " [3.6855e-09, 5.8006e-18, 2.6545e-18, 3.4651e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "711000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7260e-20, 4.8715e-40, 2.9562e-40, 4.1470e-40],\n", + " [3.7130e-09, 5.7602e-18, 2.6411e-18, 3.4466e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "712000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8880e-20, 3.7932e-40, 2.0153e-40, 2.9130e-40],\n", + " [3.1036e-09, 5.0587e-18, 2.1257e-18, 2.8205e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "713000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8843e-20, 5.2434e-40, 3.3861e-40, 4.6912e-40],\n", + " [4.0595e-09, 6.0105e-18, 2.8708e-18, 3.7169e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "714000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6321e-20, 4.5325e-40, 2.7291e-40, 3.8425e-40],\n", + " [3.6985e-09, 5.5686e-18, 2.5381e-18, 3.3157e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "715000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4319e-20, 3.8586e-40, 2.1390e-40, 3.0686e-40],\n", + " [3.3097e-09, 5.1210e-18, 2.2103e-18, 2.9177e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "716000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3497e-20, 3.8015e-40, 2.0956e-40, 3.0114e-40],\n", + " [3.2941e-09, 5.1105e-18, 2.2019e-18, 2.9068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "717000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.0960e-20, 4.1248e-40, 2.4003e-40, 3.4105e-40],\n", + " [3.5571e-09, 5.3562e-18, 2.3937e-18, 3.1378e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "718000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4065e-20, 4.1549e-40, 2.4635e-40, 3.4883e-40],\n", + " [3.6546e-09, 5.3685e-18, 2.4250e-18, 3.1726e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "719000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4190e-20, 4.0439e-40, 2.3961e-40, 3.3957e-40],\n", + " [3.6571e-09, 5.2863e-18, 2.3834e-18, 3.1196e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "720000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7857e-20, 4.5021e-40, 2.8776e-40, 4.0134e-40],\n", + " [4.0612e-09, 5.5876e-18, 2.6441e-18, 3.4294e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "721000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8640e-20, 3.6449e-40, 2.0786e-40, 2.9745e-40],\n", + " [3.4874e-09, 5.0229e-18, 2.2085e-18, 2.9045e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "722000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6760e-20, 3.0968e-40, 1.6077e-40, 2.3498e-40],\n", + " [3.0754e-09, 4.6464e-18, 1.9265e-18, 2.5615e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "723000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9140e-20, 3.1748e-40, 1.6835e-40, 2.4503e-40],\n", + " [3.1720e-09, 4.7176e-18, 1.9841e-18, 2.6307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "724000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1117e-20, 3.2351e-40, 1.7449e-40, 2.5315e-40],\n", + " [3.2565e-09, 4.7871e-18, 2.0387e-18, 2.6962e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "725000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8102e-20, 4.1825e-40, 2.6729e-40, 3.7389e-40],\n", + " [4.1104e-09, 5.4507e-18, 2.5854e-18, 3.3507e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "726000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2725e-20, 3.1258e-40, 1.7027e-40, 2.4683e-40],\n", + " [3.3122e-09, 4.6891e-18, 2.0042e-18, 2.6493e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "727000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5382e-20, 2.7549e-40, 1.4068e-40, 2.0696e-40],\n", + " [3.0348e-09, 4.3909e-18, 1.7984e-18, 2.3967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "728000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.4808e-20, 3.1260e-40, 1.7299e-40, 2.5017e-40],\n", + " [3.3976e-09, 4.7093e-18, 2.0347e-18, 2.6840e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "729000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.3558e-20, 3.7245e-40, 2.3181e-40, 3.2690e-40],\n", + " [3.9925e-09, 5.1443e-18, 2.3945e-18, 3.1146e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "730000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0063e-20, 3.1948e-40, 1.8320e-40, 2.6316e-40],\n", + " [3.5745e-09, 4.7512e-18, 2.0959e-18, 2.7542e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "731000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5040e-20, 2.9382e-40, 1.6237e-40, 2.3528e-40],\n", + " [3.4029e-09, 4.5458e-18, 1.9556e-18, 2.5824e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "732000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.3337e-20, 2.9162e-40, 1.5951e-40, 2.3175e-40],\n", + " [3.3699e-09, 4.5862e-18, 1.9700e-18, 2.6007e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "733000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0284e-20, 2.3497e-40, 1.1387e-40, 1.6997e-40],\n", + " [2.8592e-09, 4.1136e-18, 1.6349e-18, 2.1903e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "734000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9436e-20, 3.3456e-40, 2.0330e-40, 2.8897e-40],\n", + " [3.9040e-09, 4.9207e-18, 2.2591e-18, 2.9454e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "735000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2057e-20, 2.3119e-40, 1.1393e-40, 1.6966e-40],\n", + " [2.9335e-09, 4.0684e-18, 1.6304e-18, 2.1813e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "736000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7058e-20, 3.1214e-40, 1.8664e-40, 2.6654e-40],\n", + " [3.8286e-09, 4.7370e-18, 2.1472e-18, 2.8067e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "737000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3940e-20, 1.8989e-40, 8.4762e-41, 1.2913e-40],\n", + " [2.5748e-09, 3.7002e-18, 1.3940e-18, 1.8867e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "738000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0141e-20, 2.4977e-40, 1.3257e-40, 1.9455e-40],\n", + " [3.2668e-09, 4.2485e-18, 1.7857e-18, 2.3675e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "739000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4068e-20, 1.8569e-40, 8.3019e-41, 1.2656e-40],\n", + " [2.5830e-09, 3.6592e-18, 1.3781e-18, 1.8653e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "740000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8394e-20, 2.4209e-40, 1.2679e-40, 1.8677e-40],\n", + " [3.2235e-09, 4.2261e-18, 1.7675e-18, 2.3447e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "741000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4505e-20, 2.2248e-40, 1.1227e-40, 1.6685e-40],\n", + " [3.0670e-09, 4.0421e-18, 1.6485e-18, 2.1975e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "742000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1834e-20, 2.4402e-40, 1.3135e-40, 1.9257e-40],\n", + " [3.3595e-09, 4.2482e-18, 1.8069e-18, 2.3894e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "743000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4230e-20, 2.1356e-40, 1.0734e-40, 1.5984e-40],\n", + " [3.0609e-09, 3.9638e-18, 1.6116e-18, 2.1496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "744000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2163e-20, 2.0163e-40, 9.9131e-41, 1.4841e-40],\n", + " [2.9729e-09, 3.8443e-18, 1.5392e-18, 2.0592e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "745000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.5030e-20, 2.6526e-40, 1.5609e-40, 2.2481e-40],\n", + " [3.8098e-09, 4.4154e-18, 1.9816e-18, 2.5947e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "746000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6067e-20, 2.0512e-40, 1.0456e-40, 1.5549e-40],\n", + " [3.1325e-09, 3.8676e-18, 1.5812e-18, 2.1074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "747000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5901e-20, 1.9944e-40, 1.0138e-40, 1.5096e-40],\n", + " [3.1247e-09, 3.8071e-18, 1.5516e-18, 2.0694e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "748000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9698e-20, 2.1920e-40, 1.1326e-40, 1.6615e-40],\n", + " [3.3752e-09, 4.1072e-18, 1.7017e-18, 2.2399e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "749000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1330e-20, 2.1213e-40, 1.1123e-40, 1.6279e-40],\n", + " [3.4383e-09, 4.0144e-18, 1.6764e-18, 2.2037e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "750000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4698e-20, 1.8653e-40, 9.2756e-41, 1.3786e-40],\n", + " [3.1357e-09, 3.7601e-18, 1.5155e-18, 2.0128e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "751000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9383e-20, 1.6652e-40, 7.8691e-41, 1.1868e-40],\n", + " [2.8741e-09, 3.5398e-18, 1.3796e-18, 1.8502e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "752000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0767e-20, 1.9540e-40, 1.0211e-40, 1.5007e-40],\n", + " [3.3923e-09, 3.8550e-18, 1.6001e-18, 2.1102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "753000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4042e-20, 1.7233e-40, 8.5198e-41, 1.2724e-40],\n", + " [3.0859e-09, 3.6059e-18, 1.4428e-18, 1.9231e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "754000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4963e-20, 1.7586e-40, 8.7871e-41, 1.3098e-40],\n", + " [3.1419e-09, 3.6686e-18, 1.4828e-18, 1.9722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "755000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3896e-20, 1.6954e-40, 8.3917e-41, 1.2552e-40],\n", + " [3.0870e-09, 3.5981e-18, 1.4441e-18, 1.9253e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "756000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1252e-20, 1.8321e-40, 9.6328e-41, 1.4199e-40],\n", + " [3.4039e-09, 3.7503e-18, 1.5616e-18, 2.0626e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "757000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6653e-20, 1.4663e-40, 6.7681e-41, 1.0339e-40],\n", + " [2.7408e-09, 3.3606e-18, 1.2946e-18, 1.7479e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "758000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9216e-20, 1.5077e-40, 7.1560e-41, 1.0862e-40],\n", + " [2.8668e-09, 3.4112e-18, 1.3361e-18, 1.7966e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "759000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8770e-20, 1.1593e-40, 4.8098e-41, 7.5770e-41],\n", + " [2.2832e-09, 2.9692e-18, 1.0669e-18, 1.4697e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "760000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2869e-20, 1.5533e-40, 7.6480e-41, 1.1518e-40],\n", + " [3.0386e-09, 3.4727e-18, 1.3910e-18, 1.8609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "761000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7550e-20, 1.3764e-40, 6.4188e-41, 9.8189e-41],\n", + " [2.7702e-09, 3.2566e-18, 1.2587e-18, 1.7013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "762000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9211e-20, 1.6287e-40, 8.4636e-41, 1.2593e-40],\n", + " [3.3107e-09, 3.5622e-18, 1.4729e-18, 1.9556e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "763000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3409e-20, 1.2190e-40, 5.4152e-41, 8.4099e-41],\n", + " [2.5450e-09, 3.0611e-18, 1.1465e-18, 1.5648e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "764000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3818e-20, 1.6865e-40, 9.0712e-41, 1.3394e-40],\n", + " [3.5018e-09, 3.6392e-18, 1.5382e-18, 2.0317e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "765000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7650e-20, 1.2821e-40, 5.9915e-41, 9.1976e-41],\n", + " [2.7610e-09, 3.1450e-18, 1.2140e-18, 1.6448e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "766000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4360e-20, 1.4159e-40, 7.0700e-41, 1.0672e-40],\n", + " [3.0802e-09, 3.3161e-18, 1.3338e-18, 1.7877e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "767000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6536e-20, 1.2360e-40, 5.7160e-41, 8.8146e-41],\n", + " [2.7088e-09, 3.1016e-18, 1.1915e-18, 1.6181e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "768000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2131e-20, 1.5594e-40, 8.3049e-41, 1.2342e-40],\n", + " [3.4253e-09, 3.5105e-18, 1.4739e-18, 1.9542e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "769000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3205e-20, 1.3409e-40, 6.6392e-41, 1.0072e-40],\n", + " [3.0268e-09, 3.2397e-18, 1.2971e-18, 1.7432e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "770000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9071e-20, 1.4497e-40, 7.5524e-41, 1.1314e-40],\n", + " [3.2917e-09, 3.3869e-18, 1.4018e-18, 1.8678e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "771000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0707e-20, 1.2432e-40, 6.0172e-41, 9.2037e-41],\n", + " [2.9041e-09, 3.1212e-18, 1.2312e-18, 1.6632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "772000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1469e-20, 1.2392e-40, 6.0431e-41, 9.2325e-41],\n", + " [2.9362e-09, 3.1159e-18, 1.2339e-18, 1.6658e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "773000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2035e-20, 1.2570e-40, 6.1743e-41, 9.4206e-41],\n", + " [2.9718e-09, 3.1531e-18, 1.2572e-18, 1.6948e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "774000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5355e-20, 1.2977e-40, 6.5691e-41, 9.9533e-41],\n", + " [3.1192e-09, 3.2075e-18, 1.3021e-18, 1.7476e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "775000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4857e-20, 1.2774e-40, 6.4470e-41, 9.7861e-41],\n", + " [3.1003e-09, 3.1912e-18, 1.2945e-18, 1.7387e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "776000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9647e-20, 1.3401e-40, 7.0356e-41, 1.0580e-40],\n", + " [3.3045e-09, 3.2740e-18, 1.3602e-18, 1.8161e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "777000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2527e-20, 1.3841e-40, 7.4322e-41, 1.1118e-40],\n", + " [3.4298e-09, 3.3417e-18, 1.4101e-18, 1.8756e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "778000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1034e-20, 1.1473e-40, 5.5958e-41, 8.5961e-41],\n", + " [2.9152e-09, 3.0243e-18, 1.1994e-18, 1.6233e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "779000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9014e-20, 1.2729e-40, 6.6556e-41, 1.0045e-40],\n", + " [3.2709e-09, 3.1964e-18, 1.3237e-18, 1.7712e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "780000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7028e-20, 1.0370e-40, 4.8563e-41, 7.5569e-41],\n", + " [2.7154e-09, 2.8762e-18, 1.1119e-18, 1.5170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "781000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8388e-20, 8.4198e-41, 3.5024e-41, 5.6104e-41],\n", + " [2.2500e-09, 2.5962e-18, 9.3184e-19, 1.2934e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "782000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6177e-20, 1.1718e-40, 6.0019e-41, 9.1376e-41],\n", + " [3.1455e-09, 3.0768e-18, 1.2581e-18, 1.6921e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "783000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6250e-20, 1.1515e-40, 5.9007e-41, 8.9903e-41],\n", + " [3.1433e-09, 3.0484e-18, 1.2456e-18, 1.6764e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "784000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1889e-20, 1.0558e-40, 5.2036e-41, 8.0187e-41],\n", + " [2.9392e-09, 2.9110e-18, 1.1592e-18, 1.5719e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "785000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0511e-20, 1.0105e-40, 4.9137e-41, 7.6064e-41],\n", + " [2.8684e-09, 2.8440e-18, 1.1217e-18, 1.5258e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "786000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1082e-20, 1.0257e-40, 5.0277e-41, 7.7734e-41],\n", + " [2.9068e-09, 2.8834e-18, 1.1465e-18, 1.5569e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "787000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5132e-20, 1.0877e-40, 5.5412e-41, 8.4874e-41],\n", + " [3.0977e-09, 2.9836e-18, 1.2170e-18, 1.6420e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "788000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6242e-20, 1.0857e-40, 5.5842e-41, 8.5397e-41],\n", + " [3.1419e-09, 2.9809e-18, 1.2221e-18, 1.6473e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "789000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7672e-20, 1.0829e-40, 5.6376e-41, 8.6040e-41],\n", + " [3.1976e-09, 2.9772e-18, 1.2283e-18, 1.6538e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "790000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2551e-20, 8.1832e-41, 3.6201e-41, 5.7295e-41],\n", + " [2.5017e-09, 2.6017e-18, 9.6832e-19, 1.3309e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "791000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8360e-20, 1.1913e-40, 6.6936e-41, 1.0028e-40],\n", + " [3.6197e-09, 3.1327e-18, 1.3539e-18, 1.8016e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "792000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6070e-20, 8.6719e-41, 4.0380e-41, 6.3490e-41],\n", + " [2.6670e-09, 2.6727e-18, 1.0286e-18, 1.4098e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "793000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5348e-20, 9.9425e-41, 5.0908e-41, 7.8331e-41],\n", + " [3.0906e-09, 2.8611e-18, 1.1677e-18, 1.5799e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "794000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9656e-20, 9.0295e-41, 4.3901e-41, 6.8550e-41],\n", + " [2.8310e-09, 2.7282e-18, 1.0791e-18, 1.4733e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "795000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2016e-20, 9.2368e-41, 4.5971e-41, 7.1400e-41],\n", + " [2.9389e-09, 2.7616e-18, 1.1075e-18, 1.5071e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "796000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5402e-20, 8.1546e-41, 3.7441e-41, 5.8772e-41],\n", + " [2.6769e-09, 2.6388e-18, 1.0065e-18, 1.3729e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "797000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4948e-20, 7.9428e-41, 3.6173e-41, 5.6789e-41],\n", + " [2.6656e-09, 2.6165e-18, 9.9229e-19, 1.3522e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "798000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6320e-20, 7.9896e-41, 3.7035e-41, 5.8014e-41],\n", + " [2.7251e-09, 2.6181e-18, 1.0027e-18, 1.3654e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "799000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2758e-20, 8.6572e-41, 4.3362e-41, 6.7414e-41],\n", + " [2.9604e-09, 2.6748e-18, 1.0726e-18, 1.4606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "800000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3598e-20, 8.7538e-41, 4.4242e-41, 6.8647e-41],\n", + " [3.0074e-09, 2.7026e-18, 1.0916e-18, 1.4836e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "801000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5105e-20, 8.7483e-41, 4.4847e-41, 6.9444e-41],\n", + " [3.0657e-09, 2.6997e-18, 1.0987e-18, 1.4918e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "802000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7610e-20, 8.9484e-41, 4.6915e-41, 7.2355e-41],\n", + " [3.1624e-09, 2.7261e-18, 1.1243e-18, 1.5235e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "803000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1455e-20, 8.2472e-41, 4.0593e-41, 6.2995e-41],\n", + " [2.9655e-09, 2.6716e-18, 1.0621e-18, 1.4380e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "804000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9868e-20, 7.9103e-41, 3.8152e-41, 5.9279e-41],\n", + " [2.9170e-09, 2.6379e-18, 1.0351e-18, 1.3997e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "805000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9632e-20, 7.7475e-41, 3.7207e-41, 5.7797e-41],\n", + " [2.9152e-09, 2.6200e-18, 1.0245e-18, 1.3841e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "806000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5776e-20, 8.4714e-41, 4.3566e-41, 6.7156e-41],\n", + " [3.1523e-09, 2.7161e-18, 1.1100e-18, 1.4967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "807000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8293e-20, 7.4941e-41, 3.5351e-41, 5.4892e-41],\n", + " [2.8967e-09, 2.6205e-18, 1.0158e-18, 1.3672e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "808000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5211e-20, 7.0128e-41, 3.1693e-41, 4.9380e-41],\n", + " [2.7811e-09, 2.5695e-18, 9.6990e-19, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "809000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5641e-20, 7.0243e-41, 3.1923e-41, 4.9673e-41],\n", + " [2.8094e-09, 2.5786e-18, 9.7720e-19, 1.3121e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "810000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4864e-20, 6.8239e-41, 3.0632e-41, 4.7693e-41],\n", + " [2.7832e-09, 2.5555e-18, 9.6053e-19, 1.2886e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "811000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6864e-20, 6.9472e-41, 3.2022e-41, 4.9710e-41],\n", + " [2.8699e-09, 2.5659e-18, 9.7918e-19, 1.3129e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "812000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3615e-20, 6.6152e-41, 2.9127e-41, 4.5340e-41],\n", + " [2.7607e-09, 2.5609e-18, 9.5394e-19, 1.2750e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "813000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5345e-20, 7.7808e-41, 3.9574e-41, 6.0746e-41],\n", + " [3.2142e-09, 2.6801e-18, 1.0880e-18, 1.4545e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "814000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0408e-20, 8.1315e-41, 4.3365e-41, 6.6234e-41],\n", + " [3.3857e-09, 2.7123e-18, 1.1320e-18, 1.5126e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "815000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5134e-20, 7.5554e-41, 3.8261e-41, 5.8663e-41],\n", + " [3.2300e-09, 2.6651e-18, 1.0788e-18, 1.4386e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "816000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4342e-20, 6.2487e-41, 2.7657e-41, 4.2908e-41],\n", + " [2.8260e-09, 2.5190e-18, 9.3918e-19, 1.2496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "817000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3182e-20, 6.0004e-41, 2.6059e-41, 4.0472e-41],\n", + " [2.7819e-09, 2.4872e-18, 9.1594e-19, 1.2174e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "818000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9746e-20, 6.6744e-41, 3.1697e-41, 4.8767e-41],\n", + " [3.0701e-09, 2.5792e-18, 1.0037e-18, 1.3323e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "819000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0424e-20, 7.6546e-41, 4.0628e-41, 6.1797e-41],\n", + " [3.4625e-09, 2.7016e-18, 1.1260e-18, 1.4931e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "820000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3543e-20, 7.0857e-41, 3.5161e-41, 5.3737e-41],\n", + " [3.2596e-09, 2.6735e-18, 1.0737e-18, 1.4189e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "821000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3510e-20, 5.9226e-41, 2.5812e-41, 3.9908e-41],\n", + " [2.8616e-09, 2.5349e-18, 9.4065e-19, 1.2409e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "822000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6343e-20, 6.0860e-41, 2.7582e-41, 4.2455e-41],\n", + " [2.9941e-09, 2.5515e-18, 9.6826e-19, 1.2762e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "823000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7466e-20, 6.0774e-41, 2.7919e-41, 4.2890e-41],\n", + " [3.0486e-09, 2.5476e-18, 9.7371e-19, 1.2822e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "824000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1497e-20, 6.3804e-41, 3.0770e-41, 4.7002e-41],\n", + " [3.2258e-09, 2.5935e-18, 1.0211e-18, 1.3426e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "825000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9766e-20, 7.0763e-41, 3.7140e-41, 5.6223e-41],\n", + " [3.5390e-09, 2.6890e-18, 1.1156e-18, 1.4649e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "826000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1008e-20, 6.2047e-41, 2.9709e-41, 4.5340e-41],\n", + " [3.2314e-09, 2.5845e-18, 1.0137e-18, 1.3293e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "827000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7983e-20, 5.8033e-41, 2.6733e-41, 4.0928e-41],\n", + " [3.1160e-09, 2.5305e-18, 9.6887e-19, 1.2692e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "828000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7754e-20, 5.6942e-41, 2.6126e-41, 3.9975e-41],\n", + " [3.1194e-09, 2.5212e-18, 9.6293e-19, 1.2594e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "829000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0094e-20, 5.7935e-41, 2.7332e-41, 4.1684e-41],\n", + " [3.2228e-09, 2.5314e-18, 9.8222e-19, 1.2837e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "830000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8612e-20, 5.7027e-41, 2.6434e-41, 4.0328e-41],\n", + " [3.1890e-09, 2.5477e-18, 9.8126e-19, 1.2790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "831000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3863e-20, 6.1646e-41, 3.0382e-41, 4.6023e-41],\n", + " [3.4215e-09, 2.6297e-18, 1.0533e-18, 1.3702e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "832000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7630e-20, 5.4944e-41, 2.5114e-41, 3.8293e-41],\n", + " [3.1776e-09, 2.5380e-18, 9.7060e-19, 1.2609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "833000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0924e-20, 6.4425e-41, 3.3917e-41, 5.0986e-41],\n", + " [3.6919e-09, 2.6582e-18, 1.1055e-18, 1.4356e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "834000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0752e-20, 6.3378e-41, 3.3281e-41, 5.0004e-41],\n", + " [3.6997e-09, 2.6496e-18, 1.1003e-18, 1.4270e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "835000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9392e-20, 5.4899e-41, 2.5616e-41, 3.8858e-41],\n", + " [3.3066e-09, 2.5730e-18, 9.9921e-19, 1.2909e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "836000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3165e-20, 5.6547e-41, 2.7517e-41, 4.1541e-41],\n", + " [3.4703e-09, 2.5922e-18, 1.0311e-18, 1.3308e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "837000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6764e-20, 5.7738e-41, 2.9116e-41, 4.3771e-41],\n", + " [3.6176e-09, 2.6042e-18, 1.0569e-18, 1.3627e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "838000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1615e-20, 5.2601e-41, 2.5069e-41, 3.7867e-41],\n", + " [3.4261e-09, 2.5287e-18, 9.9093e-19, 1.2761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "839000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6420e-20, 4.8715e-41, 2.1771e-41, 3.3043e-41],\n", + " [3.2310e-09, 2.5000e-18, 9.4584e-19, 1.2143e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "840000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6093e-20, 4.7557e-41, 2.1132e-41, 3.2073e-41],\n", + " [3.2224e-09, 2.4795e-18, 9.3400e-19, 1.1981e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "841000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0652e-20, 5.6914e-41, 2.9657e-41, 4.4295e-41],\n", + " [3.8176e-09, 2.6130e-18, 1.0818e-18, 1.3870e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "842000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3529e-20, 5.1068e-41, 2.4775e-41, 3.7238e-41],\n", + " [3.5581e-09, 2.5266e-18, 1.0012e-18, 1.2821e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "843000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8787e-20, 5.4387e-41, 2.7824e-41, 4.1540e-41],\n", + " [3.7907e-09, 2.5983e-18, 1.0653e-18, 1.3606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "844000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2917e-20, 4.9445e-41, 2.3798e-41, 3.5722e-41],\n", + " [3.5698e-09, 2.5215e-18, 9.9572e-19, 1.2705e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "845000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8973e-20, 5.8335e-41, 3.2422e-41, 4.7959e-41],\n", + " [4.1569e-09, 2.6485e-18, 1.1390e-18, 1.4526e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "846000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0863e-20, 4.6518e-41, 2.1834e-41, 3.2783e-41],\n", + " [3.5197e-09, 2.4911e-18, 9.6968e-19, 1.2327e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "847000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2927e-20, 5.3779e-41, 2.8460e-41, 4.2180e-41],\n", + " [4.0152e-09, 2.6212e-18, 1.0981e-18, 1.3932e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "848000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0366e-20, 4.4829e-41, 2.0884e-41, 3.1320e-41],\n", + " [3.5302e-09, 2.4771e-18, 9.6040e-19, 1.2170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "849000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7077e-20, 4.1575e-41, 1.8553e-41, 2.7926e-41],\n", + " [3.3881e-09, 2.4178e-18, 9.1261e-19, 1.1552e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "850000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2456e-20, 4.4357e-41, 2.1113e-41, 3.1564e-41],\n", + " [3.6349e-09, 2.4628e-18, 9.6536e-19, 1.2212e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "851000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6726e-20, 5.2521e-41, 2.8567e-41, 4.2081e-41],\n", + " [4.2127e-09, 2.6221e-18, 1.1167e-18, 1.4086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "852000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7039e-20, 4.5921e-41, 2.2906e-41, 3.4007e-41],\n", + " [3.8674e-09, 2.5128e-18, 1.0148e-18, 1.2785e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "853000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0225e-20, 4.6754e-41, 2.4004e-41, 3.5517e-41],\n", + " [3.9983e-09, 2.5236e-18, 1.0359e-18, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "854000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8870e-20, 3.9340e-41, 1.7881e-41, 2.6763e-41],\n", + " [3.5321e-09, 2.3911e-18, 9.1159e-19, 1.1464e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "855000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3020e-20, 4.0971e-41, 1.9528e-41, 2.9073e-41],\n", + " [3.7250e-09, 2.4182e-18, 9.4748e-19, 1.1905e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "856000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3929e-20, 4.1127e-41, 1.9792e-41, 2.9406e-41],\n", + " [3.7853e-09, 2.4340e-18, 9.6034e-19, 1.2043e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "857000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1227e-20, 3.9469e-41, 1.8434e-41, 2.7439e-41],\n", + " [3.6922e-09, 2.4214e-18, 9.4034e-19, 1.1766e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "858000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5648e-20, 3.5828e-41, 1.5584e-41, 2.3330e-41],\n", + " [3.4503e-09, 2.3677e-18, 8.8268e-19, 1.1018e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "859000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6280e-20, 4.2370e-41, 2.0920e-41, 3.0892e-41],\n", + " [3.9660e-09, 2.5187e-18, 1.0162e-18, 1.2658e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "860000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0415e-20, 4.3726e-41, 2.2432e-41, 3.2981e-41],\n", + " [4.1398e-09, 2.5405e-18, 1.0478e-18, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "861000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3103e-20, 3.8906e-41, 1.8531e-41, 2.7435e-41],\n", + " [3.8438e-09, 2.4460e-18, 9.6397e-19, 1.1987e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "862000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0091e-20, 3.6263e-41, 1.6660e-41, 2.4736e-41],\n", + " [3.7157e-09, 2.3897e-18, 9.2050e-19, 1.1434e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "863000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0110e-20, 3.6331e-41, 1.6706e-41, 2.4767e-41],\n", + " [3.7494e-09, 2.4172e-18, 9.3471e-19, 1.1578e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "864000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3870e-20, 3.7364e-41, 1.7903e-41, 2.6416e-41],\n", + " [3.9297e-09, 2.4336e-18, 9.6332e-19, 1.1920e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "865000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0471e-20, 3.4714e-41, 1.5985e-41, 2.3664e-41],\n", + " [3.7827e-09, 2.3752e-18, 9.1701e-19, 1.1336e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "866000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8051e-20, 3.2640e-41, 1.4565e-41, 2.1621e-41],\n", + " [3.6720e-09, 2.3265e-18, 8.8055e-19, 1.0876e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "867000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9738e-20, 3.2938e-41, 1.4998e-41, 2.2206e-41],\n", + " [3.7609e-09, 2.3306e-18, 8.9202e-19, 1.1009e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "868000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6310e-20, 3.1469e-41, 1.3727e-41, 2.0380e-41],\n", + " [3.6233e-09, 2.3282e-18, 8.7202e-19, 1.0731e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "869000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7563e-20, 3.1435e-41, 1.3928e-41, 2.0636e-41],\n", + " [3.6951e-09, 2.3239e-18, 8.7759e-19, 1.0790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "870000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6935e-20, 3.4887e-41, 1.7159e-41, 2.5139e-41],\n", + " [4.1430e-09, 2.3955e-18, 9.6137e-19, 1.1805e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "871000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1971e-20, 3.2017e-41, 1.4927e-41, 2.1975e-41],\n", + " [3.9275e-09, 2.3298e-18, 9.0479e-19, 1.1102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "872000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0580e-20, 3.5833e-41, 1.8236e-41, 2.6571e-41],\n", + " [4.3427e-09, 2.4411e-18, 1.0023e-18, 1.2261e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "873000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4471e-20, 2.7506e-41, 1.1634e-41, 1.7256e-41],\n", + " [3.5892e-09, 2.2443e-18, 8.2395e-19, 1.0068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "874000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1618e-20, 3.4490e-41, 1.7670e-41, 2.5694e-41],\n", + " [4.4051e-09, 2.4055e-18, 9.8915e-19, 1.2074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "875000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2215e-20, 2.9932e-41, 1.3953e-41, 2.0472e-41],\n", + " [4.0022e-09, 2.2985e-18, 8.9235e-19, 1.0884e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "876000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8604e-20, 3.6340e-41, 1.9699e-41, 2.8420e-41],\n", + " [4.7309e-09, 2.4721e-18, 1.0539e-18, 1.2812e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "877000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8027e-20, 3.1612e-41, 1.5647e-41, 2.2767e-41],\n", + " [4.3163e-09, 2.3634e-18, 9.5322e-19, 1.1577e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "878000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.9291e-20, 2.2407e-41, 8.6642e-42, 1.2916e-41],\n", + " [3.3534e-09, 2.1336e-18, 7.4461e-19, 9.0268e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "879000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8606e-20, 2.7241e-41, 1.2163e-41, 1.7841e-41],\n", + " [3.9198e-09, 2.2845e-18, 8.6901e-19, 1.0510e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "880000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9753e-20, 2.7117e-41, 1.2267e-41, 1.7958e-41],\n", + " [3.9873e-09, 2.2782e-18, 8.7242e-19, 1.0541e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "881000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6280e-20, 2.4995e-41, 1.0798e-41, 1.5873e-41],\n", + " [3.8100e-09, 2.2176e-18, 8.2525e-19, 9.9625e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "882000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5768e-20, 2.4799e-41, 1.0647e-41, 1.5638e-41],\n", + " [3.8138e-09, 2.2357e-18, 8.3147e-19, 1.0010e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "883000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8284e-20, 2.9268e-41, 1.4494e-41, 2.0972e-41],\n", + " [4.4461e-09, 2.3524e-18, 9.5168e-19, 1.1445e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "884000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5722e-20, 3.1156e-41, 1.6446e-41, 2.3631e-41],\n", + " [4.7676e-09, 2.3961e-18, 1.0059e-18, 1.2086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "885000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4806e-20, 2.2829e-41, 9.6367e-42, 1.4157e-41],\n", + " [3.7775e-09, 2.1688e-18, 7.9602e-19, 9.5598e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "886000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2445e-20, 2.9066e-41, 1.4913e-41, 2.1458e-41],\n", + " [4.6643e-09, 2.3503e-18, 9.6984e-19, 1.1623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "887000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1013e-20, 2.4988e-41, 1.1442e-41, 1.6638e-41],\n", + " [4.1635e-09, 2.2584e-18, 8.7281e-19, 1.0439e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "888000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.2506e-20, 2.0949e-41, 8.5325e-42, 1.2547e-41],\n", + " [3.6893e-09, 2.1327e-18, 7.6765e-19, 9.1743e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "889000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0790e-20, 2.4513e-41, 1.0908e-41, 1.5501e-41],\n", + " [4.3503e-09, 2.3347e-18, 8.8780e-19, 1.0378e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "890000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8867e-20, 2.2810e-41, 9.9492e-42, 1.4223e-41],\n", + " [4.1975e-09, 2.2484e-18, 8.4278e-19, 9.8933e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "891000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3930e-20, 2.5071e-41, 1.1578e-41, 1.6356e-41],\n", + " [4.5870e-09, 2.3883e-18, 9.3247e-19, 1.0845e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "892000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0595e-20, 2.6936e-41, 1.3192e-41, 1.8409e-41],\n", + " [5.0102e-09, 2.4793e-18, 1.0026e-18, 1.1569e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "893000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3466e-20, 2.3739e-41, 1.0934e-41, 1.5483e-41],\n", + " [4.5362e-09, 2.3210e-18, 9.0229e-19, 1.0515e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "894000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4099e-20, 2.3451e-41, 1.0874e-41, 1.5388e-41],\n", + " [4.5703e-09, 2.3061e-18, 8.9915e-19, 1.0475e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "895000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9915e-20, 1.7708e-41, 6.8594e-42, 1.0108e-41],\n", + " [3.4929e-09, 2.0148e-18, 7.0097e-19, 8.3876e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "896000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7867e-20, 1.6457e-41, 6.1349e-42, 9.1225e-42],\n", + " [3.3001e-09, 1.9445e-18, 6.5846e-19, 7.9302e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "897000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2261e-20, 2.4610e-41, 1.2298e-41, 1.7163e-41],\n", + " [5.0871e-09, 2.3837e-18, 9.7368e-19, 1.1234e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "898000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0689e-20, 2.0299e-41, 9.1603e-42, 1.3092e-41],\n", + " [4.3211e-09, 2.1558e-18, 8.2549e-19, 9.6782e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "899000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7704e-20, 1.8821e-41, 8.2088e-42, 1.1831e-41],\n", + " [4.0949e-09, 2.0748e-18, 7.7616e-19, 9.1532e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "900000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2148e-20, 1.6549e-41, 6.6660e-42, 9.7825e-42],\n", + " [3.6500e-09, 1.9502e-18, 6.9095e-19, 8.2519e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "901000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2378e-20, 1.9716e-41, 9.0888e-42, 1.2961e-41],\n", + " [4.4295e-09, 2.1335e-18, 8.2700e-19, 9.6799e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "902000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0548e-20, 1.9188e-41, 8.7049e-42, 1.2465e-41],\n", + " [4.3196e-09, 2.1198e-18, 8.1566e-19, 9.5660e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "903000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8589e-20, 1.4866e-41, 5.6514e-42, 8.4162e-42],\n", + " [3.3561e-09, 1.8762e-18, 6.4132e-19, 7.7273e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "904000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4595e-20, 1.6426e-41, 6.8958e-42, 1.0060e-41],\n", + " [3.8534e-09, 1.9656e-18, 7.1588e-19, 8.5080e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "905000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8239e-20, 1.4016e-41, 5.2927e-42, 7.9075e-42],\n", + " [3.3084e-09, 1.8218e-18, 6.1774e-19, 7.4634e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "906000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0951e-20, 1.4680e-41, 5.8224e-42, 8.6124e-42],\n", + " [3.5417e-09, 1.8614e-18, 6.5112e-19, 7.8144e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "907000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6621e-20, 1.6280e-41, 7.0401e-42, 1.0225e-41],\n", + " [4.0022e-09, 1.9639e-18, 7.2806e-19, 8.6262e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "908000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6731e-20, 1.5941e-41, 6.9042e-42, 1.0033e-41],\n", + " [4.0016e-09, 1.9431e-18, 7.1984e-19, 8.5340e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "909000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3182e-20, 1.4538e-41, 5.9863e-42, 8.8044e-42],\n", + " [3.7155e-09, 1.8585e-18, 6.6464e-19, 7.9462e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "910000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8126e-20, 1.5751e-41, 6.9560e-42, 1.0082e-41],\n", + " [4.1002e-09, 1.9379e-18, 7.2633e-19, 8.5949e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "911000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7802e-20, 1.2659e-41, 4.7602e-42, 7.1508e-42],\n", + " [3.2603e-09, 1.7525e-18, 5.9092e-19, 7.1627e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "912000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5382e-20, 1.1589e-41, 4.1408e-42, 6.2932e-42],\n", + " [3.0231e-09, 1.6795e-18, 5.4654e-19, 6.6806e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "913000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0887e-20, 1.3001e-41, 5.1722e-42, 7.6875e-42],\n", + " [3.5177e-09, 1.7725e-18, 6.1824e-19, 7.4430e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "914000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0956e-20, 9.6970e-42, 3.0829e-42, 4.8121e-42],\n", + " [2.5643e-09, 1.5634e-18, 4.7306e-19, 5.8805e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "915000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.2820e-20, 1.3551e-41, 5.5842e-42, 8.2424e-42],\n", + " [3.7016e-09, 1.8300e-18, 6.5595e-19, 7.8507e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "916000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6007e-20, 1.1308e-41, 4.1128e-42, 6.2428e-42],\n", + " [3.0912e-09, 1.6787e-18, 5.5328e-19, 6.7507e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "917000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6293e-20, 1.3842e-41, 5.9934e-42, 8.7651e-42],\n", + " [3.9587e-09, 1.8459e-18, 6.8172e-19, 8.1106e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "918000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3363e-20, 1.2839e-41, 5.3319e-42, 7.8767e-42],\n", + " [3.7227e-09, 1.7803e-18, 6.3859e-19, 7.6506e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "919000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5708e-20, 1.0514e-41, 3.7989e-42, 5.7902e-42],\n", + " [3.0433e-09, 1.6187e-18, 5.2872e-19, 6.4720e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "920000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1961e-20, 1.1980e-41, 4.8681e-42, 7.2363e-42],\n", + " [3.5945e-09, 1.7207e-18, 6.0660e-19, 7.3013e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "921000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.9507e-20, 1.1386e-41, 4.4477e-42, 6.6702e-42],\n", + " [3.3958e-09, 1.6883e-18, 5.8067e-19, 7.0289e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "922000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7487e-20, 1.3230e-41, 5.8378e-42, 8.5311e-42],\n", + " [4.0411e-09, 1.8197e-18, 6.7914e-19, 8.0726e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "923000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0734e-20, 1.1416e-41, 4.5626e-42, 6.8187e-42],\n", + " [3.5004e-09, 1.6962e-18, 5.9197e-19, 7.1465e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "924000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6989e-20, 1.0252e-41, 3.8213e-42, 5.8014e-42],\n", + " [3.1615e-09, 1.6112e-18, 5.3623e-19, 6.5454e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "925000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8931e-20, 1.0620e-41, 4.1156e-42, 6.2007e-42],\n", + " [3.3407e-09, 1.6440e-18, 5.6163e-19, 6.8173e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "926000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7018e-20, 9.9198e-42, 3.7036e-42, 5.6290e-42],\n", + " [3.1607e-09, 1.5911e-18, 5.2959e-19, 6.4687e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "927000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1058e-20, 1.0651e-41, 4.2838e-42, 6.4137e-42],\n", + " [3.5094e-09, 1.6444e-18, 5.7398e-19, 6.9394e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "928000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3480e-20, 8.8268e-42, 3.0464e-42, 4.7154e-42],\n", + " [2.8174e-09, 1.5151e-18, 4.7920e-19, 5.9235e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "929000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3244e-20, 1.0947e-41, 4.5682e-42, 6.7921e-42],\n", + " [3.6945e-09, 1.6760e-18, 5.9993e-19, 7.2152e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "930000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6107e-20, 9.1561e-42, 3.3617e-42, 5.1428e-42],\n", + " [3.0685e-09, 1.5397e-18, 5.0578e-19, 6.2038e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "931000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5841e-20, 8.9417e-42, 3.2636e-42, 5.0026e-42],\n", + " [3.0380e-09, 1.5217e-18, 4.9738e-19, 6.1094e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "932000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7966e-20, 1.1226e-41, 4.9998e-42, 7.3442e-42],\n", + " [4.0315e-09, 1.6929e-18, 6.3001e-19, 7.5191e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "933000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4115e-20, 8.1626e-42, 2.8629e-42, 4.4323e-42],\n", + " [2.8561e-09, 1.4558e-18, 4.6202e-19, 5.7174e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "934000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4863e-20, 8.2144e-42, 2.9343e-42, 4.5276e-42],\n", + " [2.9265e-09, 1.4595e-18, 4.6820e-19, 5.7817e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "935000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4072e-20, 7.9187e-42, 2.7802e-42, 4.3090e-42],\n", + " [2.8480e-09, 1.4361e-18, 4.5582e-19, 5.6436e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "936000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4859e-20, 8.1359e-42, 2.9161e-42, 4.5010e-42],\n", + " [2.9367e-09, 1.4634e-18, 4.7193e-19, 5.8225e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "937000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5655e-20, 1.0123e-41, 4.3917e-42, 6.5062e-42],\n", + " [3.8548e-09, 1.6204e-18, 5.9214e-19, 7.1051e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "938000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0666e-20, 6.8201e-42, 2.1832e-42, 3.4570e-42],\n", + " [2.4794e-09, 1.3447e-18, 4.0144e-19, 5.0429e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "939000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6736e-20, 8.1107e-42, 3.0324e-42, 4.6467e-42],\n", + " [3.1010e-09, 1.4581e-18, 4.8169e-19, 5.9169e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "940000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7371e-20, 8.2452e-42, 3.1277e-42, 4.7812e-42],\n", + " [3.1674e-09, 1.4768e-18, 4.9336e-19, 6.0457e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "941000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7032e-20, 9.8189e-42, 4.3454e-42, 6.4264e-42],\n", + " [3.9465e-09, 1.6024e-18, 5.9196e-19, 7.0939e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "942000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1619e-20, 6.7318e-42, 2.2225e-42, 3.5046e-42],\n", + " [2.5820e-09, 1.3410e-18, 4.0779e-19, 5.1070e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "943000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3302e-20, 7.0639e-42, 2.4509e-42, 3.8255e-42],\n", + " [2.7670e-09, 1.3747e-18, 4.3273e-19, 5.3778e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "944000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3257e-20, 6.9154e-42, 2.3976e-42, 3.7443e-42],\n", + " [2.7570e-09, 1.3601e-18, 4.2721e-19, 5.3140e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "945000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7038e-20, 7.5642e-42, 2.8586e-42, 4.3861e-42],\n", + " [3.1208e-09, 1.4180e-18, 4.7101e-19, 5.7872e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "946000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1663e-20, 8.2256e-42, 3.3799e-42, 5.0951e-42],\n", + " [3.5131e-09, 1.4741e-18, 5.1666e-19, 6.2742e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "947000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5660e-20, 7.0906e-42, 2.6064e-42, 4.0287e-42],\n", + " [2.9870e-09, 1.3777e-18, 4.4858e-19, 5.5402e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "948000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4707e-20, 6.9140e-42, 2.4999e-42, 3.8788e-42],\n", + " [2.9058e-09, 1.3676e-18, 4.4197e-19, 5.4677e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "949000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0237e-20, 7.7716e-42, 3.1389e-42, 4.7574e-42],\n", + " [3.4027e-09, 1.4440e-18, 5.0126e-19, 6.1045e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "950000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8656e-20, 7.3918e-42, 2.9007e-42, 4.4281e-42],\n", + " [3.2623e-09, 1.4096e-18, 4.7976e-19, 5.8701e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "951000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0139e-20, 7.5124e-42, 3.0282e-42, 4.5977e-42],\n", + " [3.3842e-09, 1.4197e-18, 4.9111e-19, 5.9889e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "952000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1925e-20, 5.9275e-42, 1.9926e-42, 3.1501e-42],\n", + " [2.6000e-09, 1.2694e-18, 3.8927e-19, 4.8789e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "953000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2281e-20, 5.9611e-42, 2.0277e-42, 3.1964e-42],\n", + " [2.6399e-09, 1.2755e-18, 3.9410e-19, 4.9323e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "954000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2028e-20, 5.8168e-42, 1.9632e-42, 3.1039e-42],\n", + " [2.6086e-09, 1.2603e-18, 3.8711e-19, 4.8525e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "955000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4420e-20, 6.1489e-42, 2.2098e-42, 3.4486e-42],\n", + " [2.8504e-09, 1.2928e-18, 4.1316e-19, 5.1352e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "956000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5097e-20, 6.2862e-42, 2.2981e-42, 3.5747e-42],\n", + " [2.9237e-09, 1.3120e-18, 4.2480e-19, 5.2650e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "957000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5092e-20, 6.1671e-42, 2.2547e-42, 3.5089e-42],\n", + " [2.9179e-09, 1.2995e-18, 4.2012e-19, 5.2107e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "958000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6101e-20, 6.2904e-42, 2.3570e-42, 3.6504e-42],\n", + " [3.0159e-09, 1.3134e-18, 4.3184e-19, 5.3362e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "959000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0862e-20, 5.2507e-42, 1.7194e-42, 2.7437e-42],\n", + " [2.4733e-09, 1.2059e-18, 3.6233e-19, 4.5707e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "960000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3499e-20, 7.1256e-42, 3.0422e-42, 4.5850e-42],\n", + " [3.6313e-09, 1.3908e-18, 4.9718e-19, 6.0329e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "961000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6948e-20, 6.0872e-42, 2.3220e-42, 3.5901e-42],\n", + " [3.0778e-09, 1.2910e-18, 4.2779e-19, 5.2827e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "962000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1013e-20, 6.6800e-42, 2.7564e-42, 4.1899e-42],\n", + " [3.4397e-09, 1.3551e-18, 4.7436e-19, 5.7860e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "963000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7480e-20, 6.0942e-42, 2.3598e-42, 3.6406e-42],\n", + " [3.1329e-09, 1.2975e-18, 4.3510e-19, 5.3601e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "964000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5446e-20, 5.6753e-42, 2.1062e-42, 3.2818e-42],\n", + " [2.9395e-09, 1.2540e-18, 4.0831e-19, 5.0657e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "965000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2345e-20, 5.1652e-42, 1.7811e-42, 2.8194e-42],\n", + " [2.6342e-09, 1.2042e-18, 3.7410e-19, 4.6909e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "966000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4463e-20, 5.4188e-42, 1.9716e-42, 3.0885e-42],\n", + " [2.8462e-09, 1.2309e-18, 3.9580e-19, 4.9264e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "967000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3354e-20, 5.1596e-42, 1.8273e-42, 2.8811e-42],\n", + " [2.7308e-09, 1.2023e-18, 3.7931e-19, 4.7430e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "968000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6586e-20, 5.5744e-42, 2.1272e-42, 3.3015e-42],\n", + " [3.0392e-09, 1.2462e-18, 4.1253e-19, 5.1042e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "969000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3808e-20, 5.1161e-42, 1.8343e-42, 2.8867e-42],\n", + " [2.7726e-09, 1.1984e-18, 3.8061e-19, 4.7544e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "970000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0567e-20, 4.4968e-42, 1.4714e-42, 2.3640e-42],\n", + " [2.4215e-09, 1.1272e-18, 3.3662e-19, 4.2651e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "971000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8943e-20, 5.7145e-42, 2.2883e-42, 3.5201e-42],\n", + " [3.2484e-09, 1.2675e-18, 4.3300e-19, 5.3237e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "972000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7076e-20, 5.3810e-42, 2.0795e-42, 3.2258e-42],\n", + " [3.0793e-09, 1.2317e-18, 4.1048e-19, 5.0769e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "973000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7982e-20, 5.4202e-42, 2.1328e-42, 3.2973e-42],\n", + " [3.1554e-09, 1.2352e-18, 4.1610e-19, 5.1354e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "974000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5817e-20, 5.0587e-42, 1.9044e-42, 2.9750e-42],\n", + " [2.9551e-09, 1.1953e-18, 3.9063e-19, 4.8555e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "975000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1251e-20, 4.3875e-42, 1.4714e-42, 2.3570e-42],\n", + " [2.4952e-09, 1.1206e-18, 3.3955e-19, 4.2937e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "976000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.0214e-20, 5.5309e-42, 2.2729e-42, 3.4850e-42],\n", + " [3.3455e-09, 1.2504e-18, 4.3362e-19, 5.3199e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "977000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8115e-20, 5.2044e-42, 2.0585e-42, 3.1866e-42],\n", + " [3.1624e-09, 1.2147e-18, 4.1042e-19, 5.0664e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "978000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6305e-20, 4.9130e-42, 1.8749e-42, 2.9259e-42],\n", + " [2.9962e-09, 1.1818e-18, 3.8953e-19, 4.8370e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "979000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5988e-20, 4.7952e-42, 1.8189e-42, 2.8432e-42],\n", + " [2.9624e-09, 1.1679e-18, 3.8280e-19, 4.7605e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "980000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2385e-20, 4.2992e-42, 1.4952e-42, 2.3836e-42],\n", + " [2.6097e-09, 1.1120e-18, 3.4443e-19, 4.3391e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "981000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2842e-20, 4.2922e-42, 1.5120e-42, 2.4046e-42],\n", + " [2.6530e-09, 1.1105e-18, 3.4641e-19, 4.3587e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "982000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5430e-20, 4.5780e-42, 1.7180e-42, 2.6975e-42],\n", + " [2.9084e-09, 1.1471e-18, 3.7318e-19, 4.6528e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "983000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5868e-20, 4.5710e-42, 1.7320e-42, 2.7157e-42],\n", + " [2.9455e-09, 1.1458e-18, 3.7475e-19, 4.6678e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "984000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4002e-20, 4.3426e-42, 1.5835e-42, 2.5041e-42],\n", + " [2.7745e-09, 1.1217e-18, 3.5857e-19, 4.4893e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "985000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0386e-20, 3.7877e-42, 1.2486e-42, 2.0193e-42],\n", + " [2.3868e-09, 1.0518e-18, 3.1412e-19, 3.9948e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "986000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4470e-20, 4.2712e-42, 1.5751e-42, 2.4873e-42],\n", + " [2.8120e-09, 1.1119e-18, 3.5732e-19, 4.4712e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "987000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1343e-20, 3.8255e-42, 1.2990e-42, 2.0893e-42],\n", + " [2.4877e-09, 1.0557e-18, 3.2098e-19, 4.0677e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "988000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1701e-20, 3.8087e-42, 1.3074e-42, 2.0991e-42],\n", + " [2.5224e-09, 1.0530e-18, 3.2200e-19, 4.0769e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "989000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3613e-21, 3.4360e-42, 1.0930e-42, 1.7867e-42],\n", + " [2.2540e-09, 1.0030e-18, 2.9155e-19, 3.7346e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "990000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1286e-20, 4.8107e-42, 2.0291e-42, 3.1193e-42],\n", + " [3.4052e-09, 1.1802e-18, 4.1374e-19, 5.0815e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "991000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4473e-20, 4.0385e-42, 1.4924e-42, 2.3626e-42],\n", + " [2.8044e-09, 1.0868e-18, 3.4882e-19, 4.3715e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "992000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3662e-20, 3.8802e-42, 1.4069e-42, 2.2365e-42],\n", + " [2.7206e-09, 1.0661e-18, 3.3738e-19, 4.2431e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "993000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7481e-20, 4.2053e-42, 1.6577e-42, 2.5910e-42],\n", + " [3.0704e-09, 1.1061e-18, 3.6945e-19, 4.5922e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "994000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3217e-20, 3.7653e-42, 1.3509e-42, 2.1552e-42],\n", + " [2.6761e-09, 1.0543e-18, 3.3140e-19, 4.1760e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "995000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6142e-20, 4.0287e-42, 1.5484e-42, 2.4341e-42],\n", + " [2.9528e-09, 1.0876e-18, 3.5724e-19, 4.4585e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "996000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6227e-20, 3.9825e-42, 1.5330e-42, 2.4102e-42],\n", + " [2.9566e-09, 1.0812e-18, 3.5516e-19, 4.4336e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "997000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4828e-20, 3.8480e-42, 1.4419e-42, 2.2813e-42],\n", + " [2.8344e-09, 1.0675e-18, 3.4530e-19, 4.3254e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "998000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5259e-20, 3.8494e-42, 1.4559e-42, 2.3009e-42],\n", + " [2.8719e-09, 1.0671e-18, 3.4713e-19, 4.3440e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "999000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2672e-20, 3.5201e-42, 1.2500e-42, 2.0039e-42],\n", + " [2.6142e-09, 1.0230e-18, 3.1891e-19, 4.0304e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.00200.00
1203.50196.50
2205.25194.75
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.00 200.00\n", + "1 203.50 196.50\n", + "2 205.25 194.75" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 15972.328125\n", + "1 11926.328125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05112.2500004160.250000
15365.5625003937.562500
25494.5156253828.515625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5112.250000 4160.250000\n", + "1 5365.562500 3937.562500\n", + "2 5494.515625 3828.515625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0128.500135.500
1130.250133.750
2131.125132.875
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 128.500 135.500\n", + "1 130.250 133.750\n", + "2 131.125 132.875" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidIndexError", + "evalue": "(slice(None, None, None), None)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3621\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3620\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 3621\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3622\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:136\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:142\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: '(slice(None, None, None), None)' is an invalid key", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mInvalidIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [18]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlearning\u001b[49m\u001b[43m,\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\pyplot.py:2757\u001b[0m, in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 2755\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mplot)\n\u001b[0;32m 2756\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot\u001b[39m(\u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, scaley\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m-> 2757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m gca()\u001b[38;5;241m.\u001b[39mplot(\n\u001b[0;32m 2758\u001b[0m \u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39mscalex, scaley\u001b[38;5;241m=\u001b[39mscaley,\n\u001b[0;32m 2759\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m\"\u001b[39m: data} \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {}), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_axes.py:1632\u001b[0m, in \u001b[0;36mAxes.plot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1391\u001b[0m \u001b[38;5;124;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[0;32m 1392\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1629\u001b[0m \u001b[38;5;124;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[0;32m 1630\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1631\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m cbook\u001b[38;5;241m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[38;5;241m.\u001b[39mLine2D)\n\u001b[1;32m-> 1632\u001b[0m lines \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_lines(\u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39mdata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)]\n\u001b[0;32m 1633\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[0;32m 1634\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_line(line)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:312\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[1;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 310\u001b[0m this \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 311\u001b[0m args \u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m1\u001b[39m:]\n\u001b[1;32m--> 312\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:487\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[1;34m(self, tup, kwargs, return_kwargs)\u001b[0m\n\u001b[0;32m 484\u001b[0m kw[prop_name] \u001b[38;5;241m=\u001b[39m val\n\u001b[0;32m 486\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(xy) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[1;32m--> 487\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43m_check_1d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxy\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 488\u001b[0m y \u001b[38;5;241m=\u001b[39m _check_1d(xy[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m 489\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\cbook\\__init__.py:1327\u001b[0m, in \u001b[0;36m_check_1d\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m warnings\u001b[38;5;241m.\u001b[39mcatch_warnings(record\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m w:\n\u001b[0;32m 1322\u001b[0m warnings\u001b[38;5;241m.\u001b[39mfilterwarnings(\n\u001b[0;32m 1323\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1324\u001b[0m category\u001b[38;5;241m=\u001b[39m\u001b[38;5;167;01mWarning\u001b[39;00m,\n\u001b[0;32m 1325\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSupport for multi-dimensional indexing\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m-> 1327\u001b[0m ndim \u001b[38;5;241m=\u001b[39m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mndim\n\u001b[0;32m 1328\u001b[0m \u001b[38;5;66;03m# we have definitely hit a pandas index or series object\u001b[39;00m\n\u001b[0;32m 1329\u001b[0m \u001b[38;5;66;03m# cast to a numpy array.\u001b[39;00m\n\u001b[0;32m 1330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(w) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\frame.py:3505\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 3503\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m 3504\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[1;32m-> 3505\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3506\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[0;32m 3507\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3628\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3623\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[0;32m 3624\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[0;32m 3625\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[0;32m 3626\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[0;32m 3627\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m-> 3628\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_check_indexing_error\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3629\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m 3631\u001b[0m \u001b[38;5;66;03m# GH#42269\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:5637\u001b[0m, in \u001b[0;36mIndex._check_indexing_error\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 5633\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_check_indexing_error\u001b[39m(\u001b[38;5;28mself\u001b[39m, key):\n\u001b[0;32m 5634\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_scalar(key):\n\u001b[0;32m 5635\u001b[0m \u001b[38;5;66;03m# if key is not a scalar, directly raise an error (the code below\u001b[39;00m\n\u001b[0;32m 5636\u001b[0m \u001b[38;5;66;03m# would convert to numpy arrays and raise later any way) - GH29926\u001b[39;00m\n\u001b[1;32m-> 5637\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n", + "\u001b[1;31mInvalidIndexError\u001b[0m: (slice(None, None, None), None)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning,loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test5-checkpoint.ipynb b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test5-checkpoint.ipynb new file mode 100644 index 0000000..cf4b490 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/.ipynb_checkpoints/test5-checkpoint.ipynb @@ -0,0 +1,3511 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=500_000, discountFactor =0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.2586, 0.2267, 0.2415, 0.2732], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2533, 0.2339, 0.2419, 0.2709], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2527, 0.2385, 0.2395, 0.2692], grad_fn=)\n", + "--------------------------------------------------\n", + "0 actions: tensor([2, 0, 1])\n", + "loss= tensor(8.5116, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([6.4173, 6.5452, 5.5306])\n", + "actionProbs tensor([[0.3393, 0.3253, 0.3351, 0.3369],\n", + " [0.3313, 0.3346, 0.3347, 0.3331],\n", + " [0.3294, 0.3401, 0.3302, 0.3299]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1817, 0.2163, 0.2985, 0.3034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2524, 0.2462, 0.2377, 0.2637], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3150, 0.2631, 0.1929, 0.2290], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 0, 1])\n", + "loss= tensor(8.1034, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([6.4204, 6.5859, 5.5493])\n", + "actionProbs tensor([[0.2481, 0.3045, 0.4168, 0.3884],\n", + " [0.3336, 0.3355, 0.3213, 0.3267],\n", + " [0.4182, 0.3600, 0.2619, 0.2849]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1334, 0.2362, 0.3270, 0.3034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2938, 0.2644, 0.2113, 0.2305], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3979, 0.2562, 0.1596, 0.1863], grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([1, 2, 0])\n", + "loss= tensor(8.1663, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([6.4144, 6.5158, 5.5876])\n", + "actionProbs tensor([[0.2371, 0.4195, 0.5818, 0.5352],\n", + " [0.3511, 0.3156, 0.2528, 0.2734],\n", + " [0.4118, 0.2649, 0.1654, 0.1913]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1264, 0.3190, 0.3194, 0.2352], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2714, 0.2118, 0.2268, 0.2900], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3312, 0.1451, 0.1824, 0.3413], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([1, 2, 3])\n", + "loss= tensor(7.7956, grad_fn=) , return= 16088.0625\n", + "discReturns/1000= tensor([6.4140, 6.5140, 5.5786])\n", + "actionProbs tensor([[0.2283, 0.5553, 0.5223, 0.3443],\n", + " [0.3600, 0.2707, 0.2723, 0.3118],\n", + " [0.4118, 0.1740, 0.2054, 0.3440]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2482, 0.2621, 0.2458, 0.2438], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0078, 0.5132, 0.1748, 0.3042], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2996e-04, 6.7104e-01, 1.0558e-01, 2.2274e-01],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([2, 3, 1])\n", + "loss= tensor(6.2015, grad_fn=) , return= 16181.078125\n", + "discReturns/1000= tensor([6.4200, 6.5586, 5.6428])\n", + "actionProbs tensor([[9.9646e-01, 7.5082e-01, 9.1119e-01, 8.4861e-01],\n", + " [3.4226e-03, 1.6053e-01, 7.0757e-02, 1.1563e-01],\n", + " [1.1663e-04, 8.8657e-02, 1.8050e-02, 3.5764e-02]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.6987, 0.0778, 0.1138, 0.1097], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2867, 0.1874, 0.2457, 0.2802], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0299, 0.3304, 0.2827, 0.3570], grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([0, 3, 2])\n", + "loss= tensor(7.0283, grad_fn=) , return= 16071.078125\n", + "discReturns/1000= tensor([6.4077, 6.4770, 5.6023])\n", + "actionProbs tensor([[0.9024, 0.4797, 0.5484, 0.4976],\n", + " [0.0932, 0.2908, 0.2981, 0.3200],\n", + " [0.0043, 0.2295, 0.1535, 0.1824]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.4281, 0.1196, 0.1586, 0.2937], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2674, 0.1681, 0.2319, 0.3326], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1276, 0.2072, 0.3222, 0.3430], grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([2, 3, 3])\n", + "loss= tensor(9.3096, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([6.4197, 6.5570, 5.6348])\n", + "actionProbs tensor([[0.5192, 0.2342, 0.2148, 0.2960],\n", + " [0.3081, 0.3128, 0.2983, 0.3183],\n", + " [0.1727, 0.4529, 0.4869, 0.3857]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3398, 0.1476, 0.1862, 0.3263], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2662, 0.1662, 0.2260, 0.3416], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1597, 0.1825, 0.2953, 0.3625], grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([3, 1, 2])\n", + "loss= tensor(8.3283, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([6.4216, 6.5917, 5.5836])\n", + "actionProbs tensor([[0.4162, 0.2694, 0.2361, 0.2880],\n", + " [0.3417, 0.3180, 0.3004, 0.3160],\n", + " [0.2421, 0.4126, 0.4635, 0.3960]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0036, 0.0059, 0.0867, 0.9037], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0407, 0.0646, 0.2431, 0.6516], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1662, 0.3718, 0.2997, 0.1622], grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([3, 3, 0])\n", + "loss= tensor(3.7994, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[0.0040, 0.0030, 0.0450, 0.3491],\n", + " [0.0600, 0.0434, 0.1674, 0.3337],\n", + " [0.9360, 0.9536, 0.7876, 0.3171]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4876e-05, 9.3187e-04, 8.7202e-03, 9.9030e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0129, 0.0520, 0.1422, 0.7930], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3535, 0.3230, 0.2566, 0.0670], grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6147, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[6.3213e-06, 1.4238e-04, 1.6296e-03, 2.8665e-01],\n", + " [2.5665e-03, 1.1246e-02, 3.7628e-02, 3.2510e-01],\n", + " [9.9743e-01, 9.8861e-01, 9.6074e-01, 3.8824e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5217e-05, 3.0186e-04, 5.6817e-03, 9.9400e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0118, 0.0418, 0.1364, 0.8100], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3650, 0.3637, 0.2124, 0.0588], grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.9327, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[8.9273e-06, 1.7587e-04, 5.2892e-03, 5.6887e-01],\n", + " [4.1136e-03, 1.4426e-02, 7.5196e-02, 2.7456e-01],\n", + " [9.9588e-01, 9.8540e-01, 9.1952e-01, 1.5657e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2717e-05, 9.0861e-04, 2.7069e-03, 9.9635e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0107, 0.0507, 0.0994, 0.8392], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2628, 0.2863, 0.3678, 0.0831], grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6499, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[2.2516e-05, 5.6284e-04, 1.2880e-03, 4.7417e-01],\n", + " [5.6598e-03, 2.4260e-02, 3.6513e-02, 3.0839e-01],\n", + " [9.9432e-01, 9.7518e-01, 9.6220e-01, 2.1744e-01]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.8378e-05, 6.0701e-04, 2.0308e-03, 9.9734e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0076, 0.0434, 0.0840, 0.8649], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2351, 0.3016, 0.3613, 0.1021], grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6850, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.8482e-05, 4.6682e-04, 1.2835e-03, 4.8667e-01],\n", + " [5.5341e-03, 2.4013e-02, 3.8230e-02, 3.0380e-01],\n", + " [9.9445e-01, 9.7552e-01, 9.6049e-01, 2.0953e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3697, 0.4972, 0.1120, 0.0211], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2470e-01, 8.7203e-01, 3.2162e-03, 4.9112e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0515e-02, 9.4913e-01, 3.5373e-04, 1.1714e-06],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([1, 0, 1])\n", + "loss= tensor(7.0830, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([6.4122, 6.5047, 5.5121])\n", + "actionProbs tensor([[9.9718e-01, 9.8445e-01, 9.9977e-01, 9.9998e-01],\n", + " [2.7010e-03, 1.3865e-02, 2.3050e-04, 1.8725e-05],\n", + " [1.2197e-04, 1.6822e-03, 2.8261e-06, 4.9786e-08]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3182, 0.5391, 0.1194, 0.0233], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5509e-03, 9.9830e-01, 1.4989e-04, 1.8189e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1629e-05, 9.9995e-01, 2.5145e-06, 5.5513e-09],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9848, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[9.9998e-01, 9.9152e-01, 9.9999e-01, 1.0000e+00],\n", + " [2.0585e-05, 7.7546e-03, 5.2999e-06, 3.3008e-07],\n", + " [6.3944e-08, 7.2479e-04, 8.2962e-09, 9.3999e-11]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3036, 0.5525, 0.1215, 0.0224], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2539e-04, 9.9963e-01, 4.1779e-05, 4.9783e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8154e-06, 9.9999e-01, 4.2360e-07, 9.7779e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9711, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9643e-01, 1.0000e+00, 1.0000e+00],\n", + " [1.9819e-06, 3.3333e-03, 6.3567e-07, 4.1076e-08],\n", + " [2.5657e-09, 2.4154e-04, 4.6686e-10, 5.8440e-12]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2998, 0.5370, 0.1414, 0.0217], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3903e-04, 9.9984e-01, 2.3061e-05, 2.4225e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8420e-06, 1.0000e+00, 1.7909e-07, 3.8110e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9668, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9851e-01, 1.0000e+00, 1.0000e+00],\n", + " [3.5205e-07, 1.4113e-03, 1.2378e-07, 8.4585e-09],\n", + " [2.5367e-10, 7.6768e-05, 5.2276e-11, 7.2368e-13]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3207, 0.5181, 0.1460, 0.0152], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3543e-05, 9.9991e-01, 1.2442e-05, 9.3556e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5673e-07, 1.0000e+00, 7.5506e-08, 1.1750e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9652, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9928e-01, 1.0000e+00, 1.0000e+00],\n", + " [8.2480e-08, 6.9354e-04, 3.0638e-08, 2.2169e-09],\n", + " [3.6713e-11, 3.0005e-05, 8.0429e-12, 1.2045e-13]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3383, 0.4909, 0.1582, 0.0127], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8787e-05, 9.9995e-01, 6.9842e-06, 4.2598e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0504e-07, 1.0000e+00, 3.2688e-08, 4.1895e-11],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9645, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9955e-01, 1.0000e+00, 1.0000e+00],\n", + " [2.4289e-08, 4.3134e-04, 9.3548e-09, 7.1231e-10],\n", + " [7.2215e-12, 1.6308e-05, 1.6553e-12, 2.6486e-14]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1905, 0.7251, 0.0794, 0.0051], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9574e-05, 9.9997e-01, 1.4276e-06, 1.8202e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1287e-07, 1.0000e+00, 3.5025e-09, 1.5485e-11],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9647, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9951e-01, 1.0000e+00, 1.0000e+00],\n", + " [5.3153e-08, 4.7185e-04, 6.1542e-09, 1.2312e-09],\n", + " [1.3510e-11, 1.6663e-05, 5.3320e-13, 3.6991e-14]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1986, 0.7299, 0.0673, 0.0042], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8482e-06, 1.0000e+00, 2.6069e-07, 4.6258e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5360e-09, 1.0000e+00, 2.6356e-10, 1.9015e-12],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9638, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9995e-01, 1.0000e+00, 1.0000e+00],\n", + " [3.3424e-10, 4.9210e-05, 1.3919e-10, 3.9621e-11],\n", + " [7.4174e-15, 5.7078e-07, 1.6322e-15, 1.8890e-16]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1972, 0.7426, 0.0568, 0.0035], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9374e-07, 1.0000e+00, 7.9414e-08, 1.4723e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0885e-10, 1.0000e+00, 4.1539e-11, 3.1162e-13],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "21000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 9.9999e-01, 1.0000e+00, 1.0000e+00],\n", + " [2.3388e-11, 1.2577e-05, 1.3068e-11, 3.9356e-12],\n", + " [1.4395e-16, 7.5111e-08, 4.0825e-17, 4.9747e-18]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2287, 0.7100, 0.0577, 0.0036], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1899e-07, 1.0000e+00, 3.2236e-08, 6.1867e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4805e-10, 1.0000e+00, 1.0156e-11, 7.8457e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.3540e-12, 4.9339e-06, 1.9585e-12, 5.9801e-13],\n", + " [9.0227e-18, 1.9633e-08, 2.4552e-18, 3.0177e-19]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.2510, 0.6890, 0.0567, 0.0033], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0986e-07, 1.0000e+00, 1.4619e-08, 2.6538e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1433e-11, 1.0000e+00, 2.8927e-12, 2.0861e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.5219e-13, 2.4944e-06, 4.4320e-13, 1.3669e-13],\n", + " [1.0287e-18, 7.2863e-09, 2.5616e-19, 3.1387e-20]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2543, 0.6870, 0.0556, 0.0031], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7060e-08, 1.0000e+00, 7.5801e-09, 1.3230e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9835e-11, 1.0000e+00, 1.0288e-12, 7.0488e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8796e-13, 1.2191e-06, 1.1417e-13, 3.5628e-14],\n", + " [1.3766e-19, 2.5685e-09, 3.2646e-20, 3.9993e-21]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2706, 0.6732, 0.0517, 0.0045], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2764e-08, 1.0000e+00, 3.8387e-09, 1.0760e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1982e-12, 1.0000e+00, 3.3819e-13, 3.6984e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.5756e-14, 6.8400e-07, 3.4187e-14, 1.1091e-14],\n", + " [2.1841e-20, 1.0708e-09, 4.7151e-21, 5.9682e-22]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2393, 0.7125, 0.0448, 0.0034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0036e-08, 1.0000e+00, 2.4947e-09, 6.1273e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6171e-12, 1.0000e+00, 2.0062e-13, 1.9072e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9218e-14, 3.2208e-07, 1.2767e-14, 4.1169e-15],\n", + " [5.0811e-21, 3.6954e-10, 1.1780e-21, 1.4703e-22]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2369, 0.7325, 0.0286, 0.0020], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7278e-08, 1.0000e+00, 1.5155e-09, 3.3104e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8506e-12, 1.0000e+00, 1.1481e-13, 9.5265e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.5239e-15, 1.5954e-07, 6.1895e-15, 1.9765e-15],\n", + " [1.5847e-21, 1.3308e-10, 3.9114e-22, 4.7447e-23]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1775, 0.8058, 0.0157, 0.0010], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0847e-08, 1.0000e+00, 7.4647e-10, 1.4703e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2394e-12, 1.0000e+00, 4.9859e-14, 3.6364e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2649e-15, 8.6615e-08, 3.3111e-15, 1.0544e-15],\n", + " [5.3176e-22, 5.2308e-11, 1.3356e-22, 1.5748e-23]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1566e-01, 8.7251e-01, 1.1127e-02, 6.9700e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5685e-09, 1.0000e+00, 4.9123e-10, 9.7605e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3417e-12, 1.0000e+00, 3.2383e-14, 2.3767e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1695e-15, 4.3784e-08, 1.6866e-15, 5.3497e-16],\n", + " [1.9010e-22, 1.8783e-11, 4.7697e-23, 5.5883e-24]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5606e-02, 9.0454e-01, 9.1949e-03, 6.5668e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6807e-09, 1.0000e+00, 3.5039e-10, 7.6765e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8114e-13, 1.0000e+00, 2.3749e-14, 1.9406e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1057e-15, 2.2356e-08, 7.7059e-16, 2.3639e-16],\n", + " [7.3431e-23, 7.0831e-12, 1.6548e-23, 1.8933e-24]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6920e-02, 9.3530e-01, 7.1973e-03, 5.8179e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0711e-09, 1.0000e+00, 2.4896e-10, 6.0438e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2358e-13, 1.0000e+00, 1.6418e-14, 1.4798e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1040e-16, 1.2096e-08, 3.9133e-16, 1.1752e-16],\n", + " [2.7940e-23, 2.7268e-12, 5.8176e-24, 6.4870e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6236e-02, 9.5781e-01, 5.4622e-03, 4.9332e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9294e-09, 1.0000e+00, 1.7680e-10, 4.7449e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7823e-13, 1.0000e+00, 1.1446e-14, 1.1367e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.2512e-16, 6.3751e-09, 1.9764e-16, 5.8731e-17],\n", + " [1.0084e-23, 1.0087e-12, 2.0245e-24, 2.2260e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2445e-02, 9.7299e-01, 4.1493e-03, 4.1741e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1523e-09, 1.0000e+00, 1.2314e-10, 3.6802e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1408e-13, 1.0000e+00, 7.7025e-15, 8.5867e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8553e-16, 3.7141e-09, 1.0725e-16, 3.1862e-17],\n", + " [3.9733e-24, 4.2814e-13, 7.7330e-25, 8.5693e-26]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.3699e-02, 9.8299e-01, 2.9732e-03, 3.3332e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8968e-10, 1.0000e+00, 8.4996e-11, 2.9097e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2317e-13, 1.0000e+00, 5.2250e-15, 6.8599e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.0025e-16, 2.0257e-09, 5.6925e-17, 1.7383e-17],\n", + " [1.4567e-24, 1.6482e-13, 2.8472e-25, 3.3344e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5300e-03, 9.9018e-01, 2.0273e-03, 2.5946e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6582e-10, 1.0000e+00, 5.3643e-11, 2.1657e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1696e-14, 1.0000e+00, 3.1936e-15, 5.1250e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1553e-17, 1.2796e-09, 3.3525e-17, 1.0576e-17],\n", + " [6.3323e-25, 7.8050e-14, 1.2175e-25, 1.5265e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1973e-03, 9.9279e-01, 1.7551e-03, 2.5455e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1528e-10, 1.0000e+00, 5.9251e-11, 2.8249e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7870e-14, 1.0000e+00, 4.0557e-15, 7.9765e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0994e-17, 6.8067e-10, 2.2813e-17, 7.4994e-18],\n", + " [3.1642e-25, 2.8624e-14, 6.5669e-26, 8.9050e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9267e-03, 9.9566e-01, 1.2145e-03, 1.9928e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6421e-10, 1.0000e+00, 3.7780e-11, 2.1187e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8044e-14, 1.0000e+00, 2.4962e-15, 5.9901e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3986e-17, 4.2937e-10, 1.3299e-17, 4.5452e-18],\n", + " [1.2932e-25, 1.3555e-14, 2.7740e-26, 4.0568e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4849e-03, 9.9765e-01, 7.2241e-04, 1.3922e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4091e-11, 1.0000e+00, 1.3612e-11, 9.8666e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1952e-15, 1.0000e+00, 6.9753e-16, 2.3141e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.2673e-17, 3.4871e-10, 6.5552e-18, 2.4656e-18],\n", + " [4.6326e-26, 9.5829e-15, 9.2312e-27, 1.5892e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3101e-03, 9.9767e-01, 8.4527e-04, 1.7901e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7293e-11, 1.0000e+00, 2.7787e-11, 2.2622e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3089e-14, 1.0000e+00, 1.9747e-15, 7.5382e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.0597e-17, 1.8003e-10, 5.9046e-18, 2.2697e-18],\n", + " [3.3695e-26, 3.3805e-15, 7.8789e-27, 1.4202e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8588e-04, 9.9900e-01, 4.1200e-04, 1.0480e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7074e-11, 1.0000e+00, 7.5580e-12, 7.8085e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1387e-15, 1.0000e+00, 4.0687e-16, 2.0817e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "40000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1889e-18, 1.7629e-10, 3.2308e-18, 1.3122e-18],\n", + " [1.3898e-26, 3.1605e-15, 3.1180e-27, 6.2713e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0990e-04, 9.9903e-01, 4.3681e-04, 1.1960e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1737e-11, 1.0000e+00, 1.2825e-11, 1.4480e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4031e-15, 1.0000e+00, 9.3137e-16, 5.3288e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "41000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.3406e-18, 1.0081e-10, 2.9569e-18, 1.2193e-18],\n", + " [1.0987e-26, 1.3246e-15, 2.8216e-27, 5.8963e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4064e-04, 9.9934e-01, 3.0372e-04, 1.1202e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6588e-12, 1.0000e+00, 3.6420e-12, 6.8190e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0277e-16, 1.0000e+00, 1.5348e-16, 1.6749e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9000e-18, 8.0850e-11, 9.6885e-19, 4.9184e-19],\n", + " [1.6343e-27, 7.8275e-16, 3.9528e-28, 1.1696e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8178e-04, 9.9945e-01, 2.6597e-04, 1.0324e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8803e-12, 1.0000e+00, 4.5437e-12, 8.9914e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8361e-16, 1.0000e+00, 2.6232e-16, 3.0829e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.7176e-18, 5.3125e-11, 9.0706e-19, 4.6242e-19],\n", + " [1.7358e-27, 4.6183e-16, 4.5523e-28, 1.3783e-28]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.5037e-04, 9.9951e-01, 2.4435e-04, 9.8391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7690e-12, 1.0000e+00, 5.9524e-12, 1.2235e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0255e-15, 1.0000e+00, 4.6344e-16, 5.7392e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.5880e-18, 3.5295e-11, 8.5936e-19, 4.3866e-19],\n", + " [1.8794e-27, 2.7572e-16, 5.2266e-28, 1.6075e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3897e-04, 9.9952e-01, 2.4183e-04, 9.9783e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6783e-12, 1.0000e+00, 8.3102e-12, 1.7513e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6344e-15, 1.0000e+00, 8.3137e-16, 1.0685e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.4949e-18, 2.3949e-11, 8.2259e-19, 4.2013e-19],\n", + " [1.8783e-27, 1.5978e-16, 5.4903e-28, 1.7102e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7100e-04, 9.9931e-01, 3.6235e-04, 1.5864e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0651e-12, 1.0000e+00, 3.5875e-12, 7.5840e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8209e-16, 1.0000e+00, 1.6320e-16, 2.0493e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.2062e-19, 2.1916e-11, 2.1683e-19, 1.0470e-19],\n", + " [2.2877e-28, 1.0246e-16, 4.6113e-29, 1.3226e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3093e-04, 9.9945e-01, 2.9096e-04, 1.2960e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5180e-12, 1.0000e+00, 3.2933e-12, 7.0645e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8415e-16, 1.0000e+00, 1.7893e-16, 2.3057e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8947e-19, 1.8226e-11, 2.0618e-19, 9.9295e-20],\n", + " [2.5283e-28, 8.6218e-17, 5.2990e-29, 1.5331e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0591e-04, 9.9954e-01, 2.4488e-04, 1.1067e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3339e-12, 1.0000e+00, 3.2774e-12, 7.1098e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3171e-16, 1.0000e+00, 2.1635e-16, 2.8482e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6056e-19, 1.4638e-11, 1.9582e-19, 9.3996e-20],\n", + " [2.8178e-28, 6.9162e-17, 6.1076e-29, 1.7792e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1836e-05, 9.9959e-01, 2.1929e-04, 1.0029e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4910e-12, 1.0000e+00, 3.5707e-12, 7.8113e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4168e-16, 1.0000e+00, 2.8820e-16, 3.8595e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3474e-19, 1.1441e-11, 1.8621e-19, 8.9079e-20],\n", + " [3.1279e-28, 5.3053e-17, 6.9696e-29, 2.0409e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5961e-05, 9.9961e-01, 2.1013e-04, 9.6930e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0257e-12, 1.0000e+00, 4.2387e-12, 9.3257e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4091e-16, 1.0000e+00, 4.1346e-16, 5.6113e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1360e-19, 8.8351e-12, 1.7815e-19, 8.4970e-20],\n", + " [3.3531e-28, 3.8918e-17, 7.6544e-29, 2.2521e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6876e-05, 9.9960e-01, 2.1569e-04, 1.0005e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0597e-12, 1.0000e+00, 5.4333e-12, 1.2000e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0691e-15, 1.0000e+00, 6.1952e-16, 8.4960e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9729e-19, 6.8243e-12, 1.7183e-19, 8.1818e-20],\n", + " [3.3263e-28, 2.7039e-17, 7.7632e-29, 2.2953e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0607e-05, 9.9958e-01, 2.2777e-04, 1.0611e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5486e-12, 1.0000e+00, 7.1428e-12, 1.5822e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5769e-15, 1.0000e+00, 9.4119e-16, 1.3012e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8407e-19, 5.3162e-12, 1.6665e-19, 7.9236e-20],\n", + " [3.2933e-28, 1.8931e-17, 7.8196e-29, 2.3205e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1508e-05, 9.9975e-01, 1.1844e-04, 9.3568e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1663e-13, 1.0000e+00, 1.6288e-13, 1.0591e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1825e-18, 1.0000e+00, 4.3018e-18, 2.3474e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.9527e-20, 1.0511e-11, 1.4452e-20, 1.1895e-20],\n", + " [4.8520e-30, 3.8872e-17, 1.4115e-30, 9.7495e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.3723e-05, 9.9979e-01, 9.8618e-05, 7.8933e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1077e-13, 1.0000e+00, 1.5952e-13, 1.0467e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2282e-18, 1.0000e+00, 5.4193e-18, 3.0158e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.7200e-20, 8.2827e-12, 1.3394e-20, 1.0981e-20],\n", + " [6.0963e-30, 3.3016e-17, 1.8139e-30, 1.2612e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0493e-05, 9.9981e-01, 9.0659e-05, 7.3363e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2102e-13, 1.0000e+00, 1.7794e-13, 1.1774e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2069e-18, 1.0000e+00, 7.4194e-18, 4.1953e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.5698e-20, 6.4765e-12, 1.2709e-20, 1.0392e-20],\n", + " [6.8995e-30, 2.5640e-17, 2.0979e-30, 1.4660e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9635e-05, 9.9981e-01, 8.9362e-05, 7.3031e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4451e-13, 1.0000e+00, 2.1626e-13, 1.4426e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1495e-17, 1.0000e+00, 1.0715e-17, 6.1373e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.4626e-20, 5.0510e-12, 1.2221e-20, 9.9752e-21],\n", + " [7.3764e-30, 1.9020e-17, 2.2802e-30, 1.5981e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0075e-05, 9.9980e-01, 9.1933e-05, 7.5801e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8058e-13, 1.0000e+00, 2.7474e-13, 1.8468e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6533e-17, 1.0000e+00, 1.5789e-17, 9.1363e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3837e-20, 3.9708e-12, 1.1865e-20, 9.6724e-21],\n", + " [7.6707e-30, 1.3956e-17, 2.3965e-30, 1.6818e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1326e-05, 9.9979e-01, 9.6814e-05, 8.0391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2950e-13, 1.0000e+00, 3.5386e-13, 2.3934e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3738e-17, 1.0000e+00, 2.3117e-17, 1.3486e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3243e-20, 3.1733e-12, 1.1596e-20, 9.4458e-21],\n", + " [7.8112e-30, 1.0310e-17, 2.4613e-30, 1.7293e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3119e-05, 9.9978e-01, 1.0313e-04, 8.6070e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9159e-13, 1.0000e+00, 4.5381e-13, 3.0836e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3418e-17, 1.0000e+00, 3.3068e-17, 1.9421e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "59000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2794e-20, 2.5895e-12, 1.1392e-20, 9.2751e-21],\n", + " [7.8004e-30, 7.7323e-18, 2.4788e-30, 1.7444e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5152e-05, 9.9976e-01, 1.1008e-04, 9.2242e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6534e-13, 1.0000e+00, 5.7263e-13, 3.9050e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5727e-17, 1.0000e+00, 4.5846e-17, 2.7076e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2439e-20, 2.1595e-12, 1.1230e-20, 9.1397e-21],\n", + " [7.7311e-30, 5.9445e-18, 2.4751e-30, 1.7445e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7201e-05, 9.9975e-01, 1.1706e-04, 9.8419e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4838e-13, 1.0000e+00, 7.0698e-13, 4.8360e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0693e-17, 1.0000e+00, 6.1530e-17, 3.6509e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "61000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2140e-20, 1.8373e-12, 1.1093e-20, 9.0256e-21],\n", + " [7.6722e-30, 4.7038e-18, 2.4718e-30, 1.7445e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9207e-05, 9.9973e-01, 1.2387e-04, 1.0445e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3938e-13, 1.0000e+00, 8.5476e-13, 5.8624e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8274e-17, 1.0000e+00, 8.0113e-17, 4.7731e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1882e-20, 1.5910e-12, 1.0975e-20, 8.9273e-21],\n", + " [7.6199e-30, 3.8178e-18, 2.4684e-30, 1.7441e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1149e-05, 9.9972e-01, 1.3048e-04, 1.1030e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3723e-13, 1.0000e+00, 1.0144e-12, 6.9729e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8411e-17, 1.0000e+00, 1.0157e-16, 6.0729e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1661e-20, 1.3992e-12, 1.0874e-20, 8.8429e-21],\n", + " [7.5768e-30, 3.1690e-18, 2.4663e-30, 1.7444e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.3010e-05, 9.9970e-01, 1.3682e-04, 1.1592e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4081e-13, 1.0000e+00, 1.1840e-12, 8.1555e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2097e-16, 1.0000e+00, 1.2580e-16, 7.5451e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1463e-20, 1.2465e-12, 1.0783e-20, 8.7668e-21],\n", + " [7.5362e-30, 2.6801e-18, 2.4635e-30, 1.7439e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4782e-05, 9.9969e-01, 1.4285e-04, 1.2127e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4920e-13, 1.0000e+00, 1.3618e-12, 9.3972e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4584e-16, 1.0000e+00, 1.5266e-16, 9.1813e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1286e-20, 1.1228e-12, 1.0701e-20, 8.6985e-21],\n", + " [7.5003e-30, 2.3037e-18, 2.4613e-30, 1.7437e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6480e-05, 9.9968e-01, 1.4863e-04, 1.2641e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6227e-13, 1.0000e+00, 1.5478e-12, 1.0698e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7305e-16, 1.0000e+00, 1.8220e-16, 1.0985e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1133e-20, 1.0211e-12, 1.0630e-20, 8.6391e-21],\n", + " [7.4732e-30, 2.0079e-18, 2.4606e-30, 1.7443e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8127e-05, 9.9967e-01, 1.5423e-04, 1.3138e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0798e-12, 1.0000e+00, 1.7415e-12, 1.2054e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0245e-16, 1.0000e+00, 2.1427e-16, 1.2947e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0996e-20, 9.3613e-13, 1.0567e-20, 8.5859e-21],\n", + " [7.4418e-30, 1.7697e-18, 2.4577e-30, 1.7433e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9731e-05, 9.9965e-01, 1.5972e-04, 1.3626e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2018e-12, 1.0000e+00, 1.9436e-12, 1.3471e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3405e-16, 1.0000e+00, 2.4898e-16, 1.5075e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0870e-20, 8.6389e-13, 1.0509e-20, 8.5380e-21],\n", + " [7.4018e-30, 1.5732e-18, 2.4516e-30, 1.7400e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1271e-05, 9.9964e-01, 1.6501e-04, 1.4098e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3273e-12, 1.0000e+00, 2.1522e-12, 1.4938e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6772e-16, 1.0000e+00, 2.8620e-16, 1.7364e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0750e-20, 8.0180e-13, 1.0454e-20, 8.4924e-21],\n", + " [7.3621e-30, 1.4104e-18, 2.4453e-30, 1.7365e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2752e-05, 9.9963e-01, 1.7013e-04, 1.4554e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4558e-12, 1.0000e+00, 2.3667e-12, 1.6447e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0336e-16, 1.0000e+00, 3.2581e-16, 1.9805e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0634e-20, 7.4794e-13, 1.0401e-20, 8.4487e-21],\n", + " [7.3218e-30, 1.2737e-18, 2.4383e-30, 1.7326e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4191e-05, 9.9962e-01, 1.7511e-04, 1.5000e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5877e-12, 1.0000e+00, 2.5876e-12, 1.8003e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4106e-16, 1.0000e+00, 3.6798e-16, 2.2409e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0525e-20, 7.0083e-13, 1.0352e-20, 8.4083e-21],\n", + " [7.2840e-30, 1.1578e-18, 2.4320e-30, 1.7290e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5587e-05, 9.9961e-01, 1.7994e-04, 1.5432e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7230e-12, 1.0000e+00, 2.8144e-12, 1.9603e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8088e-16, 1.0000e+00, 4.1267e-16, 2.5173e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0426e-20, 6.5926e-13, 1.0307e-20, 8.3715e-21],\n", + " [7.2504e-30, 1.0586e-18, 2.4268e-30, 1.7261e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6941e-05, 9.9960e-01, 1.8464e-04, 1.5852e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8616e-12, 1.0000e+00, 3.0475e-12, 2.1249e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2289e-16, 1.0000e+00, 4.6003e-16, 2.8106e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0338e-20, 6.2232e-13, 1.0268e-20, 8.3386e-21],\n", + " [7.2228e-30, 9.7290e-19, 2.4230e-30, 1.7242e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([5.8235e-05, 9.9959e-01, 1.8916e-04, 1.6258e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0022e-12, 1.0000e+00, 3.2847e-12, 2.2927e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6664e-16, 1.0000e+00, 5.0962e-16, 3.1184e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0255e-20, 5.8940e-13, 1.0231e-20, 8.3079e-21],\n", + " [7.1973e-30, 8.9857e-19, 2.4199e-30, 1.7228e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9513e-05, 9.9958e-01, 1.9362e-04, 1.6659e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1464e-12, 1.0000e+00, 3.5287e-12, 2.4654e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1266e-16, 1.0000e+00, 5.6197e-16, 3.4439e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0179e-20, 5.5973e-13, 1.0197e-20, 8.2802e-21],\n", + " [7.1748e-30, 8.3324e-19, 2.4175e-30, 1.7218e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0760e-05, 9.9957e-01, 1.9797e-04, 1.7051e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2937e-12, 1.0000e+00, 3.7781e-12, 2.6422e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6072e-16, 1.0000e+00, 6.1683e-16, 3.7856e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0109e-20, 5.3291e-13, 1.0166e-20, 8.2544e-21],\n", + " [7.1539e-30, 7.7554e-19, 2.4153e-30, 1.7210e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1969e-05, 9.9956e-01, 2.0221e-04, 1.7433e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4431e-12, 1.0000e+00, 4.0321e-12, 2.8225e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1068e-16, 1.0000e+00, 6.7415e-16, 4.1432e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0040e-20, 5.0854e-13, 1.0136e-20, 8.2301e-21],\n", + " [7.1345e-30, 7.2430e-19, 2.4137e-30, 1.7207e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3138e-05, 9.9955e-01, 2.0634e-04, 1.7805e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5944e-12, 1.0000e+00, 4.2905e-12, 3.0060e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6238e-16, 1.0000e+00, 7.3385e-16, 4.5160e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "78000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9974e-20, 4.8629e-13, 1.0107e-20, 8.2064e-21],\n", + " [7.1153e-30, 6.7852e-19, 2.4121e-30, 1.7202e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4299e-05, 9.9954e-01, 2.1043e-04, 1.8174e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7500e-12, 1.0000e+00, 4.5559e-12, 3.1946e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1663e-16, 1.0000e+00, 7.9653e-16, 4.9080e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9909e-20, 4.6571e-13, 1.0078e-20, 8.1828e-21],\n", + " [7.0966e-30, 6.3703e-19, 2.4102e-30, 1.7196e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5427e-05, 9.9953e-01, 2.1440e-04, 1.8532e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9065e-12, 1.0000e+00, 4.8230e-12, 3.3846e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7227e-16, 1.0000e+00, 8.6097e-16, 5.3113e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9847e-20, 4.4699e-13, 1.0051e-20, 8.1599e-21],\n", + " [7.0790e-30, 6.0002e-19, 2.4084e-30, 1.7189e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6548e-05, 9.9953e-01, 2.1836e-04, 1.8890e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0667e-12, 1.0000e+00, 5.0973e-12, 3.5798e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3028e-16, 1.0000e+00, 9.2836e-16, 5.7337e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "81000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9787e-20, 4.2957e-13, 1.0023e-20, 8.1369e-21],\n", + " [7.0611e-30, 5.6623e-19, 2.4062e-30, 1.7179e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7644e-05, 9.9952e-01, 2.2222e-04, 1.9239e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2291e-12, 1.0000e+00, 5.3753e-12, 3.7779e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9012e-16, 1.0000e+00, 9.9801e-16, 6.1707e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9727e-20, 4.1344e-13, 9.9960e-21, 8.1147e-21],\n", + " [7.0423e-30, 5.3543e-19, 2.4035e-30, 1.7165e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8694e-05, 9.9951e-01, 2.2590e-04, 1.9572e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3914e-12, 1.0000e+00, 5.6529e-12, 3.9757e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5106e-16, 1.0000e+00, 1.0690e-15, 6.6166e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9669e-20, 3.9859e-13, 9.9696e-21, 8.0929e-21],\n", + " [7.0243e-30, 5.0760e-19, 2.4009e-30, 1.7152e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([6.9756e-05, 9.9950e-01, 2.2961e-04, 1.9907e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5586e-12, 1.0000e+00, 5.9386e-12, 4.1793e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0148e-15, 1.0000e+00, 1.1433e-15, 7.0831e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9613e-20, 3.8465e-13, 9.9438e-21, 8.0714e-21],\n", + " [7.0071e-30, 4.8190e-19, 2.3983e-30, 1.7138e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0822e-05, 9.9949e-01, 2.3333e-04, 2.0243e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7300e-12, 1.0000e+00, 6.2320e-12, 4.3885e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0811e-15, 1.0000e+00, 1.2208e-15, 7.5705e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9558e-20, 3.7153e-13, 9.9181e-21, 8.0501e-21],\n", + " [6.9893e-30, 4.5808e-19, 2.3955e-30, 1.7123e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1818e-05, 9.9949e-01, 2.3681e-04, 2.0558e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8988e-12, 1.0000e+00, 6.5209e-12, 4.5946e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1477e-15, 1.0000e+00, 1.2986e-15, 8.0604e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9505e-20, 3.5947e-13, 9.8934e-21, 8.0297e-21],\n", + " [6.9727e-30, 4.3655e-19, 2.3928e-30, 1.7107e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2805e-05, 9.9948e-01, 2.4027e-04, 2.0872e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0704e-12, 1.0000e+00, 6.8148e-12, 4.8044e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2161e-15, 1.0000e+00, 1.3785e-15, 8.5637e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9456e-20, 3.4818e-13, 9.8702e-21, 8.0103e-21],\n", + " [6.9539e-30, 4.1655e-19, 2.3887e-30, 1.7082e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3813e-05, 9.9947e-01, 2.4375e-04, 2.1187e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2473e-12, 1.0000e+00, 7.1167e-12, 5.0199e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2874e-15, 1.0000e+00, 1.4617e-15, 9.0868e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9409e-20, 3.3748e-13, 9.8478e-21, 7.9916e-21],\n", + " [6.9353e-30, 3.9785e-19, 2.3845e-30, 1.7054e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4810e-05, 9.9946e-01, 2.4721e-04, 2.1499e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4267e-12, 1.0000e+00, 7.4232e-12, 5.2387e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3607e-15, 1.0000e+00, 1.5473e-15, 9.6263e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9362e-20, 3.2739e-13, 9.8257e-21, 7.9733e-21],\n", + " [6.9167e-30, 3.8047e-19, 2.3802e-30, 1.7027e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5816e-05, 9.9946e-01, 2.5067e-04, 2.1811e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6106e-12, 1.0000e+00, 7.7368e-12, 5.4625e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4369e-15, 1.0000e+00, 1.6362e-15, 1.0186e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9317e-20, 3.1781e-13, 9.8039e-21, 7.9551e-21],\n", + " [6.8990e-30, 3.6421e-19, 2.3760e-30, 1.7000e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8372e-06, 9.9995e-01, 2.4608e-05, 1.7789e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5244e-14, 1.0000e+00, 5.9721e-14, 3.2052e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1065e-18, 1.0000e+00, 2.1090e-18, 9.1354e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6780e-21, 1.2671e-12, 3.0749e-21, 2.2830e-21],\n", + " [1.6216e-31, 1.0021e-18, 8.5878e-32, 5.1462e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8165e-06, 9.9995e-01, 2.4625e-05, 1.7816e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5961e-14, 1.0000e+00, 6.1723e-14, 3.3141e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1732e-18, 1.0000e+00, 2.2529e-18, 9.7769e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6212e-21, 1.2134e-12, 3.0413e-21, 2.2571e-21],\n", + " [1.6455e-31, 9.5612e-19, 8.7467e-32, 5.2466e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8445e-06, 9.9995e-01, 2.4813e-05, 1.7971e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7274e-14, 1.0000e+00, 6.5127e-14, 3.4993e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2831e-18, 1.0000e+00, 2.4807e-18, 1.0792e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.5731e-21, 1.1477e-12, 3.0122e-21, 2.2346e-21],\n", + " [1.6845e-31, 8.9861e-19, 8.9833e-32, 5.3958e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([6.9040e-06, 9.9995e-01, 2.5114e-05, 1.8207e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9055e-14, 1.0000e+00, 6.9667e-14, 3.7455e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4310e-18, 1.0000e+00, 2.7844e-18, 1.2141e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.5281e-21, 1.0760e-12, 2.9848e-21, 2.2134e-21],\n", + " [1.7295e-31, 8.3451e-19, 9.2516e-32, 5.5644e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9955e-06, 9.9995e-01, 2.5527e-05, 1.8524e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1299e-14, 1.0000e+00, 7.5337e-14, 4.0522e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6192e-18, 1.0000e+00, 3.1697e-18, 1.3852e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4851e-21, 1.0025e-12, 2.9585e-21, 2.1929e-21],\n", + " [1.7772e-31, 7.6786e-19, 9.5339e-32, 5.7414e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1145e-06, 9.9995e-01, 2.6036e-05, 1.8910e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3967e-14, 1.0000e+00, 8.2046e-14, 4.4148e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8484e-18, 1.0000e+00, 3.6385e-18, 1.5933e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4438e-21, 9.3082e-13, 2.9331e-21, 2.1731e-21],\n", + " [1.8252e-31, 7.0255e-19, 9.8173e-32, 5.9192e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2494e-06, 9.9995e-01, 2.6604e-05, 1.9338e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6969e-14, 1.0000e+00, 8.9600e-14, 4.8233e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1160e-18, 1.0000e+00, 4.1876e-18, 1.8374e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "97000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4033e-21, 8.6349e-13, 2.9080e-21, 2.1535e-21],\n", + " [1.8727e-31, 6.4160e-19, 1.0099e-31, 6.0958e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3917e-06, 9.9995e-01, 2.7201e-05, 1.9788e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0217e-14, 1.0000e+00, 9.7803e-14, 5.2669e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4175e-18, 1.0000e+00, 4.8098e-18, 2.1145e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3653e-21, 8.0237e-13, 2.8848e-21, 2.1354e-21],\n", + " [1.9191e-31, 5.8680e-19, 1.0376e-31, 6.2700e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5373e-06, 9.9994e-01, 2.7813e-05, 2.0250e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3658e-14, 1.0000e+00, 1.0653e-13, 5.7392e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7500e-18, 1.0000e+00, 5.5005e-18, 2.4227e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3306e-21, 7.4767e-13, 2.8636e-21, 2.1190e-21],\n", + " [1.9638e-31, 5.3827e-19, 1.0645e-31, 6.4393e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6871e-06, 9.9994e-01, 2.8439e-05, 2.0721e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7273e-14, 1.0000e+00, 1.1572e-13, 6.2364e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1130e-18, 1.0000e+00, 6.2578e-18, 2.7611e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2975e-21, 6.9885e-13, 2.8435e-21, 2.1033e-21],\n", + " [2.0065e-31, 4.9551e-19, 1.0903e-31, 6.6024e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8361e-06, 9.9994e-01, 2.9062e-05, 2.1190e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1025e-14, 1.0000e+00, 1.2529e-13, 6.7546e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5050e-18, 1.0000e+00, 7.0801e-18, 3.1291e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "101000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2673e-21, 6.5539e-13, 2.8252e-21, 2.0890e-21],\n", + " [2.0486e-31, 4.5803e-19, 1.1158e-31, 6.7631e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9794e-06, 9.9994e-01, 2.9662e-05, 2.1641e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4848e-14, 1.0000e+00, 1.3506e-13, 7.2838e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9210e-18, 1.0000e+00, 7.9564e-18, 3.5218e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2407e-21, 6.1698e-13, 2.8092e-21, 2.0765e-21],\n", + " [2.0906e-31, 4.2546e-19, 1.1412e-31, 6.9231e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1197e-06, 9.9994e-01, 3.0251e-05, 2.2085e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8762e-14, 1.0000e+00, 1.4511e-13, 7.8285e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3632e-18, 1.0000e+00, 8.8929e-18, 3.9422e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2155e-21, 5.8252e-13, 2.7941e-21, 2.0647e-21],\n", + " [2.1313e-31, 3.9664e-19, 1.1659e-31, 7.0795e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([8.2572e-06, 9.9994e-01, 3.0830e-05, 2.2521e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2762e-14, 1.0000e+00, 1.5541e-13, 8.3867e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8316e-18, 1.0000e+00, 9.8893e-18, 4.3902e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1924e-21, 5.5160e-13, 2.7804e-21, 2.0540e-21],\n", + " [2.1717e-31, 3.7117e-19, 1.1905e-31, 7.2350e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3890e-06, 9.9994e-01, 3.1386e-05, 2.2941e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6791e-14, 1.0000e+00, 1.6582e-13, 8.9514e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3208e-18, 1.0000e+00, 1.0935e-17, 4.8615e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1705e-21, 5.2386e-13, 2.7675e-21, 2.0439e-21],\n", + " [2.2113e-31, 3.4867e-19, 1.2147e-31, 7.3883e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5201e-06, 9.9994e-01, 3.1936e-05, 2.3356e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0922e-14, 1.0000e+00, 1.7650e-13, 9.5310e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8380e-18, 1.0000e+00, 1.2044e-17, 5.3617e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1493e-21, 4.9850e-13, 2.7549e-21, 2.0341e-21],\n", + " [2.2495e-31, 3.2831e-19, 1.2381e-31, 7.5363e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6433e-06, 9.9994e-01, 3.2462e-05, 2.3754e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5044e-14, 1.0000e+00, 1.8724e-13, 1.0114e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3708e-18, 1.0000e+00, 1.3196e-17, 5.8822e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1294e-21, 4.7563e-13, 2.7432e-21, 2.0251e-21],\n", + " [2.2856e-31, 3.1010e-19, 1.2605e-31, 7.6785e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7664e-06, 9.9993e-01, 3.2991e-05, 2.4154e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9267e-14, 1.0000e+00, 1.9828e-13, 1.0715e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9310e-18, 1.0000e+00, 1.4413e-17, 6.4332e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1104e-21, 4.5462e-13, 2.7322e-21, 2.0165e-21],\n", + " [2.3202e-31, 2.9349e-19, 1.2821e-31, 7.8163e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8866e-06, 9.9993e-01, 3.3507e-05, 2.4545e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3508e-14, 1.0000e+00, 2.0939e-13, 1.1319e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5102e-18, 1.0000e+00, 1.5674e-17, 7.0049e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0920e-21, 4.3548e-13, 2.7213e-21, 2.0081e-21],\n", + " [2.3539e-31, 2.7855e-19, 1.3030e-31, 7.9491e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0049e-06, 9.9993e-01, 3.4016e-05, 2.4931e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7822e-14, 1.0000e+00, 2.2071e-13, 1.1935e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1144e-18, 1.0000e+00, 1.6994e-17, 7.6033e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0743e-21, 4.1779e-13, 2.7106e-21, 1.9998e-21],\n", + " [2.3865e-31, 2.6487e-19, 1.3232e-31, 8.0772e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1236e-06, 9.9993e-01, 3.4520e-05, 2.5313e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2241e-14, 1.0000e+00, 2.3228e-13, 1.2564e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7478e-18, 1.0000e+00, 1.8377e-17, 8.2311e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0570e-21, 4.0131e-13, 2.7002e-21, 1.9917e-21],\n", + " [2.4179e-31, 2.5219e-19, 1.3425e-31, 8.1998e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2338e-06, 9.9993e-01, 3.4989e-05, 2.5669e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6567e-14, 1.0000e+00, 2.4363e-13, 1.3181e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3860e-18, 1.0000e+00, 1.9775e-17, 8.8662e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0399e-21, 3.8632e-13, 2.6898e-21, 1.9836e-21],\n", + " [2.4474e-31, 2.4079e-19, 1.3608e-31, 8.3165e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3492e-06, 9.9993e-01, 3.5475e-05, 2.6037e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0106e-13, 1.0000e+00, 2.5540e-13, 1.3822e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0059e-17, 1.0000e+00, 2.1249e-17, 9.5368e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0230e-21, 3.7220e-13, 2.6795e-21, 1.9757e-21],\n", + " [2.4753e-31, 2.3007e-19, 1.3780e-31, 8.4266e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([9.4618e-06, 9.9993e-01, 3.5948e-05, 2.6395e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0559e-13, 1.0000e+00, 2.6727e-13, 1.4467e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0754e-17, 1.0000e+00, 2.2775e-17, 1.0231e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0068e-21, 3.5906e-13, 2.6695e-21, 1.9679e-21],\n", + " [2.5027e-31, 2.2021e-19, 1.3950e-31, 8.5348e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5691e-06, 9.9993e-01, 3.6402e-05, 2.6739e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1012e-13, 1.0000e+00, 2.7920e-13, 1.5116e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1468e-17, 1.0000e+00, 2.4346e-17, 1.0947e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9909e-21, 3.4681e-13, 2.6598e-21, 1.9604e-21],\n", + " [2.5296e-31, 2.1110e-19, 1.4118e-31, 8.6415e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6712e-06, 9.9993e-01, 3.6831e-05, 2.7064e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1462e-13, 1.0000e+00, 2.9100e-13, 1.5758e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2193e-17, 1.0000e+00, 2.5944e-17, 1.1675e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "116000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9759e-21, 3.3548e-13, 2.6505e-21, 1.9532e-21],\n", + " [2.5566e-31, 2.0279e-19, 1.4284e-31, 8.7474e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7763e-06, 9.9993e-01, 3.7265e-05, 2.7391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1925e-13, 1.0000e+00, 3.0309e-13, 1.6414e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2952e-17, 1.0000e+00, 2.7610e-17, 1.2433e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9613e-21, 3.2477e-13, 2.6413e-21, 1.9461e-21],\n", + " [2.5831e-31, 1.9499e-19, 1.4446e-31, 8.8501e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8826e-06, 9.9992e-01, 3.7702e-05, 2.7721e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2397e-13, 1.0000e+00, 3.1542e-13, 1.7084e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3740e-17, 1.0000e+00, 2.9339e-17, 1.3221e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9468e-21, 3.1465e-13, 2.6321e-21, 1.9389e-21],\n", + " [2.6086e-31, 1.8764e-19, 1.4601e-31, 8.9486e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9895e-06, 9.9992e-01, 3.8137e-05, 2.8048e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2877e-13, 1.0000e+00, 3.2790e-13, 1.7761e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4555e-17, 1.0000e+00, 3.1124e-17, 1.4035e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9328e-21, 3.0510e-13, 2.6231e-21, 1.9319e-21],\n", + " [2.6336e-31, 1.8077e-19, 1.4752e-31, 9.0448e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0089e-05, 9.9992e-01, 3.8548e-05, 2.8357e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3349e-13, 1.0000e+00, 3.4022e-13, 1.8430e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5373e-17, 1.0000e+00, 3.2924e-17, 1.4855e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9188e-21, 2.9622e-13, 2.6142e-21, 1.9250e-21],\n", + " [2.6576e-31, 1.7443e-19, 1.4898e-31, 9.1371e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0187e-05, 9.9992e-01, 3.8952e-05, 2.8663e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3819e-13, 1.0000e+00, 3.5257e-13, 1.9101e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6205e-17, 1.0000e+00, 3.4764e-17, 1.5695e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "121000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9049e-21, 2.8787e-13, 2.6054e-21, 1.9182e-21],\n", + " [2.6806e-31, 1.6851e-19, 1.5038e-31, 9.2266e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0282e-05, 9.9992e-01, 3.9354e-05, 2.8966e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4294e-13, 1.0000e+00, 3.6510e-13, 1.9782e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7062e-17, 1.0000e+00, 3.6665e-17, 1.6564e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8913e-21, 2.7993e-13, 2.5969e-21, 1.9116e-21],\n", + " [2.7033e-31, 1.6293e-19, 1.5178e-31, 9.3159e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0380e-05, 9.9992e-01, 3.9762e-05, 2.9274e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4785e-13, 1.0000e+00, 3.7802e-13, 2.0483e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7958e-17, 1.0000e+00, 3.8655e-17, 1.7473e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8778e-21, 2.7228e-13, 2.5884e-21, 1.9050e-21],\n", + " [2.7255e-31, 1.5755e-19, 1.5315e-31, 9.4032e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.0480e-05, 9.9992e-01, 4.0176e-05, 2.9585e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5286e-13, 1.0000e+00, 3.9123e-13, 2.1200e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8886e-17, 1.0000e+00, 4.0716e-17, 1.8414e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8644e-21, 2.6496e-13, 2.5799e-21, 1.8985e-21],\n", + " [2.7466e-31, 1.5242e-19, 1.5446e-31, 9.4863e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0577e-05, 9.9992e-01, 4.0582e-05, 2.9891e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5785e-13, 1.0000e+00, 4.0442e-13, 2.1917e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9826e-17, 1.0000e+00, 4.2812e-17, 1.9373e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8510e-21, 2.5805e-13, 2.5715e-21, 1.8920e-21],\n", + " [2.7670e-31, 1.4763e-19, 1.5573e-31, 9.5674e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0663e-05, 9.9992e-01, 4.0949e-05, 3.0169e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6262e-13, 1.0000e+00, 4.1709e-13, 2.2605e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0745e-17, 1.0000e+00, 4.4872e-17, 2.0317e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8389e-21, 2.5173e-13, 2.5638e-21, 1.8861e-21],\n", + " [2.7871e-31, 1.4327e-19, 1.5698e-31, 9.6476e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0750e-05, 9.9992e-01, 4.1324e-05, 3.0453e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6751e-13, 1.0000e+00, 4.3013e-13, 2.3314e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1699e-17, 1.0000e+00, 4.7019e-17, 2.1301e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8269e-21, 2.4562e-13, 2.5563e-21, 1.8802e-21],\n", + " [2.8067e-31, 1.3906e-19, 1.5821e-31, 9.7264e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0836e-05, 9.9992e-01, 4.1698e-05, 3.0736e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7244e-13, 1.0000e+00, 4.4333e-13, 2.4032e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2675e-17, 1.0000e+00, 4.9223e-17, 2.2312e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8151e-21, 2.3976e-13, 2.5489e-21, 1.8745e-21],\n", + " [2.8257e-31, 1.3505e-19, 1.5941e-31, 9.8029e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0921e-05, 9.9992e-01, 4.2068e-05, 3.1017e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7738e-13, 1.0000e+00, 4.5660e-13, 2.4754e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3667e-17, 1.0000e+00, 5.1472e-17, 2.3345e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8032e-21, 2.3417e-13, 2.5415e-21, 1.8687e-21],\n", + " [2.8439e-31, 1.3124e-19, 1.6057e-31, 9.8771e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1008e-05, 9.9992e-01, 4.2449e-05, 3.1305e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8246e-13, 1.0000e+00, 4.7027e-13, 2.5497e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4698e-17, 1.0000e+00, 5.3816e-17, 2.4421e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7918e-21, 2.2879e-13, 2.5344e-21, 1.8633e-21],\n", + " [2.8625e-31, 1.2759e-19, 1.6175e-31, 9.9531e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1097e-05, 9.9991e-01, 4.2838e-05, 3.1600e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8762e-13, 1.0000e+00, 4.8421e-13, 2.6256e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5759e-17, 1.0000e+00, 5.6237e-17, 2.5534e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7811e-21, 2.2366e-13, 2.5279e-21, 1.8582e-21],\n", + " [2.8815e-31, 1.2415e-19, 1.6296e-31, 1.0030e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1187e-05, 9.9991e-01, 4.3231e-05, 3.1898e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9288e-13, 1.0000e+00, 4.9844e-13, 2.7031e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6854e-17, 1.0000e+00, 5.8739e-17, 2.6685e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7705e-21, 2.1870e-13, 2.5213e-21, 1.8531e-21],\n", + " [2.9001e-31, 1.2082e-19, 1.6415e-31, 1.0107e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1274e-05, 9.9991e-01, 4.3617e-05, 3.2191e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9821e-13, 1.0000e+00, 5.1288e-13, 2.7816e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7980e-17, 1.0000e+00, 6.1315e-17, 2.7869e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7619e-21, 2.1400e-13, 2.5161e-21, 1.8490e-21],\n", + " [2.9208e-31, 1.1770e-19, 1.6544e-31, 1.0189e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.1356e-05, 9.9991e-01, 4.3981e-05, 3.2468e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0343e-13, 1.0000e+00, 5.2705e-13, 2.8587e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9106e-17, 1.0000e+00, 6.3896e-17, 2.9057e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7540e-21, 2.0958e-13, 2.5113e-21, 1.8452e-21],\n", + " [2.9423e-31, 1.1481e-19, 1.6678e-31, 1.0274e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1431e-05, 9.9991e-01, 4.4321e-05, 3.2728e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0847e-13, 1.0000e+00, 5.4086e-13, 2.9340e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0214e-17, 1.0000e+00, 6.6456e-17, 3.0237e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "135000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7468e-21, 2.0546e-13, 2.5070e-21, 1.8417e-21],\n", + " [2.9639e-31, 1.1214e-19, 1.6813e-31, 1.0360e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1506e-05, 9.9991e-01, 4.4665e-05, 3.2991e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1363e-13, 1.0000e+00, 5.5502e-13, 3.0112e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1358e-17, 1.0000e+00, 6.9106e-17, 3.1458e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7404e-21, 2.0147e-13, 2.5033e-21, 1.8388e-21],\n", + " [2.9858e-31, 1.0956e-19, 1.6950e-31, 1.0446e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1581e-05, 9.9991e-01, 4.5011e-05, 3.3254e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1884e-13, 1.0000e+00, 5.6936e-13, 3.0894e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2529e-17, 1.0000e+00, 7.1827e-17, 3.2713e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7345e-21, 1.9765e-13, 2.4999e-21, 1.8361e-21],\n", + " [3.0082e-31, 1.0711e-19, 1.7091e-31, 1.0536e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1659e-05, 9.9991e-01, 4.5364e-05, 3.3523e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2419e-13, 1.0000e+00, 5.8408e-13, 3.1696e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3743e-17, 1.0000e+00, 7.4648e-17, 3.4015e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7288e-21, 1.9393e-13, 2.4967e-21, 1.8335e-21],\n", + " [3.0308e-31, 1.0473e-19, 1.7232e-31, 1.0626e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1737e-05, 9.9991e-01, 4.5717e-05, 3.3791e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2961e-13, 1.0000e+00, 5.9900e-13, 3.2509e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4988e-17, 1.0000e+00, 7.7550e-17, 3.5355e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7231e-21, 1.9033e-13, 2.4935e-21, 1.8309e-21],\n", + " [3.0534e-31, 1.0244e-19, 1.7374e-31, 1.0716e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1811e-05, 9.9991e-01, 4.6061e-05, 3.4054e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3495e-13, 1.0000e+00, 6.1378e-13, 3.3315e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6231e-17, 1.0000e+00, 8.0457e-17, 3.6698e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7183e-21, 1.8695e-13, 2.4909e-21, 1.8288e-21],\n", + " [3.0765e-31, 1.0031e-19, 1.7519e-31, 1.0808e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1886e-05, 9.9991e-01, 4.6407e-05, 3.4318e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4035e-13, 1.0000e+00, 6.2878e-13, 3.4134e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7503e-17, 1.0000e+00, 8.3442e-17, 3.8079e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "141000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7140e-21, 1.8369e-13, 2.4886e-21, 1.8269e-21],\n", + " [3.1001e-31, 9.8266e-20, 1.7667e-31, 1.0902e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1963e-05, 9.9991e-01, 4.6759e-05, 3.4587e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4588e-13, 1.0000e+00, 6.4413e-13, 3.4973e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8817e-17, 1.0000e+00, 8.6527e-17, 3.9506e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7098e-21, 1.8051e-13, 2.4864e-21, 1.8251e-21],\n", + " [3.1239e-31, 9.6279e-20, 1.7815e-31, 1.0996e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2041e-05, 9.9991e-01, 4.7123e-05, 3.4865e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5157e-13, 1.0000e+00, 6.5999e-13, 3.5840e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0177e-17, 1.0000e+00, 8.9729e-17, 4.0989e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7060e-21, 1.7740e-13, 2.4844e-21, 1.8234e-21],\n", + " [3.1471e-31, 9.4326e-20, 1.7960e-31, 1.1088e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.2121e-05, 9.9991e-01, 4.7490e-05, 3.5146e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5736e-13, 1.0000e+00, 6.7615e-13, 3.6725e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1578e-17, 1.0000e+00, 9.3032e-17, 4.2519e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7025e-21, 1.7438e-13, 2.4826e-21, 1.8220e-21],\n", + " [3.1708e-31, 9.2442e-20, 1.8107e-31, 1.1182e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2200e-05, 9.9990e-01, 4.7860e-05, 3.5429e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6325e-13, 1.0000e+00, 6.9261e-13, 3.7625e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3014e-17, 1.0000e+00, 9.6428e-17, 4.4094e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6991e-21, 1.7145e-13, 2.4810e-21, 1.8206e-21],\n", + " [3.1945e-31, 9.0614e-20, 1.8255e-31, 1.1276e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2281e-05, 9.9990e-01, 4.8236e-05, 3.5718e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6925e-13, 1.0000e+00, 7.0943e-13, 3.8546e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4491e-17, 1.0000e+00, 9.9924e-17, 4.5717e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6959e-21, 1.6860e-13, 2.4794e-21, 1.8193e-21],\n", + " [3.2177e-31, 8.8829e-20, 1.8400e-31, 1.1368e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2362e-05, 9.9990e-01, 4.8615e-05, 3.6009e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7531e-13, 1.0000e+00, 7.2647e-13, 3.9480e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5998e-17, 1.0000e+00, 1.0350e-16, 4.7380e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6926e-21, 1.6582e-13, 2.4777e-21, 1.8179e-21],\n", + " [3.2406e-31, 8.7103e-20, 1.8543e-31, 1.1460e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2442e-05, 9.9990e-01, 4.8986e-05, 3.6295e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8136e-13, 1.0000e+00, 7.4352e-13, 4.0415e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7520e-17, 1.0000e+00, 1.0713e-16, 4.9066e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6892e-21, 1.6315e-13, 2.4761e-21, 1.8166e-21],\n", + " [3.2634e-31, 8.5449e-20, 1.8686e-31, 1.1551e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2507e-05, 9.9990e-01, 4.9304e-05, 3.6540e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8688e-13, 1.0000e+00, 7.5918e-13, 4.1275e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8934e-17, 1.0000e+00, 1.1053e-16, 5.0645e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6865e-21, 1.6074e-13, 2.4748e-21, 1.8155e-21],\n", + " [3.2847e-31, 8.3964e-20, 1.8820e-31, 1.1636e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2573e-05, 9.9990e-01, 4.9621e-05, 3.6785e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9245e-13, 1.0000e+00, 7.7502e-13, 4.2143e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0373e-17, 1.0000e+00, 1.1399e-16, 5.2257e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6841e-21, 1.5840e-13, 2.4738e-21, 1.8146e-21],\n", + " [3.3057e-31, 8.2518e-20, 1.8954e-31, 1.1721e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2639e-05, 9.9990e-01, 4.9939e-05, 3.7030e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9809e-13, 1.0000e+00, 7.9108e-13, 4.3025e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1844e-17, 1.0000e+00, 1.1753e-16, 5.3908e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6816e-21, 1.5611e-13, 2.4727e-21, 1.8137e-21],\n", + " [3.3268e-31, 8.1110e-20, 1.9087e-31, 1.1807e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2704e-05, 9.9990e-01, 5.0254e-05, 3.7273e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0377e-13, 1.0000e+00, 8.0723e-13, 4.3911e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3337e-17, 1.0000e+00, 1.2113e-16, 5.5584e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6795e-21, 1.5390e-13, 2.4718e-21, 1.8129e-21],\n", + " [3.3481e-31, 7.9752e-20, 1.9221e-31, 1.1892e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2770e-05, 9.9990e-01, 5.0573e-05, 3.7519e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0958e-13, 1.0000e+00, 8.2375e-13, 4.4818e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4871e-17, 1.0000e+00, 1.2483e-16, 5.7310e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6781e-21, 1.5174e-13, 2.4713e-21, 1.8124e-21],\n", + " [3.3692e-31, 7.8419e-20, 1.9354e-31, 1.1977e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.2836e-05, 9.9990e-01, 5.0891e-05, 3.7764e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1541e-13, 1.0000e+00, 8.4040e-13, 4.5732e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6429e-17, 1.0000e+00, 1.2860e-16, 5.9067e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "154000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6767e-21, 1.4964e-13, 2.4709e-21, 1.8120e-21],\n", + " [3.3902e-31, 7.7126e-20, 1.9487e-31, 1.2062e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2902e-05, 9.9990e-01, 5.1212e-05, 3.8011e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2132e-13, 1.0000e+00, 8.5730e-13, 4.6660e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8021e-17, 1.0000e+00, 1.3246e-16, 6.0869e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6753e-21, 1.4759e-13, 2.4704e-21, 1.8115e-21],\n", + " [3.4115e-31, 7.5869e-20, 1.9621e-31, 1.2148e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2969e-05, 9.9990e-01, 5.1538e-05, 3.8263e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2733e-13, 1.0000e+00, 8.7450e-13, 4.7606e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9651e-17, 1.0000e+00, 1.3642e-16, 6.2719e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6739e-21, 1.4558e-13, 2.4699e-21, 1.8111e-21],\n", + " [3.4328e-31, 7.4644e-20, 1.9757e-31, 1.2234e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3038e-05, 9.9990e-01, 5.1870e-05, 3.8519e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3345e-13, 1.0000e+00, 8.9205e-13, 4.8570e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1323e-17, 1.0000e+00, 1.4050e-16, 6.4622e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6725e-21, 1.4361e-13, 2.4695e-21, 1.8106e-21],\n", + " [3.4539e-31, 7.3441e-20, 1.9890e-31, 1.2320e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3107e-05, 9.9990e-01, 5.2204e-05, 3.8777e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3968e-13, 1.0000e+00, 9.0991e-13, 4.9552e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3039e-17, 1.0000e+00, 1.4467e-16, 6.6574e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6712e-21, 1.4167e-13, 2.4691e-21, 1.8102e-21],\n", + " [3.4751e-31, 7.2261e-20, 2.0024e-31, 1.2405e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3177e-05, 9.9990e-01, 5.2541e-05, 3.9037e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4602e-13, 1.0000e+00, 9.2804e-13, 5.0548e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4792e-17, 1.0000e+00, 1.4894e-16, 6.8567e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6700e-21, 1.3978e-13, 2.4687e-21, 1.8098e-21],\n", + " [3.4958e-31, 7.1104e-20, 2.0154e-31, 1.2488e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3245e-05, 9.9989e-01, 5.2870e-05, 3.9291e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5229e-13, 1.0000e+00, 9.4606e-13, 5.1540e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6543e-17, 1.0000e+00, 1.5322e-16, 7.0569e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6688e-21, 1.3795e-13, 2.4682e-21, 1.8094e-21],\n", + " [3.5161e-31, 6.9993e-20, 2.0282e-31, 1.2570e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3309e-05, 9.9989e-01, 5.3182e-05, 3.9532e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5840e-13, 1.0000e+00, 9.6367e-13, 5.2509e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8275e-17, 1.0000e+00, 1.5746e-16, 7.2550e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "161000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6675e-21, 1.3621e-13, 2.4679e-21, 1.8090e-21],\n", + " [3.5363e-31, 6.8944e-20, 2.0410e-31, 1.2651e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3374e-05, 9.9989e-01, 5.3493e-05, 3.9772e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6460e-13, 1.0000e+00, 9.8147e-13, 5.3487e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0043e-17, 1.0000e+00, 1.6178e-16, 7.4572e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6665e-21, 1.3451e-13, 2.4676e-21, 1.8087e-21],\n", + " [3.5567e-31, 6.7920e-20, 2.0539e-31, 1.2733e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3440e-05, 9.9989e-01, 5.3806e-05, 4.0014e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7089e-13, 1.0000e+00, 9.9951e-13, 5.4479e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1846e-17, 1.0000e+00, 1.6619e-16, 7.6634e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6654e-21, 1.3284e-13, 2.4673e-21, 1.8084e-21],\n", + " [3.5767e-31, 6.6916e-20, 2.0665e-31, 1.2814e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.3507e-05, 9.9989e-01, 5.4124e-05, 4.0258e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7731e-13, 1.0000e+00, 1.0179e-12, 5.5489e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3697e-17, 1.0000e+00, 1.7070e-16, 7.8746e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6643e-21, 1.3119e-13, 2.4670e-21, 1.8080e-21],\n", + " [3.5965e-31, 6.5921e-20, 2.0789e-31, 1.2893e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3575e-05, 9.9989e-01, 5.4447e-05, 4.0506e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8385e-13, 1.0000e+00, 1.0366e-12, 5.6517e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5588e-17, 1.0000e+00, 1.7532e-16, 8.0909e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6633e-21, 1.2957e-13, 2.4667e-21, 1.8077e-21],\n", + " [3.6156e-31, 6.4942e-20, 2.0910e-31, 1.2970e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3645e-05, 9.9989e-01, 5.4771e-05, 4.0755e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9050e-13, 1.0000e+00, 1.0556e-12, 5.7561e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7526e-17, 1.0000e+00, 1.8005e-16, 8.3121e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6624e-21, 1.2798e-13, 2.4664e-21, 1.8074e-21],\n", + " [3.6349e-31, 6.3982e-20, 2.1032e-31, 1.3048e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3715e-05, 9.9989e-01, 5.5094e-05, 4.1002e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9726e-13, 1.0000e+00, 1.0749e-12, 5.8615e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9509e-17, 1.0000e+00, 1.8488e-16, 8.5377e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6615e-21, 1.2642e-13, 2.4662e-21, 1.8071e-21],\n", + " [3.6543e-31, 6.3042e-20, 2.1153e-31, 1.3126e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3787e-05, 9.9989e-01, 5.5422e-05, 4.1252e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0416e-13, 1.0000e+00, 1.0944e-12, 5.9684e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1529e-17, 1.0000e+00, 1.8979e-16, 8.7671e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6607e-21, 1.2489e-13, 2.4659e-21, 1.8068e-21],\n", + " [3.6723e-31, 6.2109e-20, 2.1267e-31, 1.3199e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3864e-05, 9.9989e-01, 5.5764e-05, 4.1509e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1131e-13, 1.0000e+00, 1.1145e-12, 6.0784e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3610e-17, 1.0000e+00, 1.9485e-16, 9.0033e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6599e-21, 1.2338e-13, 2.4657e-21, 1.8065e-21],\n", + " [3.6882e-31, 6.1163e-20, 2.1369e-31, 1.3265e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3942e-05, 9.9989e-01, 5.6109e-05, 4.1769e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1860e-13, 1.0000e+00, 1.1350e-12, 6.1904e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5746e-17, 1.0000e+00, 2.0003e-16, 9.2453e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6591e-21, 1.2189e-13, 2.4654e-21, 1.8062e-21],\n", + " [3.7039e-31, 6.0232e-20, 2.1471e-31, 1.3331e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4021e-05, 9.9989e-01, 5.6454e-05, 4.2028e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2596e-13, 1.0000e+00, 1.1557e-12, 6.3030e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7915e-17, 1.0000e+00, 2.0528e-16, 9.4902e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6584e-21, 1.2043e-13, 2.4651e-21, 1.8059e-21],\n", + " [3.7194e-31, 5.9326e-20, 2.1570e-31, 1.3395e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4099e-05, 9.9989e-01, 5.6794e-05, 4.2284e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3330e-13, 1.0000e+00, 1.1762e-12, 6.4152e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0096e-17, 1.0000e+00, 2.1057e-16, 9.7369e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6577e-21, 1.1903e-13, 2.4649e-21, 1.8057e-21],\n", + " [3.7349e-31, 5.8454e-20, 2.1670e-31, 1.3459e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4176e-05, 9.9989e-01, 5.7134e-05, 4.2539e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4070e-13, 1.0000e+00, 1.1970e-12, 6.5286e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2311e-17, 1.0000e+00, 2.1595e-16, 9.9882e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "173000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6569e-21, 1.1765e-13, 2.4646e-21, 1.8054e-21],\n", + " [3.7504e-31, 5.7602e-20, 2.1769e-31, 1.3523e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4254e-05, 9.9989e-01, 5.7473e-05, 4.2794e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4819e-13, 1.0000e+00, 1.2181e-12, 6.6434e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4571e-17, 1.0000e+00, 2.2144e-16, 1.0244e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6562e-21, 1.1629e-13, 2.4643e-21, 1.8051e-21],\n", + " [3.7660e-31, 5.6765e-20, 2.1869e-31, 1.3588e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4321e-05, 9.9988e-01, 5.7772e-05, 4.3019e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5514e-13, 1.0000e+00, 1.2377e-12, 6.7503e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6708e-17, 1.0000e+00, 2.2666e-16, 1.0488e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6555e-21, 1.1503e-13, 2.4641e-21, 1.8048e-21],\n", + " [3.7815e-31, 5.6003e-20, 2.1969e-31, 1.3652e-31]],\n", + " grad_fn=)\n" + ] + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16041.703125\n", + "1 11864.703125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05112.2500004160.250000
15361.5625003937.562500
25567.8906253766.890625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5112.250000 4160.250000\n", + "1 5361.562500 3937.562500\n", + "2 5567.890625 3766.890625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0128.500135.500
1128.250133.750
2130.625132.375
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 128.500 135.500\n", + "1 128.250 133.750\n", + "2 130.625 132.375" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidIndexError", + "evalue": "(slice(None, None, None), None)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3621\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3620\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 3621\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3622\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:136\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:142\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: '(slice(None, None, None), None)' is an invalid key", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mInvalidIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [18]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlearning\u001b[49m\u001b[43m,\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\pyplot.py:2757\u001b[0m, in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 2755\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mplot)\n\u001b[0;32m 2756\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot\u001b[39m(\u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, scaley\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m-> 2757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m gca()\u001b[38;5;241m.\u001b[39mplot(\n\u001b[0;32m 2758\u001b[0m \u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39mscalex, scaley\u001b[38;5;241m=\u001b[39mscaley,\n\u001b[0;32m 2759\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m\"\u001b[39m: data} \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {}), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_axes.py:1632\u001b[0m, in \u001b[0;36mAxes.plot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1391\u001b[0m \u001b[38;5;124;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[0;32m 1392\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1629\u001b[0m \u001b[38;5;124;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[0;32m 1630\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1631\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m cbook\u001b[38;5;241m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[38;5;241m.\u001b[39mLine2D)\n\u001b[1;32m-> 1632\u001b[0m lines \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_lines(\u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39mdata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)]\n\u001b[0;32m 1633\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[0;32m 1634\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_line(line)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:312\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[1;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 310\u001b[0m this \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 311\u001b[0m args \u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m1\u001b[39m:]\n\u001b[1;32m--> 312\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:487\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[1;34m(self, tup, kwargs, return_kwargs)\u001b[0m\n\u001b[0;32m 484\u001b[0m kw[prop_name] \u001b[38;5;241m=\u001b[39m val\n\u001b[0;32m 486\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(xy) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[1;32m--> 487\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43m_check_1d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxy\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 488\u001b[0m y \u001b[38;5;241m=\u001b[39m _check_1d(xy[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m 489\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\cbook\\__init__.py:1327\u001b[0m, in \u001b[0;36m_check_1d\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m warnings\u001b[38;5;241m.\u001b[39mcatch_warnings(record\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m w:\n\u001b[0;32m 1322\u001b[0m warnings\u001b[38;5;241m.\u001b[39mfilterwarnings(\n\u001b[0;32m 1323\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1324\u001b[0m category\u001b[38;5;241m=\u001b[39m\u001b[38;5;167;01mWarning\u001b[39;00m,\n\u001b[0;32m 1325\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSupport for multi-dimensional indexing\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m-> 1327\u001b[0m ndim \u001b[38;5;241m=\u001b[39m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mndim\n\u001b[0;32m 1328\u001b[0m \u001b[38;5;66;03m# we have definitely hit a pandas index or series object\u001b[39;00m\n\u001b[0;32m 1329\u001b[0m \u001b[38;5;66;03m# cast to a numpy array.\u001b[39;00m\n\u001b[0;32m 1330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(w) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\frame.py:3505\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 3503\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m 3504\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[1;32m-> 3505\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3506\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[0;32m 3507\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3628\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3623\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[0;32m 3624\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[0;32m 3625\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[0;32m 3626\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[0;32m 3627\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m-> 3628\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_check_indexing_error\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3629\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m 3631\u001b[0m \u001b[38;5;66;03m# GH#42269\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:5637\u001b[0m, in \u001b[0;36mIndex._check_indexing_error\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 5633\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_check_indexing_error\u001b[39m(\u001b[38;5;28mself\u001b[39m, key):\n\u001b[0;32m 5634\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_scalar(key):\n\u001b[0;32m 5635\u001b[0m \u001b[38;5;66;03m# if key is not a scalar, directly raise an error (the code below\u001b[39;00m\n\u001b[0;32m 5636\u001b[0m \u001b[38;5;66;03m# would convert to numpy arrays and raise later any way) - GH29926\u001b[39;00m\n\u001b[1;32m-> 5637\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n", + "\u001b[1;31mInvalidIndexError\u001b[0m: (slice(None, None, None), None)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning,loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 10000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 10000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..f970760 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 10000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 0.0009 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 0.0009 lr.pt new file mode 100644 index 0000000..57e21c8 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 0.0009 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..92c73b4 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 100000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0009 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0009 lr.pt new file mode 100644 index 0000000..8f28811 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 0.0009 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..1ba136a Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 1000000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 20000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 20000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..3af2567 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 20000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 2000000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 2000000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..66a7ade Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 2000000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 0.0009 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 0.0009 lr.pt new file mode 100644 index 0000000..56e2149 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 0.0009 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 1e-05 lr.pt b/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 1e-05 lr.pt new file mode 100644 index 0000000..6adc748 Binary files /dev/null and b/learningAgents/naive_policy_gradient/test/NNs/ep 500000, myopic-1.0-, 0 hist, 1e-05 lr.pt differ diff --git a/learningAgents/naive_policy_gradient/test/NeuralNetwork.py b/learningAgents/naive_policy_gradient/test/NeuralNetwork.py new file mode 100644 index 0000000..5dc3efa --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/NeuralNetwork.py @@ -0,0 +1,44 @@ +import torch +import torch.nn as nn + + +class NeuralNetwork(): + + """ + Defines a three layer Neural Network that acts as the agent. The output is a tensor of probablities over actions. + """ + + save_path_format = './NNs/{name}.pt' + + def __init__(self, lr=.000001, num_input=3, num_actions=50, nn_dim=100) -> None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + self.nn_ = nn_dim + + self.nn_name = f"nn, lr={self.lr}, actions={self.num_actions}" + + def reset(self): + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_), + nn.ReLU(), + nn.Linear(self.nn_, self.nn_), + nn.ReLU(), + nn.Linear(self.nn_, self.num_actions), + nn.Softmax(dim=0)) + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim + + def save(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + return torch.save(self.policy.state_dict(), self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + self.policy.load_state_dict( + torch.load(self.save_path_format.format(name=self.nn_name))) + + def newSoftmax(self,dim=None): + pass \ No newline at end of file diff --git a/learningAgents/naive_policy_gradient/test/environmentModel.py b/learningAgents/naive_policy_gradient/test/environmentModel.py new file mode 100644 index 0000000..f689859 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/environmentModel.py @@ -0,0 +1,287 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T), [0]*(self.T)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player, t): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player, self.stage) + + def const(self, player, price): # constant price strategy + """ + Adversary follows Constant strategy + """ + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return price + + def imit(self, player, firstprice): # price imitator strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return self.prices[1-player][self.stage-1] + + def fight(self, player, firstprice): # simplified fighting strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (self.totalDemand-self.costs[player] + + self.costs[1-player])/2 + + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return self.prices[player][self.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getself.demandPotential to Asp + P = self.prices[1-player][self.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (self.totalDemand+self.costs[0]+self.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + def fight_lb(self, player, firstprice): + P = self.fight(player, firstprice) + # never price less than production cost + P = max(P, self.costs[player]) + return P + + # sophisticated fighting strategy, compare fight() + # estimate *sales* of opponent as their target + + def guess(self, player, firstprice): # predictive fighting strategy + if self.stage == 0: + self.aspireDemand = [(self.totalDemand+ self.costs[1]-self.costs[0] ), (self.totalDemand+ self.costs[0]-self.costs[1] )] # aspiration level + self.aspirePrice = (self.totalDemand+self.costs[0]+self.costs[1])/4 + self.saleGuess= [self.aspireDemand[0]-self.aspirePrice,self.aspireDemand[1]-self.aspirePrice ] # first guess opponent sales as in monopoly ( sale= demand-price) + + return firstprice + + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + + + + D = self.demandPotential[player][self.stage] + Asp = self.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = self.monopolyPrice(player, self.stage) + pcurrent = self.prices[player][self.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = self.demandPotential[1 - + player][self.stage-1] - self.prices[1-player][self.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * self.saleGuess[player] + (1-alpha)*prevsales + # update + self.saleGuess[player] = newsalesguess + guessoppPrice = self.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, adversaryProbs, advHistoryNum=3) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + + self.rewardFunction = self.profits + + # [stage, agent's demand potential, agent's last price, history of adversary's prices] + self.initState = [ + 0, totalDemand/2, ((totalDemand/2) + tupleCosts[0])/2] + ([0]*advHistoryNum) + self.episodesMemory = list() + self.done = False + self.adversaryProbs = adversaryProbs + # number of previous adversary's action we consider in the state + self.advHistoryNum = advHistoryNum + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return torch.tensor(self.initState, dtype=torch.float32), reward, self.done + + def resetAdversary(self): + adversaryDist = Categorical(self.adversaryProbs) + adversaryInd = (adversaryDist.sample()).item() + self.adversaryMode = AdversaryModes(adversaryInd) + # print(self.adversaryMode) + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + if self.adversaryMode == AdversaryModes.constant_132: + return self.const(player=1, price=132) + elif self.adversaryMode == AdversaryModes.constant_95: + return self.const(player=1, price=95) + elif self.adversaryMode == AdversaryModes.imitation_128: + return self.imit(player=1, firstprice=128) + elif self.adversaryMode == AdversaryModes.imitation_132: + return self.imit(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_100: + return self.fight(player=1, firstprice=100) + elif self.adversaryMode == AdversaryModes.fight_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_lb_125: + return self.fight_lb(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_132: + return self.fight(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_lb_132: + return self.fight_lb(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.guess_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.guess_132: + return self.fight(player=1, firstprice=132) + else: + return self.myopic(player=1) + + def step(self, state, action): + """ + Transition Function. + Parameters: + - action: Price + - state: tupple in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + adversaryAction = self.adversaryChoosePrice() + myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [self.myopic() - action, adversaryAction]) + + done = (self.stage == self.T-1) + + + if not done: + newState = [self.stage+1, self.demandPotential[0] + [self.stage + 1], self.prices[0][self.stage]] + else: + newState = [self.stage+1, 0, self.prices[0] + [self.stage]] + + if(self.advHistoryNum>0): + advHistory = [0]*self.advHistoryNum + j = self.advHistoryNum-1 + for i in range(self.stage, max(-1, self.stage-self.advHistoryNum), -1): + advHistory[j] = self.prices[1][i] + j -= 1 + + newState+= advHistory + + + reward = self.rewardFunction() + self.stage = self.stage + 1 + + return torch.tensor(newState, dtype=torch.float32), reward, done + + +class AdversaryModes(Enum): + myopic = 0 + constant_132 = 1 + constant_95 = 2 + imitation_132 = 3 + imitation_128 = 4 + fight_132 = 5 + fight_lb_132 = 6 + fight_125 = 7 + fight_lb_125 = 8 + fight_100 = 9 + guess_132 = 10 + guess_125 = 11 diff --git a/learningAgents/naive_policy_gradient/test/learningAgents.py b/learningAgents/naive_policy_gradient/test/learningAgents.py new file mode 100644 index 0000000..e1bb530 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/learningAgents.py @@ -0,0 +1,194 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + self.returns = np.zeros((numberIterations, numberEpisodes)) + self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def savePolicy(self): + pass + + def solver(self): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + for episode in range(self.numberEpisodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + prob_dists=[] + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + prob_dists.append(distAction) + action = distAction.sample() + + if episode % 1000 == 0: + print("-"*30) + print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + + + action_probs = self.policy(states) + action_dists = Categorical(action_probs) + action_logprobs = action_dists.log_prob(actions) + + discReturns = self.returnsComputation(rewards, episodeMemory) + + # is it a good idea? to get over the big weights in NN + discReturns/=1000 + + + loss = - (torch.sum(discReturns*action_logprobs)) / \ + len(episodeMemory) + + self.loss[iteration][episode] = loss + + if episode % 1000 == 0: + print("-"*50) + print(episode, " actions: ", actions) + print("loss= ",loss, " , return= ", returns) + print("discReturns/1000=", discReturns) + print("actionProbs",action_probs) + print("action_dists",action_dists) + print("action_logprobs",action_logprobs) + + self.optim.zero_grad() + loss.backward() + self.optim.step() + + # sum of the our player's rewards rounds 0-25 + self.returns[iteration][episode] = returns + + + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + plt.plot(self.returns[iteration]) + plt.show() + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + """ + return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normalizeState(self, state): + normalized = [0]*len(state) + normalized[0] = state[0]/(self.env.T) + for i in range(1, len(state)): + normalized[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalized) + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.neuralNetwork(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + retu = retu + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + print(f"episode {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + plt.plot(returns) + plt.show() diff --git a/learningAgents/naive_policy_gradient/test/learningAgentsBase.py b/learningAgents/naive_policy_gradient/test/learningAgentsBase.py new file mode 100644 index 0000000..035a679 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/learningAgentsBase.py @@ -0,0 +1,212 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + self.returns = np.zeros((numberIterations, numberEpisodes)) + self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def savePolicy(self): + pass + + def solver(self,print_step=10_000): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + self.meanStageValue = torch.zeros(self.env.T) + + for episode in range(self.numberEpisodes): + if episode % print_step == 0: + print("-"*50) + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst=[] + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*30) + # print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + + discReturns = self.returnsComputation(rewards, episodeMemory) + + if episode == 0: + self.meanStageValue = discReturns + + baseDiscReturns = discReturns-self.meanStageValue + + # is it a good idea? to get over the big weights in NN + baseDiscReturns /= 1000 + + + + loss = - (torch.sum(baseDiscReturns*action_logprobs)) / \ + len(episodeMemory) + + self.loss[iteration][episode] = loss + + if episode % print_step == 0: + + print(episode, " adversary: ", self.env.adversaryMode) + print(" actions: ", actions) + print("loss= ",loss, " , return= ", returns) + print("probs of actions: ",torch.exp(action_logprobs)) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + print("baseDiscReturns/1000=" , baseDiscReturns) + # print("discReturns=", discReturns) + print("meanStageValue= ", self.meanStageValue) + + + if episode != 0: + self.meanStageValue = ( + (self.meanStageValue*episode)+discReturns)/(episode+1) + + self.optim.zero_grad() + loss.backward() + self.optim.step() + + # sum of the our player's rewards rounds 0-25 + self.returns[iteration][episode] = returns + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + plt.plot(self.returns[iteration]) + plt.show() + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + """ + return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normalizeState(self, state): + normalized = [0]*len(state) + normalized[0] = state[0]/(self.env.T) + for i in range(1, len(state)): + normalized[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalized) + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs = self.neuralNetwork(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + retu = retu + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + print(f"episode {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + plt.plot(returns) + plt.show() diff --git a/learningAgents/naive_policy_gradient/test/test1.ipynb b/learningAgents/naive_policy_gradient/test/test1.ipynb new file mode 100644 index 0000000..bdbc8f3 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/test1.ipynb @@ -0,0 +1,9318 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=500_000, discountFactor =0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.2517, 0.2253, 0.2504, 0.2726], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2546, 0.2273, 0.2506, 0.2675], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2576, 0.2272, 0.2508, 0.2644], grad_fn=)\n", + "--------------------------------------------------\n", + "0 actions: tensor([1, 1, 3])\n", + "loss= tensor(7.4485, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([5.1112, 5.4012, 5.5413])\n", + "actionProbs tensor([[0.3344, 0.3364, 0.3381, 0.3438],\n", + " [0.3340, 0.3350, 0.3339, 0.3330],\n", + " [0.3316, 0.3286, 0.3280, 0.3231]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2066, 0.2897, 0.2791, 0.2246], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3016, 0.2461, 0.2508, 0.2015], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.4139, 0.1901, 0.2186, 0.1775], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([1, 2, 2])\n", + "loss= tensor(7.8283, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "actionProbs tensor([[0.5801, 0.7376, 0.7206, 0.7203],\n", + " [0.2703, 0.2000, 0.2067, 0.2064],\n", + " [0.1497, 0.0624, 0.0727, 0.0733]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2566, 0.3441, 0.0719, 0.3274], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0015, 0.0032, 0.9942, 0.0010], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7919e-06, 2.3492e-05, 9.9997e-01, 2.4626e-06],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([1, 2, 2])\n", + "loss= tensor(1.9615, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "actionProbs tensor([[9.9885e-01, 9.9819e-01, 1.2432e-01, 9.9940e-01],\n", + " [1.1399e-03, 1.7843e-03, 3.2640e-01, 6.0125e-04],\n", + " [7.1627e-06, 2.1652e-05, 5.4927e-01, 2.3884e-06]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0666, 0.6586, 0.0580, 0.2168], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1821, 0.4569, 0.0832, 0.2777], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.4229, 0.2139, 0.0949, 0.2683], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([1, 3, 3])\n", + "loss= tensor(6.2044, grad_fn=) , return= 16120.5\n", + "discReturns/1000= tensor([5.1112, 5.3932, 5.6160])\n", + "actionProbs tensor([[0.0555, 0.3910, 0.1591, 0.1907],\n", + " [0.1886, 0.3370, 0.2834, 0.3035],\n", + " [0.7559, 0.2721, 0.5575, 0.5058]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3309, 0.1202, 0.2879, 0.2610], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0116, 0.0011, 0.9823, 0.0050], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2098e-04, 1.0863e-05, 9.9971e-01, 5.8602e-05],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([1, 2, 2])\n", + "loss= tensor(2.3558, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "actionProbs tensor([[9.9900e-01, 9.9974e-01, 9.0028e-01, 9.9945e-01],\n", + " [9.9806e-04, 2.5625e-04, 8.7372e-02, 5.4454e-04],\n", + " [2.6363e-06, 3.5706e-07, 1.2353e-02, 8.8661e-07]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3274, 0.1297, 0.2681, 0.2749], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6369e-04, 2.2761e-04, 9.9807e-01, 7.3993e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2424e-06, 9.1688e-07, 9.9999e-01, 2.4338e-06],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([0, 2, 2])\n", + "loss= tensor(2.3442, grad_fn=) , return= 16038.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5649])\n", + "actionProbs tensor([[9.9996e-01, 9.9998e-01, 9.4882e-01, 9.9996e-01],\n", + " [3.9420e-05, 2.3510e-05, 4.7311e-02, 3.6048e-05],\n", + " [1.0830e-08, 7.7328e-09, 3.8705e-03, 9.6817e-09]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3404, 0.1237, 0.2535, 0.2824], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5818e-04, 1.9098e-03, 9.9710e-01, 4.3342e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0468e-06, 2.7399e-05, 9.9997e-01, 7.8372e-07],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([3, 2, 2])\n", + "loss= tensor(2.3552, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6210])\n", + "actionProbs tensor([[9.9999e-01, 9.9989e-01, 9.7212e-01, 9.9999e-01],\n", + " [1.1348e-05, 1.0687e-04, 2.6466e-02, 1.0623e-05],\n", + " [1.1297e-09, 8.1385e-08, 1.4089e-03, 1.0195e-09]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3540, 0.1409, 0.2271, 0.2780], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8088e-05, 1.6462e-04, 9.9968e-01, 6.2318e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4666e-08, 4.3412e-07, 1.0000e+00, 3.0337e-08],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.4783, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 9.9998e-01, 9.1337e-01, 1.0000e+00],\n", + " [4.7954e-06, 2.2509e-05, 7.7462e-02, 4.3203e-06],\n", + " [2.8784e-10, 7.0264e-09, 9.1726e-03, 2.4896e-10]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2166, 0.0756, 0.5555, 0.1523], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4924e-04, 9.6556e-05, 9.9973e-01, 2.8974e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3893e-07, 4.2463e-07, 1.0000e+00, 2.5663e-08],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3846, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[9.9999e-01, 9.9999e-01, 9.8302e-01, 1.0000e+00],\n", + " [6.3384e-06, 1.1741e-05, 1.6272e-02, 1.7502e-06],\n", + " [6.2697e-10, 2.2489e-09, 7.0890e-04, 6.7517e-11]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1486, 0.0569, 0.6958, 0.0987], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1616e-06, 6.2061e-06, 9.9999e-01, 1.5134e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3530e-10, 6.1918e-09, 1.0000e+00, 3.4760e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3615, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 9.9936e-01, 1.0000e+00],\n", + " [9.4745e-09, 4.8542e-08, 6.3945e-04, 6.8281e-09],\n", + " [1.4858e-14, 2.5673e-13, 3.3898e-06, 8.3135e-15]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1466, 0.0607, 0.6953, 0.0973], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7432e-07, 8.1090e-07, 1.0000e+00, 1.7785e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4042e-11, 1.7816e-10, 1.0000e+00, 8.7827e-12],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([0, 2, 2])\n", + "loss= tensor(2.3624, grad_fn=) , return= 16038.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5649])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 9.9992e-01, 1.0000e+00],\n", + " [1.3436e-10, 7.0314e-10, 7.5693e-05, 9.6165e-11],\n", + " [9.8701e-18, 1.7669e-16, 8.6573e-08, 5.4313e-18]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.1581, 0.0657, 0.6691, 0.1071], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3316e-07, 2.9685e-07, 1.0000e+00, 6.2842e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0536e-12, 3.0874e-11, 1.0000e+00, 1.4386e-12],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3606, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 9.9998e-01, 1.0000e+00],\n", + " [1.3137e-11, 7.0466e-11, 2.3306e-05, 9.1460e-12],\n", + " [2.0957e-19, 3.8405e-18, 1.2213e-08, 1.0972e-19]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1681, 0.0684, 0.6454, 0.1181], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2782e-08, 1.3838e-07, 1.0000e+00, 3.0170e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0571e-12, 7.9859e-12, 1.0000e+00, 3.7686e-13],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 9.9999e-01, 1.0000e+00],\n", + " [2.4288e-12, 1.3159e-11, 1.0075e-05, 1.6608e-12],\n", + " [1.1936e-20, 2.2163e-19, 2.9404e-09, 6.0547e-21]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1718, 0.0704, 0.6405, 0.1173], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0639e-08, 6.8458e-08, 1.0000e+00, 1.4113e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0629e-13, 2.3498e-12, 1.0000e+00, 1.0362e-13],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 9.9999e-01, 1.0000e+00],\n", + " [6.0139e-13, 3.2798e-12, 5.2655e-06, 4.0574e-13],\n", + " [1.1166e-21, 2.0910e-20, 9.7801e-10, 5.5328e-22]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1716, 0.0706, 0.6238, 0.1340], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7012e-08, 3.8190e-08, 1.0000e+00, 8.8983e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0725e-13, 8.3017e-13, 1.0000e+00, 4.0982e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([1, 2, 2])\n", + "loss= tensor(2.3619, grad_fn=) , return= 16093.0625\n", + "discReturns/1000= tensor([5.1112, 5.3983, 5.5836])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.6714e-13, 9.1206e-13, 2.7034e-06, 1.1197e-13],\n", + " [1.1942e-22, 2.2470e-21, 3.0639e-10, 5.8447e-23]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1926, 0.0661, 0.6286, 0.1128], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8489e-09, 1.8578e-08, 1.0000e+00, 3.8365e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0791e-14, 2.6431e-13, 1.0000e+00, 1.1542e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6673e-14, 2.5657e-13, 1.4518e-06, 3.1046e-14],\n", + " [1.4640e-23, 2.7645e-22, 1.0996e-10, 7.0741e-24]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1679, 0.0771, 0.6403, 0.1148], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9604e-09, 1.2453e-08, 1.0000e+00, 2.2465e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3180e-14, 1.1448e-13, 1.0000e+00, 4.3225e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([0, 2, 2])\n", + "loss= tensor(2.3624, grad_fn=) , return= 16038.703125\n", + "discReturns/1000= tensor([5.1122, 5.3616, 5.5649])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.4810e-14, 8.0997e-14, 7.8284e-07, 9.8121e-15],\n", + " [1.8155e-24, 3.4350e-23, 3.6114e-11, 8.7095e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1576, 0.0747, 0.6257, 0.1419], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1439e-09, 8.2531e-09, 1.0000e+00, 1.8745e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9960e-15, 6.2716e-14, 1.0000e+00, 3.0158e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([3, 2, 2])\n", + "loss= tensor(2.3582, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([5.1033, 5.4720, 5.6210])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.1569e-15, 2.8552e-14, 4.1327e-07, 3.4155e-15],\n", + " [3.7300e-25, 7.0525e-24, 1.3433e-11, 1.7862e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1370, 0.0590, 0.7097, 0.0943], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5428e-09, 3.6720e-09, 1.0000e+00, 6.9892e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4389e-15, 1.9886e-14, 1.0000e+00, 7.9603e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1153e-15, 1.1679e-14, 2.6464e-07, 1.3923e-15],\n", + " [7.7445e-26, 1.4649e-24, 6.1292e-12, 3.6726e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1059, 0.0473, 0.7800, 0.0667], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4829e-10, 2.3462e-09, 1.0000e+00, 3.9378e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3728e-15, 1.1578e-14, 1.0000e+00, 4.1096e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [9.8999e-16, 5.4851e-15, 1.4179e-07, 6.5243e-16],\n", + " [2.1519e-26, 4.0641e-25, 2.1289e-12, 1.0224e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1064, 0.0491, 0.7800, 0.0645], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2757e-10, 2.3738e-09, 1.0000e+00, 3.7109e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3322e-15, 1.1587e-14, 1.0000e+00, 3.8425e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9952e-16, 2.7708e-15, 7.3446e-08, 3.2963e-16],\n", + " [6.8274e-27, 1.2871e-25, 6.9892e-13, 3.2480e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0876, 0.0414, 0.8179, 0.0532], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2597e-10, 1.9138e-09, 1.0000e+00, 2.8897e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0574e-15, 9.3453e-15, 1.0000e+00, 3.0135e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "21000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.6919e-16, 1.5031e-15, 3.9712e-08, 1.7655e-16],\n", + " [2.4591e-27, 4.6032e-26, 2.4906e-13, 1.1547e-27]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.0558, 0.0268, 0.8827, 0.0348], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8375e-10, 1.2962e-09, 1.0000e+00, 1.9345e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7555e-16, 6.7857e-15, 1.0000e+00, 2.1763e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.5231e-16, 8.5067e-16, 1.9893e-08, 9.7618e-17],\n", + " [9.4926e-28, 1.7311e-26, 7.7333e-14, 4.2692e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0321, 0.0156, 0.9318, 0.0205], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8370e-10, 7.6398e-10, 1.0000e+00, 1.1210e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8245e-16, 4.1159e-15, 1.0000e+00, 1.2980e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.1980e-17, 4.5457e-16, 9.9548e-09, 5.0598e-17],\n", + " [3.3382e-28, 5.8640e-27, 2.3837e-14, 1.4028e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0178, 0.0090, 0.9614, 0.0119], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7714e-10, 5.1473e-10, 1.0000e+00, 7.4302e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3722e-16, 3.1083e-15, 1.0000e+00, 9.6835e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8320e-17, 2.7762e-16, 5.0364e-09, 3.0184e-17],\n", + " [1.3579e-28, 2.4749e-27, 7.4350e-15, 5.8072e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0098, 0.0050, 0.9785, 0.0066], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0698e-11, 2.6234e-10, 1.0000e+00, 3.6452e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6705e-16, 1.4858e-15, 1.0000e+00, 4.4341e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.5531e-17, 1.4474e-16, 2.8303e-09, 1.5225e-17],\n", + " [4.6409e-29, 8.0901e-28, 2.7933e-15, 1.8278e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0053, 0.0027, 0.9885, 0.0035], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4076e-11, 1.2021e-10, 1.0000e+00, 1.6718e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7022e-17, 6.1196e-16, 1.0000e+00, 1.8540e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.4273e-17, 7.7174e-17, 1.7285e-09, 8.0805e-18],\n", + " [1.7456e-29, 2.7495e-28, 1.2097e-15, 6.2712e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0033, 0.0017, 0.9928, 0.0022], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5362e-11, 6.5483e-11, 1.0000e+00, 9.0383e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1974e-17, 3.0078e-16, 1.0000e+00, 9.1540e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.0693e-18, 4.1670e-17, 1.0733e-09, 4.3567e-18],\n", + " [6.7224e-30, 9.6348e-29, 5.4029e-16, 2.2212e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0025, 0.0012, 0.9948, 0.0016], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9658e-11, 4.1728e-11, 1.0000e+00, 6.1987e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4548e-17, 1.8233e-16, 1.0000e+00, 6.2719e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.1081e-18, 2.3093e-17, 6.4368e-10, 2.5401e-18],\n", + " [3.1998e-30, 3.5967e-29, 2.2943e-16, 9.1611e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8909e-03, 9.1155e-04, 9.9596e-01, 1.2372e-03],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0612e-11, 4.6392e-11, 1.0000e+00, 7.0609e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6574e-17, 2.6211e-16, 1.0000e+00, 9.5080e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7234e-18, 1.7384e-17, 3.4296e-10, 1.9493e-18],\n", + " [1.9632e-30, 2.2919e-29, 8.0029e-17, 6.1252e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4735e-04, 3.8817e-04, 9.9820e-01, 5.6062e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7854e-12, 1.0993e-11, 1.0000e+00, 2.0552e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5527e-18, 4.0936e-17, 1.0000e+00, 2.0528e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3785e-18, 9.8656e-18, 3.4898e-10, 1.2770e-18],\n", + " [9.5052e-31, 8.8916e-30, 8.4464e-17, 3.0872e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1134e-04, 3.3153e-04, 9.9849e-01, 4.7082e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7705e-12, 1.5144e-11, 1.0000e+00, 2.7758e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8748e-17, 8.1395e-17, 1.0000e+00, 4.0563e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9992e-18, 8.3596e-18, 1.8329e-10, 1.0790e-18],\n", + " [7.7411e-31, 7.2110e-30, 2.9415e-17, 2.5304e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5433e-04, 1.8571e-04, 9.9908e-01, 2.8463e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6705e-12, 5.0391e-12, 1.0000e+00, 1.1506e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5435e-18, 1.9513e-17, 1.0000e+00, 1.3579e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.2672e-18, 4.2560e-18, 1.5699e-10, 6.3402e-19],\n", + " [4.0089e-31, 2.5369e-30, 2.4167e-17, 1.1519e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.7942e-04, 1.5789e-04, 9.9923e-01, 2.3546e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6566e-12, 6.5606e-12, 1.0000e+00, 1.4493e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3746e-17, 3.6115e-17, 1.0000e+00, 2.4605e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1173e-18, 3.7830e-18, 9.1113e-11, 5.6039e-19],\n", + " [3.7479e-31, 2.3663e-30, 1.0353e-17, 1.0810e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4482e-04, 9.7343e-05, 9.9951e-01, 1.4992e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4851e-12, 3.0464e-12, 1.0000e+00, 7.5844e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8071e-18, 1.4457e-17, 1.0000e+00, 1.1954e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.7841e-19, 2.3999e-18, 7.6722e-11, 3.8796e-19],\n", + " [2.3178e-31, 1.2380e-30, 8.3401e-18, 6.6471e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9945e-04, 8.0773e-05, 9.9960e-01, 1.2029e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8828e-12, 3.6256e-12, 1.0000e+00, 8.6552e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0972e-17, 2.3750e-17, 1.0000e+00, 1.9063e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.0622e-19, 2.1931e-18, 4.8879e-11, 3.5157e-19],\n", + " [2.3676e-31, 1.2655e-30, 4.3056e-18, 6.8208e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6094e-05, 2.2092e-05, 9.9988e-01, 3.7903e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9188e-13, 6.3726e-13, 1.0000e+00, 2.3850e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9066e-18, 3.2138e-18, 1.0000e+00, 5.1068e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.2520e-19, 1.9825e-18, 6.8738e-11, 4.3247e-19],\n", + " [2.7693e-31, 1.1852e-30, 8.1485e-18, 1.0978e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4476e-05, 1.3948e-05, 9.9993e-01, 2.2885e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7600e-13, 5.3281e-13, 1.0000e+00, 1.8803e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1131e-18, 3.6674e-18, 1.0000e+00, 5.5916e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.3052e-19, 1.7445e-18, 4.5672e-11, 3.7523e-19],\n", + " [3.0026e-31, 1.2881e-30, 4.8993e-18, 1.1970e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3358e-06, 2.9791e-06, 9.9998e-01, 5.4342e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5138e-14, 7.5277e-14, 1.0000e+00, 3.8380e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8782e-19, 4.1228e-19, 1.0000e+00, 1.1049e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.8100e-19, 1.9267e-18, 7.6252e-11, 5.3853e-19],\n", + " [4.7827e-31, 1.6870e-30, 1.2190e-17, 2.4786e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8235e-06, 1.6078e-06, 9.9999e-01, 2.7841e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7305e-14, 6.0488e-14, 1.0000e+00, 2.8687e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4657e-19, 5.1629e-19, 1.0000e+00, 1.3164e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.3705e-19, 1.5991e-18, 4.2505e-11, 4.3795e-19],\n", + " [5.4348e-31, 1.9254e-30, 5.9958e-18, 2.8350e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2323e-06, 7.9875e-07, 1.0000e+00, 1.8333e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1852e-14, 8.8939e-15, 1.0000e+00, 7.4957e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5272e-20, 4.2060e-20, 1.0000e+00, 2.3695e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "40000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8427e-19, 3.8646e-19, 3.4708e-11, 1.4191e-19],\n", + " [1.1457e-31, 2.9746e-31, 5.6490e-18, 7.3013e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7772e-06, 6.4446e-07, 1.0000e+00, 1.4516e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3453e-14, 1.0322e-14, 1.0000e+00, 8.4492e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1637e-20, 6.7684e-20, 1.0000e+00, 3.7414e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "41000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.6288e-19, 3.4464e-19, 2.1518e-11, 1.2525e-19],\n", + " [1.1809e-31, 3.0768e-31, 2.9296e-18, 7.5512e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7060e-06, 6.2389e-07, 1.0000e+00, 1.3882e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8297e-14, 1.4242e-14, 1.0000e+00, 1.1438e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2899e-19, 1.2327e-19, 1.0000e+00, 6.7262e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.4987e-19, 3.1899e-19, 1.3974e-11, 1.1514e-19],\n", + " [1.1715e-31, 3.0613e-31, 1.5493e-18, 7.5068e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.5452e-06, 4.5520e-07, 1.0000e+00, 1.4649e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9570e-15, 1.3712e-15, 1.0000e+00, 2.5420e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6799e-21, 2.7451e-21, 1.0000e+00, 4.5273e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.9129e-20, 9.3077e-20, 3.0899e-11, 5.3616e-20],\n", + " [1.5776e-32, 2.5883e-32, 4.2920e-18, 1.3264e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2961e-06, 3.8515e-07, 1.0000e+00, 1.2282e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6824e-15, 1.7367e-15, 1.0000e+00, 3.1617e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0950e-20, 5.3364e-21, 1.0000e+00, 8.7508e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.1335e-20, 8.1473e-20, 1.8069e-11, 4.6513e-20],\n", + " [1.8694e-32, 3.0658e-32, 2.2128e-18, 1.5766e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2659e-06, 3.7803e-07, 1.0000e+00, 1.1994e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1405e-15, 2.4489e-15, 1.0000e+00, 4.4109e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1145e-20, 1.0360e-20, 1.0000e+00, 1.6925e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.7107e-20, 7.5151e-20, 1.1601e-11, 4.2661e-20],\n", + " [2.0156e-32, 3.3070e-32, 1.2068e-18, 1.7028e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3274e-06, 3.9765e-07, 1.0000e+00, 1.2576e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4471e-15, 3.5717e-15, 1.0000e+00, 6.3870e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0120e-20, 1.9725e-20, 1.0000e+00, 3.2147e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4463e-20, 7.1189e-20, 7.9255e-12, 4.0253e-20],\n", + " [2.1240e-32, 3.4859e-32, 7.0274e-19, 1.7964e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4754e-06, 4.4253e-07, 1.0000e+00, 1.3976e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1098e-14, 5.3412e-15, 1.0000e+00, 9.5150e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3680e-20, 3.6315e-20, 1.0000e+00, 5.9082e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2853e-20, 6.8760e-20, 5.6971e-12, 3.8785e-20],\n", + " [2.1058e-32, 3.4602e-32, 4.2166e-19, 1.7825e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6687e-06, 5.0084e-07, 1.0000e+00, 1.5806e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6317e-14, 7.8703e-15, 1.0000e+00, 1.3986e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2949e-19, 6.3937e-20, 1.0000e+00, 1.0389e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1714e-20, 6.7037e-20, 4.2661e-12, 3.7750e-20],\n", + " [2.0692e-32, 3.4038e-32, 2.6664e-19, 1.7527e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8879e-06, 5.6690e-07, 1.0000e+00, 1.7881e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3291e-14, 1.1253e-14, 1.0000e+00, 1.9961e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1626e-19, 1.0693e-19, 1.0000e+00, 1.7359e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0857e-20, 6.5740e-20, 3.3118e-12, 3.6969e-20],\n", + " [2.0419e-32, 3.3622e-32, 1.7825e-19, 1.7305e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1228e-06, 6.3767e-07, 1.0000e+00, 2.0104e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2131e-14, 1.5546e-14, 1.0000e+00, 2.7533e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4231e-19, 1.6943e-19, 1.0000e+00, 2.7485e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0180e-20, 6.4713e-20, 2.6545e-12, 3.6354e-20],\n", + " [2.0200e-32, 3.3284e-32, 1.2527e-19, 1.7126e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3652e-06, 7.1073e-07, 9.9999e-01, 2.2400e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2837e-14, 2.0748e-14, 1.0000e+00, 3.6702e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1467e-19, 2.5497e-19, 1.0000e+00, 4.1336e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9634e-20, 6.3884e-20, 2.1884e-12, 3.5856e-20],\n", + " [2.0025e-32, 3.3015e-32, 9.2029e-20, 1.6983e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6089e-06, 7.8416e-07, 9.9999e-01, 2.4706e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5319e-14, 2.6819e-14, 1.0000e+00, 4.7391e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3853e-19, 3.6617e-19, 1.0000e+00, 5.9331e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9188e-20, 6.3208e-20, 1.8481e-12, 3.5451e-20],\n", + " [1.9885e-32, 3.2802e-32, 7.0245e-20, 1.6869e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.8500e-06, 8.5682e-07, 9.9999e-01, 2.6989e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9445e-14, 3.3696e-14, 1.0000e+00, 5.9489e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0173e-18, 5.0474e-19, 1.0000e+00, 8.1746e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8806e-20, 6.2629e-20, 1.5926e-12, 3.5103e-20],\n", + " [1.9763e-32, 3.2615e-32, 5.5365e-20, 1.6769e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0859e-06, 9.2791e-07, 9.9999e-01, 2.9222e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5075e-14, 4.1308e-14, 1.0000e+00, 7.2872e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3534e-18, 6.7182e-19, 1.0000e+00, 1.0877e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8472e-20, 6.2124e-20, 1.3955e-12, 3.4800e-20],\n", + " [1.9657e-32, 3.2451e-32, 4.4821e-20, 1.6683e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3154e-06, 9.9709e-07, 9.9999e-01, 3.1395e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0207e-13, 4.9590e-14, 1.0000e+00, 8.7425e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7478e-18, 8.6803e-19, 1.0000e+00, 1.4049e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8174e-20, 6.1671e-20, 1.2400e-12, 3.4529e-20],\n", + " [1.9561e-32, 3.2303e-32, 3.7106e-20, 1.6604e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1540e-06, 5.3059e-07, 1.0000e+00, 2.2038e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8992e-15, 1.4322e-15, 1.0000e+00, 4.9399e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9516e-21, 2.0604e-21, 1.0000e+00, 7.9208e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.9095e-21, 1.0574e-20, 3.9171e-12, 8.7803e-21],\n", + " [3.2668e-34, 3.4364e-34, 8.8493e-20, 3.1806e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1154e-06, 5.2108e-07, 1.0000e+00, 2.1649e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2607e-15, 1.5399e-15, 1.0000e+00, 5.3053e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3560e-21, 2.4250e-21, 1.0000e+00, 9.3274e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.6996e-21, 1.0338e-20, 3.4982e-12, 8.5725e-21],\n", + " [3.3789e-34, 3.5553e-34, 7.6395e-20, 3.2914e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1129e-06, 5.2047e-07, 1.0000e+00, 2.1630e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8475e-15, 1.7139e-15, 1.0000e+00, 5.8981e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1533e-20, 2.9897e-21, 1.0000e+00, 1.1506e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.5088e-21, 1.0124e-20, 3.0744e-12, 8.3835e-21],\n", + " [3.5079e-34, 3.6917e-34, 6.4267e-20, 3.4187e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1467e-06, 5.2880e-07, 1.0000e+00, 2.1982e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6968e-15, 1.9651e-15, 1.0000e+00, 6.7557e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4753e-20, 3.8247e-21, 1.0000e+00, 1.4729e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "59000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.3363e-21, 9.9306e-21, 2.6723e-12, 8.2130e-21],\n", + " [3.6431e-34, 3.8341e-34, 5.3011e-20, 3.5518e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2139e-06, 5.4537e-07, 9.9999e-01, 2.2675e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8418e-15, 2.3036e-15, 1.0000e+00, 7.9118e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9346e-20, 5.0157e-21, 1.0000e+00, 1.9325e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.1870e-21, 9.7631e-21, 2.3114e-12, 8.0650e-21],\n", + " [3.7799e-34, 3.9783e-34, 4.3258e-20, 3.6867e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3078e-06, 5.6854e-07, 9.9999e-01, 2.3642e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2965e-15, 2.7338e-15, 1.0000e+00, 9.3805e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5641e-20, 6.6486e-21, 1.0000e+00, 2.5627e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "61000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.0608e-21, 9.6219e-21, 2.0010e-12, 7.9397e-21],\n", + " [3.9153e-34, 4.1209e-34, 3.5240e-20, 3.8199e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4218e-06, 5.9667e-07, 9.9999e-01, 2.4814e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1065e-14, 3.2568e-15, 1.0000e+00, 1.1166e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3961e-20, 8.8065e-21, 1.0000e+00, 3.3958e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.9505e-21, 9.4982e-21, 1.7402e-12, 7.8304e-21],\n", + " [4.0418e-34, 4.2540e-34, 2.8823e-20, 3.9444e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.5460e-06, 6.2729e-07, 9.9999e-01, 2.6090e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3102e-14, 3.8594e-15, 1.0000e+00, 1.3222e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4428e-20, 1.1521e-20, 1.0000e+00, 4.4442e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.8537e-21, 9.3898e-21, 1.5262e-12, 7.7346e-21],\n", + " [4.1595e-34, 4.3779e-34, 2.3836e-20, 4.0603e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6753e-06, 6.5917e-07, 9.9999e-01, 2.7419e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5381e-14, 4.5341e-15, 1.0000e+00, 1.5524e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7187e-20, 1.4830e-20, 1.0000e+00, 5.7225e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.7683e-21, 9.2939e-21, 1.3512e-12, 7.6501e-21],\n", + " [4.2685e-34, 4.4925e-34, 1.9969e-20, 4.1677e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8053e-06, 6.9124e-07, 9.9999e-01, 2.8755e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7868e-14, 5.2706e-15, 1.0000e+00, 1.8035e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2272e-20, 1.8742e-20, 1.0000e+00, 7.2344e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.6947e-21, 9.2114e-21, 1.2081e-12, 7.5773e-21],\n", + " [4.3692e-34, 4.5984e-34, 1.6960e-20, 4.2668e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9342e-06, 7.2303e-07, 9.9999e-01, 3.0079e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0536e-14, 6.0611e-15, 1.0000e+00, 2.0730e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9734e-20, 2.3271e-20, 1.0000e+00, 8.9853e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.6275e-21, 9.1358e-21, 1.0898e-12, 7.5106e-21],\n", + " [4.4626e-34, 4.6965e-34, 1.4592e-20, 4.3589e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0608e-06, 7.5429e-07, 9.9999e-01, 3.1380e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3361e-14, 6.8987e-15, 1.0000e+00, 2.3582e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0957e-19, 2.8417e-20, 1.0000e+00, 1.0975e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.5648e-21, 9.0652e-21, 9.9117e-13, 7.4485e-21],\n", + " [4.5484e-34, 4.7867e-34, 1.2705e-20, 4.4434e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1846e-06, 7.8484e-07, 9.9999e-01, 3.2652e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6324e-14, 7.7778e-15, 1.0000e+00, 2.6575e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3176e-19, 3.4172e-20, 1.0000e+00, 1.3200e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.5068e-21, 8.9998e-21, 9.0815e-13, 7.3914e-21],\n", + " [4.6257e-34, 4.8679e-34, 1.1180e-20, 4.5198e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3042e-06, 8.1435e-07, 9.9999e-01, 3.3881e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9405e-14, 8.6920e-15, 1.0000e+00, 2.9687e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5628e-19, 4.0533e-20, 1.0000e+00, 1.5661e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.4546e-21, 8.9408e-21, 8.3769e-13, 7.3398e-21],\n", + " [4.6998e-34, 4.9456e-34, 9.9365e-21, 4.5929e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4193e-06, 8.4272e-07, 9.9999e-01, 3.5064e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2593e-14, 9.6378e-15, 1.0000e+00, 3.2907e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8314e-19, 4.7495e-20, 1.0000e+00, 1.8356e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.4084e-21, 8.8886e-21, 7.7723e-13, 7.2942e-21],\n", + " [4.7704e-34, 5.0198e-34, 8.9069e-21, 4.6627e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5318e-06, 8.7043e-07, 9.9999e-01, 3.6221e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5905e-14, 1.0621e-14, 1.0000e+00, 3.6253e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1252e-19, 5.5111e-20, 1.0000e+00, 2.1305e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.3695e-21, 8.8451e-21, 7.2492e-13, 7.2556e-21],\n", + " [4.8409e-34, 5.0939e-34, 8.0453e-21, 4.7324e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6413e-06, 8.9741e-07, 9.9999e-01, 3.7346e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9322e-14, 1.1635e-14, 1.0000e+00, 3.9705e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4439e-19, 6.3375e-20, 1.0000e+00, 2.4505e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.3359e-21, 8.8078e-21, 6.7933e-13, 7.2223e-21],\n", + " [4.9125e-34, 5.1691e-34, 7.3196e-21, 4.8030e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.7465e-06, 9.2334e-07, 9.9999e-01, 3.8429e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2817e-14, 1.2673e-14, 1.0000e+00, 4.3236e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7860e-19, 7.2245e-20, 1.0000e+00, 2.7942e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.3030e-21, 8.7709e-21, 6.3904e-13, 7.1897e-21],\n", + " [4.9811e-34, 5.2410e-34, 6.6984e-21, 4.8704e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8490e-06, 9.4857e-07, 9.9999e-01, 3.9484e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6400e-14, 1.3737e-14, 1.0000e+00, 4.6858e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1526e-19, 8.1746e-20, 1.0000e+00, 3.1625e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.2703e-21, 8.7343e-21, 6.0310e-13, 7.1574e-21],\n", + " [5.0444e-34, 5.3075e-34, 6.1589e-21, 4.9329e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9493e-06, 9.7328e-07, 9.9999e-01, 4.0516e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0074e-14, 1.4829e-14, 1.0000e+00, 5.0572e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5435e-19, 9.1877e-20, 1.0000e+00, 3.5554e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.2379e-21, 8.6975e-21, 5.7086e-13, 7.1253e-21],\n", + " [5.1014e-34, 5.3672e-34, 5.6857e-21, 4.9891e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0478e-06, 9.9750e-07, 9.9999e-01, 4.1530e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3843e-14, 1.5948e-14, 1.0000e+00, 5.4382e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9607e-19, 1.0269e-19, 1.0000e+00, 3.9747e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.2055e-21, 8.6609e-21, 5.4170e-13, 7.0933e-21],\n", + " [5.1560e-34, 5.4245e-34, 5.2694e-21, 5.0432e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1422e-06, 1.0207e-06, 9.9999e-01, 4.2503e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7642e-14, 1.7077e-14, 1.0000e+00, 5.8225e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3983e-19, 1.1402e-19, 1.0000e+00, 4.4148e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.1733e-21, 8.6244e-21, 5.1549e-13, 7.0616e-21],\n", + " [5.2079e-34, 5.4788e-34, 4.9048e-21, 5.0945e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2352e-06, 1.0436e-06, 9.9999e-01, 4.3462e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1531e-14, 1.8233e-14, 1.0000e+00, 6.2159e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8619e-19, 1.2603e-19, 1.0000e+00, 4.8812e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "78000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.1422e-21, 8.5890e-21, 4.9160e-13, 7.0309e-21],\n", + " [5.2569e-34, 5.5300e-34, 4.5793e-21, 5.1429e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3279e-06, 1.0664e-06, 9.9999e-01, 4.4418e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5545e-14, 1.9427e-14, 1.0000e+00, 6.6220e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3560e-19, 1.3883e-19, 1.0000e+00, 5.3784e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.1122e-21, 8.5550e-21, 4.6963e-13, 7.0013e-21],\n", + " [5.3049e-34, 5.5805e-34, 4.2866e-21, 5.1905e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4163e-06, 1.0882e-06, 9.9999e-01, 4.5330e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9554e-14, 2.0620e-14, 1.0000e+00, 7.0276e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8678e-19, 1.5209e-19, 1.0000e+00, 5.8934e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.0839e-21, 8.5226e-21, 4.4979e-13, 6.9731e-21],\n", + " [5.3526e-34, 5.6304e-34, 4.0287e-21, 5.2377e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5051e-06, 1.1101e-06, 9.9999e-01, 4.6245e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3700e-14, 2.1854e-14, 1.0000e+00, 7.4471e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4130e-19, 1.6622e-19, 1.0000e+00, 6.4422e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "81000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.0558e-21, 8.4908e-21, 4.3131e-13, 6.9456e-21],\n", + " [5.3998e-34, 5.6798e-34, 3.7932e-21, 5.2841e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5907e-06, 1.1312e-06, 9.9999e-01, 4.7128e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7859e-14, 2.3092e-14, 1.0000e+00, 7.8680e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9758e-19, 1.8080e-19, 1.0000e+00, 7.0089e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.0290e-21, 8.4602e-21, 4.1444e-13, 6.9191e-21],\n", + " [5.4423e-34, 5.7245e-34, 3.5816e-21, 5.3264e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.6776e-06, 1.1526e-06, 9.9999e-01, 4.8024e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2182e-14, 2.4378e-14, 1.0000e+00, 8.3056e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5746e-19, 1.9632e-19, 1.0000e+00, 7.6119e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.0034e-21, 8.4310e-21, 3.9862e-13, 6.8938e-21],\n", + " [5.4817e-34, 5.7661e-34, 3.3852e-21, 5.3655e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7599e-06, 1.1728e-06, 9.9999e-01, 4.8873e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6455e-14, 2.5650e-14, 1.0000e+00, 8.7380e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1851e-19, 2.1214e-19, 1.0000e+00, 8.2266e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.9784e-21, 8.4024e-21, 3.8421e-13, 6.8692e-21],\n", + " [5.5202e-34, 5.8063e-34, 3.2102e-21, 5.4035e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8439e-06, 1.1935e-06, 9.9999e-01, 4.9738e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0905e-14, 2.6975e-14, 1.0000e+00, 9.1881e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8361e-19, 2.2900e-19, 1.0000e+00, 8.8819e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.9546e-21, 8.3753e-21, 3.7058e-13, 6.8455e-21],\n", + " [5.5584e-34, 5.8464e-34, 3.0471e-21, 5.4412e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9248e-06, 1.2135e-06, 9.9999e-01, 5.0572e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5352e-14, 2.8299e-14, 1.0000e+00, 9.6379e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5044e-19, 2.4632e-19, 1.0000e+00, 9.5547e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.9307e-21, 8.3480e-21, 3.5796e-13, 6.8220e-21],\n", + " [5.5944e-34, 5.8841e-34, 2.8988e-21, 5.4769e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0038e-06, 1.2329e-06, 9.9999e-01, 5.1385e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9835e-14, 2.9634e-14, 1.0000e+00, 1.0091e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0196e-18, 2.6422e-19, 1.0000e+00, 1.0251e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.9069e-21, 8.3209e-21, 3.4619e-13, 6.7985e-21],\n", + " [5.6294e-34, 5.9209e-34, 2.7629e-21, 5.5115e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0841e-06, 1.2527e-06, 9.9999e-01, 5.2211e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0449e-13, 3.1021e-14, 1.0000e+00, 1.0562e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0928e-18, 2.8321e-19, 1.0000e+00, 1.0989e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.8851e-21, 8.2961e-21, 3.3501e-13, 6.7770e-21],\n", + " [5.6650e-34, 5.9584e-34, 2.6355e-21, 5.5466e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1627e-06, 1.2721e-06, 9.9999e-01, 5.3019e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0916e-13, 3.2415e-14, 1.0000e+00, 1.1034e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1681e-18, 3.0273e-19, 1.0000e+00, 1.1746e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.8648e-21, 8.2731e-21, 3.2468e-13, 6.7568e-21],\n", + " [5.7004e-34, 5.9956e-34, 2.5194e-21, 5.5817e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2387e-06, 1.2908e-06, 9.9999e-01, 5.3799e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1382e-13, 3.3805e-14, 1.0000e+00, 1.1505e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2448e-18, 3.2261e-19, 1.0000e+00, 1.2518e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.8454e-21, 8.2512e-21, 3.1507e-13, 6.7377e-21],\n", + " [5.7332e-34, 6.0302e-34, 2.4128e-21, 5.6140e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3161e-06, 1.3099e-06, 9.9999e-01, 5.4594e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1866e-13, 3.5247e-14, 1.0000e+00, 1.1994e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3259e-18, 3.4364e-19, 1.0000e+00, 1.3334e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.8273e-21, 8.2307e-21, 3.0588e-13, 6.7197e-21],\n", + " [5.7662e-34, 6.0649e-34, 2.3119e-21, 5.6464e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4585e-06, 3.9830e-07, 1.0000e+00, 1.5152e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5722e-15, 8.8762e-16, 1.0000e+00, 2.6457e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9181e-21, 1.5642e-21, 1.0000e+00, 5.0581e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1589e-21, 2.7281e-21, 1.2242e-12, 2.1376e-21],\n", + " [6.1309e-35, 7.1402e-35, 1.8182e-20, 6.0696e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4398e-06, 3.9327e-07, 1.0000e+00, 1.4959e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6129e-15, 9.0229e-16, 1.0000e+00, 2.6878e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1669e-21, 1.6435e-21, 1.0000e+00, 5.3157e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1397e-21, 2.7051e-21, 1.1790e-12, 2.1184e-21],\n", + " [6.2566e-35, 7.2861e-35, 1.7434e-20, 6.1954e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4318e-06, 3.9116e-07, 1.0000e+00, 1.4879e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6971e-15, 9.3202e-16, 1.0000e+00, 2.7747e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5465e-21, 1.7645e-21, 1.0000e+00, 5.7081e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1208e-21, 2.6826e-21, 1.1259e-12, 2.0996e-21],\n", + " [6.3835e-35, 7.4336e-35, 1.6479e-20, 6.3220e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4355e-06, 3.9224e-07, 1.0000e+00, 1.4919e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8306e-15, 9.7884e-16, 1.0000e+00, 2.9124e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0848e-21, 1.9360e-21, 1.0000e+00, 6.2642e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1024e-21, 2.6607e-21, 1.0662e-12, 2.0814e-21],\n", + " [6.5087e-35, 7.5790e-35, 1.5355e-20, 6.4473e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4511e-06, 3.9656e-07, 1.0000e+00, 1.5082e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0171e-15, 1.0440e-15, 1.0000e+00, 3.1046e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8082e-21, 2.1665e-21, 1.0000e+00, 7.0109e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0850e-21, 2.6400e-21, 1.0027e-12, 2.0640e-21],\n", + " [6.6305e-35, 7.7207e-35, 1.4132e-20, 6.5693e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4771e-06, 4.0375e-07, 1.0000e+00, 1.5355e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2558e-15, 1.1274e-15, 1.0000e+00, 3.3505e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7318e-21, 2.4608e-21, 1.0000e+00, 7.9643e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "97000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0686e-21, 2.6205e-21, 9.3851e-13, 2.0478e-21],\n", + " [6.7458e-35, 7.8544e-35, 1.2887e-20, 6.6844e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5116e-06, 4.1325e-07, 1.0000e+00, 1.5716e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5442e-15, 1.2279e-15, 1.0000e+00, 3.6475e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8710e-21, 2.8237e-21, 1.0000e+00, 9.1404e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0535e-21, 2.6025e-21, 8.7586e-13, 2.0328e-21],\n", + " [6.8571e-35, 7.9838e-35, 1.1685e-20, 6.7960e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5509e-06, 4.2403e-07, 1.0000e+00, 1.6125e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8708e-15, 1.3418e-15, 1.0000e+00, 3.9840e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0210e-20, 3.2499e-21, 1.0000e+00, 1.0523e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0397e-21, 2.5860e-21, 8.1723e-13, 2.0191e-21],\n", + " [6.9657e-35, 8.1099e-35, 1.0582e-20, 6.9049e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5950e-06, 4.3612e-07, 1.0000e+00, 1.6586e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2393e-15, 1.4701e-15, 1.0000e+00, 4.3636e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1774e-20, 3.7480e-21, 1.0000e+00, 1.2138e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0274e-21, 2.5714e-21, 7.6281e-13, 2.0069e-21],\n", + " [7.0683e-35, 8.2287e-35, 9.5752e-21, 7.0076e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6395e-06, 4.4833e-07, 1.0000e+00, 1.7051e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6284e-15, 1.6058e-15, 1.0000e+00, 4.7646e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3506e-20, 4.2992e-21, 1.0000e+00, 1.3927e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "101000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0171e-21, 2.5592e-21, 7.1452e-13, 1.9966e-21],\n", + " [7.1748e-35, 8.3522e-35, 8.7098e-21, 7.1141e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6858e-06, 4.6101e-07, 1.0000e+00, 1.7534e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0464e-15, 1.7514e-15, 1.0000e+00, 5.1951e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5445e-20, 4.9166e-21, 1.0000e+00, 1.5930e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0077e-21, 2.5481e-21, 6.7073e-13, 1.9873e-21],\n", + " [7.2802e-35, 8.4744e-35, 7.9463e-21, 7.2194e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.7308e-06, 4.7334e-07, 1.0000e+00, 1.8003e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4763e-15, 1.9013e-15, 1.0000e+00, 5.6382e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7537e-20, 5.5826e-21, 1.0000e+00, 1.8091e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9986e-21, 2.5373e-21, 6.3167e-13, 1.9783e-21],\n", + " [7.3812e-35, 8.5918e-35, 7.2849e-21, 7.3204e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7756e-06, 4.8562e-07, 1.0000e+00, 1.8472e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9227e-15, 2.0570e-15, 1.0000e+00, 6.0984e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9797e-20, 6.3021e-21, 1.0000e+00, 2.0428e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9894e-21, 2.5264e-21, 5.9644e-13, 1.9691e-21],\n", + " [7.4729e-35, 8.6979e-35, 6.7024e-21, 7.4120e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8199e-06, 4.9773e-07, 1.0000e+00, 1.8934e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3830e-15, 2.2176e-15, 1.0000e+00, 6.5729e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2221e-20, 7.0736e-21, 1.0000e+00, 2.2933e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9804e-21, 2.5156e-21, 5.6464e-13, 1.9601e-21],\n", + " [7.5569e-35, 8.7955e-35, 6.1889e-21, 7.4962e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8634e-06, 5.0965e-07, 1.0000e+00, 1.9389e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8562e-15, 2.3826e-15, 1.0000e+00, 7.0608e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4815e-20, 7.8991e-21, 1.0000e+00, 2.5616e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9714e-21, 2.5049e-21, 5.3580e-13, 1.9512e-21],\n", + " [7.6378e-35, 8.8892e-35, 5.7355e-21, 7.5774e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9059e-06, 5.2129e-07, 1.0000e+00, 1.9834e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3381e-15, 2.5508e-15, 1.0000e+00, 7.5580e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7556e-20, 8.7711e-21, 1.0000e+00, 2.8451e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9625e-21, 2.4941e-21, 5.0971e-13, 1.9423e-21],\n", + " [7.7134e-35, 8.9766e-35, 5.3351e-21, 7.6531e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9472e-06, 5.3261e-07, 1.0000e+00, 2.0266e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8272e-15, 2.7215e-15, 1.0000e+00, 8.0628e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0440e-20, 9.6890e-21, 1.0000e+00, 3.1437e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9537e-21, 2.4836e-21, 4.8604e-13, 1.9337e-21],\n", + " [7.7850e-35, 9.0593e-35, 4.9800e-21, 7.7251e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9884e-06, 5.4389e-07, 1.0000e+00, 2.0697e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3317e-15, 2.8977e-15, 1.0000e+00, 8.5835e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3514e-20, 1.0668e-20, 1.0000e+00, 3.4621e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9454e-21, 2.4736e-21, 4.6428e-13, 1.9255e-21],\n", + " [7.8557e-35, 9.1413e-35, 4.6607e-21, 7.7960e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0279e-06, 5.5474e-07, 1.0000e+00, 2.1111e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8386e-15, 3.0749e-15, 1.0000e+00, 9.1067e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6715e-20, 1.1687e-20, 1.0000e+00, 3.7935e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9374e-21, 2.4639e-21, 4.4452e-13, 1.9175e-21],\n", + " [7.9264e-35, 9.2232e-35, 4.3781e-21, 7.8669e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0673e-06, 5.6553e-07, 1.0000e+00, 2.1524e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3590e-15, 3.2568e-15, 1.0000e+00, 9.6438e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0101e-20, 1.2765e-20, 1.0000e+00, 4.1441e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9297e-21, 2.4547e-21, 4.2626e-13, 1.9099e-21],\n", + " [7.9943e-35, 9.3020e-35, 4.1213e-21, 7.9351e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1057e-06, 5.7605e-07, 1.0000e+00, 2.1925e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8850e-15, 3.4406e-15, 1.0000e+00, 1.0187e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3614e-20, 1.3883e-20, 1.0000e+00, 4.5079e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9224e-21, 2.4458e-21, 4.0951e-13, 1.9026e-21],\n", + " [8.0547e-35, 9.3723e-35, 3.8888e-21, 7.9959e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.1444e-06, 5.8665e-07, 9.9999e-01, 2.2330e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0428e-14, 3.6303e-15, 1.0000e+00, 1.0747e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7326e-20, 1.5065e-20, 1.0000e+00, 4.8925e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9154e-21, 2.4375e-21, 3.9389e-13, 1.8957e-21],\n", + " [8.1104e-35, 9.4367e-35, 3.6749e-21, 8.0518e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1815e-06, 5.9682e-07, 9.9999e-01, 2.2718e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0969e-14, 3.8196e-15, 1.0000e+00, 1.1306e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1136e-20, 1.6277e-20, 1.0000e+00, 5.2873e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9086e-21, 2.4293e-21, 3.7958e-13, 1.8889e-21],\n", + " [8.1633e-35, 9.4978e-35, 3.4825e-21, 8.1046e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2194e-06, 6.0722e-07, 9.9999e-01, 2.3115e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1532e-14, 4.0168e-15, 1.0000e+00, 1.1887e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5195e-20, 1.7570e-20, 1.0000e+00, 5.7077e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9020e-21, 2.4213e-21, 3.6604e-13, 1.8824e-21],\n", + " [8.2144e-35, 9.5570e-35, 3.3030e-21, 8.1557e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2554e-06, 6.1708e-07, 9.9999e-01, 2.3491e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2089e-14, 4.2116e-15, 1.0000e+00, 1.2462e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9318e-20, 1.8883e-20, 1.0000e+00, 6.1349e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "116000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8955e-21, 2.4134e-21, 3.5362e-13, 1.8759e-21],\n", + " [8.2632e-35, 9.6137e-35, 3.1417e-21, 8.2048e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2908e-06, 6.2680e-07, 9.9999e-01, 2.3862e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2655e-14, 4.4097e-15, 1.0000e+00, 1.3046e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3623e-20, 2.0252e-20, 1.0000e+00, 6.5806e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8891e-21, 2.4057e-21, 3.4195e-13, 1.8696e-21],\n", + " [8.3111e-35, 9.6693e-35, 2.9926e-21, 8.2530e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3271e-06, 6.3675e-07, 9.9999e-01, 2.4241e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3245e-14, 4.6161e-15, 1.0000e+00, 1.3654e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8193e-20, 2.1708e-20, 1.0000e+00, 7.0541e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8831e-21, 2.3985e-21, 3.3085e-13, 1.8636e-21],\n", + " [8.3591e-35, 9.7246e-35, 2.8525e-21, 8.3007e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3620e-06, 6.4637e-07, 9.9999e-01, 2.4605e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3828e-14, 4.8205e-15, 1.0000e+00, 1.4255e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2815e-20, 2.3181e-20, 1.0000e+00, 7.5328e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8775e-21, 2.3918e-21, 3.2071e-13, 1.8580e-21],\n", + " [8.4047e-35, 9.7778e-35, 2.7264e-21, 8.3466e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3964e-06, 6.5579e-07, 9.9999e-01, 2.4963e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4418e-14, 5.0274e-15, 1.0000e+00, 1.4864e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7594e-20, 2.4703e-20, 1.0000e+00, 8.0273e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8723e-21, 2.3856e-21, 3.1118e-13, 1.8529e-21],\n", + " [8.4492e-35, 9.8294e-35, 2.6094e-21, 8.3909e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4316e-06, 6.6548e-07, 9.9999e-01, 2.5331e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5032e-14, 5.2426e-15, 1.0000e+00, 1.5497e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2658e-20, 2.6317e-20, 1.0000e+00, 8.5518e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "121000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8675e-21, 2.3799e-21, 3.0210e-13, 1.8481e-21],\n", + " [8.4963e-35, 9.8841e-35, 2.4994e-21, 8.4379e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4676e-06, 6.7537e-07, 9.9999e-01, 2.5706e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5670e-14, 5.4663e-15, 1.0000e+00, 1.6154e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8021e-20, 2.8026e-20, 1.0000e+00, 9.1071e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8630e-21, 2.3745e-21, 2.9338e-13, 1.8436e-21],\n", + " [8.5442e-35, 9.9399e-35, 2.3953e-21, 8.4860e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.4999e-06, 6.8428e-07, 9.9999e-01, 2.6044e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6276e-14, 5.6791e-15, 1.0000e+00, 1.6779e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3274e-20, 2.9701e-20, 1.0000e+00, 9.6511e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8592e-21, 2.3699e-21, 2.8556e-13, 1.8398e-21],\n", + " [8.5968e-35, 1.0001e-34, 2.3041e-21, 8.5382e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5327e-06, 6.9331e-07, 9.9999e-01, 2.6386e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6901e-14, 5.8984e-15, 1.0000e+00, 1.7423e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8775e-20, 3.1454e-20, 1.0000e+00, 1.0221e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8557e-21, 2.3659e-21, 2.7810e-13, 1.8363e-21],\n", + " [8.6487e-35, 1.0061e-34, 2.2177e-21, 8.5903e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5661e-06, 7.0247e-07, 9.9999e-01, 2.6734e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7547e-14, 6.1252e-15, 1.0000e+00, 1.8090e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0456e-19, 3.3297e-20, 1.0000e+00, 1.0819e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8526e-21, 2.3622e-21, 2.7092e-13, 1.8332e-21],\n", + " [8.7003e-35, 1.0121e-34, 2.1353e-21, 8.6415e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5998e-06, 7.1173e-07, 9.9999e-01, 2.7086e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8212e-14, 6.3584e-15, 1.0000e+00, 1.8775e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1060e-19, 3.5225e-20, 1.0000e+00, 1.1446e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8497e-21, 2.3588e-21, 2.6405e-13, 1.8303e-21],\n", + " [8.7516e-35, 1.0181e-34, 2.0571e-21, 8.6927e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6335e-06, 7.2100e-07, 9.9999e-01, 2.7438e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8894e-14, 6.5978e-15, 1.0000e+00, 1.9479e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1692e-19, 3.7238e-20, 1.0000e+00, 1.2100e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8473e-21, 2.3562e-21, 2.5748e-13, 1.8279e-21],\n", + " [8.8039e-35, 1.0241e-34, 1.9830e-21, 8.7450e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6637e-06, 7.2932e-07, 9.9999e-01, 2.7753e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9541e-14, 6.8248e-15, 1.0000e+00, 2.0146e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2304e-19, 3.9187e-20, 1.0000e+00, 1.2734e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8456e-21, 2.3542e-21, 2.5158e-13, 1.8262e-21],\n", + " [8.8551e-35, 1.0301e-34, 1.9171e-21, 8.7961e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6943e-06, 7.3771e-07, 9.9999e-01, 2.8072e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0203e-14, 7.0571e-15, 1.0000e+00, 2.0828e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2939e-19, 4.1209e-20, 1.0000e+00, 1.3391e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8438e-21, 2.3523e-21, 2.4590e-13, 1.8245e-21],\n", + " [8.9041e-35, 1.0358e-34, 1.8542e-21, 8.8450e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7252e-06, 7.4620e-07, 9.9999e-01, 2.8394e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0884e-14, 7.2963e-15, 1.0000e+00, 2.1531e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3603e-19, 4.3327e-20, 1.0000e+00, 1.4080e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8425e-21, 2.3508e-21, 2.4043e-13, 1.8231e-21],\n", + " [8.9561e-35, 1.0418e-34, 1.7942e-21, 8.8967e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7570e-06, 7.5493e-07, 9.9999e-01, 2.8726e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1592e-14, 7.5447e-15, 1.0000e+00, 2.2261e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4303e-19, 4.5558e-20, 1.0000e+00, 1.4805e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8419e-21, 2.3504e-21, 2.3518e-13, 1.8225e-21],\n", + " [9.0138e-35, 1.0485e-34, 1.7374e-21, 8.9543e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7896e-06, 7.6388e-07, 9.9999e-01, 2.9067e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2324e-14, 7.8016e-15, 1.0000e+00, 2.3015e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5036e-19, 4.7892e-20, 1.0000e+00, 1.5564e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8415e-21, 2.3501e-21, 2.3011e-13, 1.8221e-21],\n", + " [9.0703e-35, 1.0550e-34, 1.6828e-21, 9.0106e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.8226e-06, 7.7296e-07, 9.9999e-01, 2.9411e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3078e-14, 8.0660e-15, 1.0000e+00, 2.3793e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5801e-19, 5.0331e-20, 1.0000e+00, 1.6356e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8412e-21, 2.3499e-21, 2.2519e-13, 1.8217e-21],\n", + " [9.1260e-35, 1.0615e-34, 1.6303e-21, 9.0662e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8528e-06, 7.8125e-07, 9.9999e-01, 2.9727e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3799e-14, 8.3190e-15, 1.0000e+00, 2.4536e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6549e-19, 5.2715e-20, 1.0000e+00, 1.7132e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8408e-21, 2.3497e-21, 2.2066e-13, 1.8213e-21],\n", + " [9.1806e-35, 1.0679e-34, 1.5826e-21, 9.1206e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8815e-06, 7.8912e-07, 9.9999e-01, 3.0026e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4506e-14, 8.5673e-15, 1.0000e+00, 2.5265e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7298e-19, 5.5101e-20, 1.0000e+00, 1.7907e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "135000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8404e-21, 2.3495e-21, 2.1641e-13, 1.8210e-21],\n", + " [9.2355e-35, 1.0742e-34, 1.5385e-21, 9.1754e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9104e-06, 7.9707e-07, 9.9999e-01, 3.0328e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5230e-14, 8.8215e-15, 1.0000e+00, 2.6012e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8075e-19, 5.7578e-20, 1.0000e+00, 1.8713e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8401e-21, 2.3492e-21, 2.1226e-13, 1.8206e-21],\n", + " [9.2903e-35, 1.0806e-34, 1.4959e-21, 9.2299e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9396e-06, 8.0508e-07, 9.9999e-01, 3.0633e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5968e-14, 9.0807e-15, 1.0000e+00, 2.6774e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8878e-19, 6.0135e-20, 1.0000e+00, 1.9545e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8397e-21, 2.3490e-21, 2.0826e-13, 1.8202e-21],\n", + " [9.3443e-35, 1.0868e-34, 1.4550e-21, 9.2835e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9692e-06, 8.1320e-07, 9.9999e-01, 3.0942e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6727e-14, 9.3470e-15, 1.0000e+00, 2.7556e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9714e-19, 6.2797e-20, 1.0000e+00, 2.0410e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8394e-21, 2.3487e-21, 2.0434e-13, 1.8198e-21],\n", + " [9.3973e-35, 1.0930e-34, 1.4154e-21, 9.3363e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9989e-06, 8.2137e-07, 9.9999e-01, 3.1252e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7501e-14, 9.6189e-15, 1.0000e+00, 2.8354e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0579e-19, 6.5553e-20, 1.0000e+00, 2.1306e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8390e-21, 2.3485e-21, 2.0054e-13, 1.8194e-21],\n", + " [9.4503e-35, 1.0991e-34, 1.3772e-21, 9.3890e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0294e-06, 8.2973e-07, 9.9999e-01, 3.1571e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8300e-14, 9.8993e-15, 1.0000e+00, 2.9178e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1482e-19, 6.8430e-20, 1.0000e+00, 2.2242e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8386e-21, 2.3482e-21, 1.9682e-13, 1.8190e-21],\n", + " [9.5030e-35, 1.1052e-34, 1.3402e-21, 9.4416e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0605e-06, 8.3827e-07, 9.9999e-01, 3.1896e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9123e-14, 1.0188e-14, 1.0000e+00, 3.0026e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2422e-19, 7.1424e-20, 1.0000e+00, 2.3216e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "141000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8383e-21, 2.3479e-21, 1.9319e-13, 1.8187e-21],\n", + " [9.5554e-35, 1.1113e-34, 1.3043e-21, 9.4935e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0919e-06, 8.4688e-07, 9.9999e-01, 3.2223e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9961e-14, 1.0483e-14, 1.0000e+00, 3.0891e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3392e-19, 7.4515e-20, 1.0000e+00, 2.4222e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8379e-21, 2.3477e-21, 1.8967e-13, 1.8183e-21],\n", + " [9.6058e-35, 1.1172e-34, 1.2697e-21, 9.5439e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.1196e-06, 8.5449e-07, 9.9999e-01, 3.2513e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0741e-14, 1.0756e-14, 1.0000e+00, 3.1695e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4314e-19, 7.7454e-20, 1.0000e+00, 2.5177e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8376e-21, 2.3474e-21, 1.8648e-13, 1.8179e-21],\n", + " [9.6556e-35, 1.1229e-34, 1.2389e-21, 9.5935e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1460e-06, 8.6175e-07, 9.9999e-01, 3.2788e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1507e-14, 1.1026e-14, 1.0000e+00, 3.2485e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5237e-19, 8.0393e-20, 1.0000e+00, 2.6133e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8372e-21, 2.3472e-21, 1.8345e-13, 1.8175e-21],\n", + " [9.7056e-35, 1.1287e-34, 1.2099e-21, 9.6433e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1726e-06, 8.6902e-07, 9.9999e-01, 3.3065e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2287e-14, 1.1300e-14, 1.0000e+00, 3.3289e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6186e-19, 8.3417e-20, 1.0000e+00, 2.7117e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8368e-21, 2.3469e-21, 1.8049e-13, 1.8172e-21],\n", + " [9.7550e-35, 1.1345e-34, 1.1819e-21, 9.6924e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1991e-06, 8.7631e-07, 9.9999e-01, 3.3342e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3080e-14, 1.1578e-14, 1.0000e+00, 3.4107e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7165e-19, 8.6534e-20, 1.0000e+00, 2.8131e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8365e-21, 2.3466e-21, 1.7760e-13, 1.8167e-21],\n", + " [9.8044e-35, 1.1402e-34, 1.1546e-21, 9.7416e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2258e-06, 8.8364e-07, 9.9999e-01, 3.3621e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3890e-14, 1.1863e-14, 1.0000e+00, 3.4941e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8174e-19, 8.9748e-20, 1.0000e+00, 2.9177e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8361e-21, 2.3463e-21, 1.7478e-13, 1.8164e-21],\n", + " [9.8537e-35, 1.1459e-34, 1.1282e-21, 9.7907e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2523e-06, 8.9092e-07, 9.9999e-01, 3.3898e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4707e-14, 1.2150e-14, 1.0000e+00, 3.5784e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9207e-19, 9.3041e-20, 1.0000e+00, 3.0247e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8358e-21, 2.3460e-21, 1.7203e-13, 1.8160e-21],\n", + " [9.9029e-35, 1.1516e-34, 1.1027e-21, 9.8398e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2789e-06, 8.9821e-07, 9.9999e-01, 3.4175e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5538e-14, 1.2442e-14, 1.0000e+00, 3.6641e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0271e-19, 9.6428e-20, 1.0000e+00, 3.1350e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8354e-21, 2.3457e-21, 1.6934e-13, 1.8156e-21],\n", + " [9.9521e-35, 1.1573e-34, 1.0780e-21, 9.8887e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3060e-06, 9.0564e-07, 9.9999e-01, 3.4457e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6390e-14, 1.2742e-14, 1.0000e+00, 3.7519e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1370e-19, 9.9928e-20, 1.0000e+00, 3.2488e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8351e-21, 2.3455e-21, 1.6671e-13, 1.8152e-21],\n", + " [9.9996e-35, 1.1628e-34, 1.0539e-21, 9.9360e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3335e-06, 9.1319e-07, 9.9999e-01, 3.4744e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7264e-14, 1.3049e-14, 1.0000e+00, 3.8420e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2509e-19, 1.0356e-19, 1.0000e+00, 3.3668e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8348e-21, 2.3452e-21, 1.6413e-13, 1.8149e-21],\n", + " [1.0048e-34, 1.1683e-34, 1.0303e-21, 9.9837e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3612e-06, 9.2078e-07, 9.9999e-01, 3.5033e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8157e-14, 1.3362e-14, 1.0000e+00, 3.9340e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3687e-19, 1.0731e-19, 1.0000e+00, 3.4889e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8344e-21, 2.3450e-21, 1.6160e-13, 1.8146e-21],\n", + " [1.0096e-34, 1.1740e-34, 1.0074e-21, 1.0032e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.3891e-06, 9.2842e-07, 9.9999e-01, 3.5324e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9068e-14, 1.3682e-14, 1.0000e+00, 4.0279e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4902e-19, 1.1118e-19, 1.0000e+00, 3.6149e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8342e-21, 2.3449e-21, 1.5912e-13, 1.8144e-21],\n", + " [1.0145e-34, 1.1796e-34, 9.8508e-22, 1.0081e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4172e-06, 9.3614e-07, 9.9999e-01, 3.5618e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9997e-14, 1.4009e-14, 1.0000e+00, 4.1236e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6154e-19, 1.1516e-19, 1.0000e+00, 3.7445e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "154000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8340e-21, 2.3448e-21, 1.5669e-13, 1.8141e-21],\n", + " [1.0192e-34, 1.1851e-34, 9.6339e-22, 1.0128e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4454e-06, 9.4386e-07, 9.9999e-01, 3.5912e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0937e-14, 1.4339e-14, 1.0000e+00, 4.2206e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7435e-19, 1.1924e-19, 1.0000e+00, 3.8773e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8338e-21, 2.3447e-21, 1.5434e-13, 1.8139e-21],\n", + " [1.0239e-34, 1.1905e-34, 9.4239e-22, 1.0174e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4681e-06, 9.5006e-07, 9.9999e-01, 3.6148e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1757e-14, 1.4628e-14, 1.0000e+00, 4.3052e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8583e-19, 1.2290e-19, 1.0000e+00, 3.9963e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8336e-21, 2.3446e-21, 1.5228e-13, 1.8136e-21],\n", + " [1.0285e-34, 1.1959e-34, 9.2448e-22, 1.0220e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4903e-06, 9.5617e-07, 9.9999e-01, 3.6380e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2577e-14, 1.4916e-14, 1.0000e+00, 4.3896e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9743e-19, 1.2659e-19, 1.0000e+00, 4.1164e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8334e-21, 2.3445e-21, 1.5030e-13, 1.8135e-21],\n", + " [1.0331e-34, 1.2012e-34, 9.0731e-22, 1.0266e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5132e-06, 9.6243e-07, 9.9999e-01, 3.6619e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3416e-14, 1.5211e-14, 1.0000e+00, 4.4761e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0937e-19, 1.3039e-19, 1.0000e+00, 4.2402e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8333e-21, 2.3446e-21, 1.4835e-13, 1.8133e-21],\n", + " [1.0377e-34, 1.2065e-34, 8.9052e-22, 1.0312e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5364e-06, 9.6879e-07, 9.9999e-01, 3.6861e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4272e-14, 1.5512e-14, 1.0000e+00, 4.5643e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2166e-19, 1.3430e-19, 1.0000e+00, 4.3676e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8332e-21, 2.3446e-21, 1.4644e-13, 1.8132e-21],\n", + " [1.0422e-34, 1.2118e-34, 8.7410e-22, 1.0357e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5598e-06, 9.7519e-07, 9.9999e-01, 3.7105e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5143e-14, 1.5818e-14, 1.0000e+00, 4.6541e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3429e-19, 1.3832e-19, 1.0000e+00, 4.4984e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8331e-21, 2.3446e-21, 1.4455e-13, 1.8131e-21],\n", + " [1.0468e-34, 1.2170e-34, 8.5801e-22, 1.0402e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5834e-06, 9.8165e-07, 9.9999e-01, 3.7351e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6032e-14, 1.6130e-14, 1.0000e+00, 4.7457e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4730e-19, 1.4246e-19, 1.0000e+00, 4.6332e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "161000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3447e-21, 1.4269e-13, 1.8130e-21],\n", + " [1.0513e-34, 1.2223e-34, 8.4224e-22, 1.0448e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6073e-06, 9.8819e-07, 9.9999e-01, 3.7599e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6940e-14, 1.6449e-14, 1.0000e+00, 4.8392e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6071e-19, 1.4673e-19, 1.0000e+00, 4.7720e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3448e-21, 1.4087e-13, 1.8130e-21],\n", + " [1.0559e-34, 1.2276e-34, 8.2681e-22, 1.0494e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.6314e-06, 9.9479e-07, 9.9999e-01, 3.7851e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7860e-14, 1.6773e-14, 1.0000e+00, 4.9341e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7441e-19, 1.5109e-19, 1.0000e+00, 4.9142e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3450e-21, 1.3908e-13, 1.8130e-21],\n", + " [1.0605e-34, 1.2330e-34, 8.1179e-22, 1.0539e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6555e-06, 1.0014e-06, 9.9999e-01, 3.8102e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8787e-14, 1.7099e-14, 1.0000e+00, 5.0296e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8832e-19, 1.5552e-19, 1.0000e+00, 5.0583e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3451e-21, 1.3734e-13, 1.8129e-21],\n", + " [1.0650e-34, 1.2382e-34, 7.9728e-22, 1.0584e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6801e-06, 1.0081e-06, 9.9999e-01, 3.8358e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9732e-14, 1.7431e-14, 1.0000e+00, 5.1270e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0256e-19, 1.6006e-19, 1.0000e+00, 5.2058e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3452e-21, 1.3564e-13, 1.8129e-21],\n", + " [1.0693e-34, 1.2431e-34, 7.8297e-22, 1.0626e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7049e-06, 1.0149e-06, 9.9999e-01, 3.8617e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0695e-14, 1.7770e-14, 1.0000e+00, 5.2262e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1718e-19, 1.6471e-19, 1.0000e+00, 5.3575e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3454e-21, 1.3396e-13, 1.8129e-21],\n", + " [1.0734e-34, 1.2479e-34, 7.6894e-22, 1.0667e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7300e-06, 1.0218e-06, 9.9999e-01, 3.8880e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1675e-14, 1.8114e-14, 1.0000e+00, 5.3272e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3218e-19, 1.6949e-19, 1.0000e+00, 5.5128e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8329e-21, 2.3455e-21, 1.3231e-13, 1.8129e-21],\n", + " [1.0775e-34, 1.2526e-34, 7.5519e-22, 1.0708e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7553e-06, 1.0287e-06, 9.9999e-01, 3.9144e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2668e-14, 1.8463e-14, 1.0000e+00, 5.4296e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4752e-19, 1.7437e-19, 1.0000e+00, 5.6718e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3457e-21, 1.3069e-13, 1.8129e-21],\n", + " [1.0815e-34, 1.2573e-34, 7.4181e-22, 1.0748e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7809e-06, 1.0357e-06, 9.9999e-01, 3.9410e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3682e-14, 1.8820e-14, 1.0000e+00, 5.5342e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6328e-19, 1.7938e-19, 1.0000e+00, 5.8350e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8330e-21, 2.3459e-21, 1.2910e-13, 1.8129e-21],\n", + " [1.0856e-34, 1.2620e-34, 7.2865e-22, 1.0788e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8068e-06, 1.0428e-06, 9.9999e-01, 3.9680e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4716e-14, 1.9183e-14, 1.0000e+00, 5.6406e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7949e-19, 1.8454e-19, 1.0000e+00, 6.0030e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8331e-21, 2.3461e-21, 1.2754e-13, 1.8130e-21],\n", + " [1.0896e-34, 1.2667e-34, 7.1577e-22, 1.0829e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8331e-06, 1.0500e-06, 9.9999e-01, 3.9954e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5772e-14, 1.9554e-14, 1.0000e+00, 5.7494e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9616e-19, 1.8985e-19, 1.0000e+00, 6.1759e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8332e-21, 2.3464e-21, 1.2599e-13, 1.8130e-21],\n", + " [1.0936e-34, 1.2713e-34, 7.0313e-22, 1.0869e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8598e-06, 1.0573e-06, 9.9999e-01, 4.0232e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6849e-14, 1.9933e-14, 1.0000e+00, 5.8605e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1331e-19, 1.9531e-19, 1.0000e+00, 6.3535e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8333e-21, 2.3466e-21, 1.2447e-13, 1.8131e-21],\n", + " [1.0976e-34, 1.2760e-34, 6.9074e-22, 1.0908e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.8867e-06, 1.0647e-06, 9.9999e-01, 4.0513e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7943e-14, 2.0317e-14, 1.0000e+00, 5.9732e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3088e-19, 2.0089e-19, 1.0000e+00, 6.5355e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "173000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8333e-21, 2.3468e-21, 1.2298e-13, 1.8132e-21],\n", + " [1.1015e-34, 1.2805e-34, 6.7865e-22, 1.0948e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9138e-06, 1.0721e-06, 9.9999e-01, 4.0796e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9056e-14, 2.0708e-14, 1.0000e+00, 6.0879e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4887e-19, 2.0662e-19, 1.0000e+00, 6.7220e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8334e-21, 2.3470e-21, 1.2151e-13, 1.8132e-21],\n", + " [1.1054e-34, 1.2850e-34, 6.6678e-22, 1.0986e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9411e-06, 1.0795e-06, 9.9999e-01, 4.1080e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0186e-14, 2.1105e-14, 1.0000e+00, 6.2042e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6729e-19, 2.1248e-19, 1.0000e+00, 6.9130e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8335e-21, 2.3472e-21, 1.2006e-13, 1.8133e-21],\n", + " [1.1093e-34, 1.2896e-34, 6.5519e-22, 1.1025e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9640e-06, 1.0858e-06, 9.9999e-01, 4.1318e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1188e-14, 2.1458e-14, 1.0000e+00, 6.3075e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8403e-19, 2.1780e-19, 1.0000e+00, 7.0863e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "176000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8335e-21, 2.3474e-21, 1.1878e-13, 1.8133e-21],\n", + " [1.1133e-34, 1.2942e-34, 6.4515e-22, 1.1064e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9845e-06, 1.0914e-06, 9.9999e-01, 4.1533e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2127e-14, 2.1788e-14, 1.0000e+00, 6.4043e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9996e-19, 2.2287e-19, 1.0000e+00, 7.2514e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "177000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8336e-21, 2.3476e-21, 1.1760e-13, 1.8133e-21],\n", + " [1.1172e-34, 1.2987e-34, 6.3597e-22, 1.1104e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0053e-06, 1.0971e-06, 9.9999e-01, 4.1749e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3079e-14, 2.2122e-14, 1.0000e+00, 6.5023e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1620e-19, 2.2804e-19, 1.0000e+00, 7.4197e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "178000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8337e-21, 2.3478e-21, 1.1643e-13, 1.8134e-21],\n", + " [1.1211e-34, 1.3033e-34, 6.2699e-22, 1.1143e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0262e-06, 1.1028e-06, 9.9999e-01, 4.1966e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4041e-14, 2.2460e-14, 1.0000e+00, 6.6014e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3273e-19, 2.3329e-19, 1.0000e+00, 7.5909e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "179000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8337e-21, 2.3480e-21, 1.1528e-13, 1.8134e-21],\n", + " [1.1250e-34, 1.3078e-34, 6.1820e-22, 1.1182e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0471e-06, 1.1085e-06, 9.9999e-01, 4.2184e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5015e-14, 2.2803e-14, 1.0000e+00, 6.7018e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4962e-19, 2.3866e-19, 1.0000e+00, 7.7659e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "180000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8338e-21, 2.3482e-21, 1.1415e-13, 1.8134e-21],\n", + " [1.1290e-34, 1.3123e-34, 6.0954e-22, 1.1221e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0681e-06, 1.1142e-06, 9.9999e-01, 4.2403e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6002e-14, 2.3150e-14, 1.0000e+00, 6.8034e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6683e-19, 2.4413e-19, 1.0000e+00, 7.9444e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "181000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8338e-21, 2.3483e-21, 1.1303e-13, 1.8135e-21],\n", + " [1.1329e-34, 1.3169e-34, 6.0102e-22, 1.1260e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0892e-06, 1.1200e-06, 9.9999e-01, 4.2623e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6997e-14, 2.3499e-14, 1.0000e+00, 6.9060e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8434e-19, 2.4970e-19, 1.0000e+00, 8.1257e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "182000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8338e-21, 2.3485e-21, 1.1193e-13, 1.8135e-21],\n", + " [1.1368e-34, 1.3214e-34, 5.9268e-22, 1.1299e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.1102e-06, 1.1257e-06, 9.9999e-01, 4.2842e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8004e-14, 2.3854e-14, 1.0000e+00, 7.0097e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.0218e-19, 2.5537e-19, 1.0000e+00, 8.3107e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "183000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8339e-21, 2.3486e-21, 1.1084e-13, 1.8136e-21],\n", + " [1.1407e-34, 1.3259e-34, 5.8449e-22, 1.1338e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1313e-06, 1.1315e-06, 9.9999e-01, 4.3062e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9023e-14, 2.4211e-14, 1.0000e+00, 7.1146e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2036e-19, 2.6115e-19, 1.0000e+00, 8.4991e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "184000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8340e-21, 2.3489e-21, 1.0977e-13, 1.8136e-21],\n", + " [1.1447e-34, 1.3305e-34, 5.7646e-22, 1.1377e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1525e-06, 1.1373e-06, 9.9999e-01, 4.3283e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0053e-14, 2.4574e-14, 1.0000e+00, 7.2209e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3890e-19, 2.6705e-19, 1.0000e+00, 8.6912e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "185000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8340e-21, 2.3490e-21, 1.0871e-13, 1.8137e-21],\n", + " [1.1486e-34, 1.3351e-34, 5.6856e-22, 1.1417e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1742e-06, 1.1432e-06, 9.9999e-01, 4.3509e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1104e-14, 2.4943e-14, 1.0000e+00, 7.3291e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5789e-19, 2.7309e-19, 1.0000e+00, 8.8879e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "186000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8341e-21, 2.3493e-21, 1.0767e-13, 1.8137e-21],\n", + " [1.1526e-34, 1.3396e-34, 5.6079e-22, 1.1456e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1960e-06, 1.1491e-06, 9.9999e-01, 4.3736e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2169e-14, 2.5318e-14, 1.0000e+00, 7.4388e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7723e-19, 2.7924e-19, 1.0000e+00, 9.0885e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "187000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8341e-21, 2.3494e-21, 1.0664e-13, 1.8137e-21],\n", + " [1.1564e-34, 1.3441e-34, 5.5313e-22, 1.1494e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2180e-06, 1.1551e-06, 9.9999e-01, 4.3965e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3247e-14, 2.5696e-14, 1.0000e+00, 7.5497e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9695e-19, 2.8550e-19, 1.0000e+00, 9.2926e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "188000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8341e-21, 2.3496e-21, 1.0562e-13, 1.8137e-21],\n", + " [1.1602e-34, 1.3485e-34, 5.4560e-22, 1.1532e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2403e-06, 1.1612e-06, 9.9999e-01, 4.4197e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4340e-14, 2.6081e-14, 1.0000e+00, 7.6625e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1706e-19, 2.9190e-19, 1.0000e+00, 9.5011e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "189000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8342e-21, 2.3497e-21, 1.0462e-13, 1.8138e-21],\n", + " [1.1640e-34, 1.3529e-34, 5.3821e-22, 1.1570e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2627e-06, 1.1674e-06, 9.9999e-01, 4.4431e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5447e-14, 2.6471e-14, 1.0000e+00, 7.7765e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3754e-19, 2.9842e-19, 1.0000e+00, 9.7133e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "190000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8342e-21, 2.3499e-21, 1.0363e-13, 1.8138e-21],\n", + " [1.1677e-34, 1.3571e-34, 5.3091e-22, 1.1606e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2854e-06, 1.1736e-06, 9.9999e-01, 4.4667e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6573e-14, 2.6867e-14, 1.0000e+00, 7.8926e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5847e-19, 3.0506e-19, 1.0000e+00, 9.9302e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "191000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8343e-21, 2.3501e-21, 1.0265e-13, 1.8139e-21],\n", + " [1.1713e-34, 1.3613e-34, 5.2370e-22, 1.1643e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3081e-06, 1.1798e-06, 9.9999e-01, 4.4904e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7711e-14, 2.7267e-14, 1.0000e+00, 8.0098e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7973e-19, 3.1183e-19, 1.0000e+00, 1.0151e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "192000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8343e-21, 2.3503e-21, 1.0169e-13, 1.8139e-21],\n", + " [1.1749e-34, 1.3655e-34, 5.1663e-22, 1.1678e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.3309e-06, 1.1860e-06, 9.9999e-01, 4.5141e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8857e-14, 2.7670e-14, 1.0000e+00, 8.1278e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0013e-18, 3.1869e-19, 1.0000e+00, 1.0374e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "193000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8344e-21, 2.3504e-21, 1.0075e-13, 1.8140e-21],\n", + " [1.1785e-34, 1.3696e-34, 5.0970e-22, 1.1714e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3538e-06, 1.1923e-06, 9.9999e-01, 4.5380e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.0017e-14, 2.8078e-14, 1.0000e+00, 8.2472e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0233e-18, 3.2568e-19, 1.0000e+00, 1.0602e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "194000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8344e-21, 2.3506e-21, 9.9815e-14, 1.8140e-21],\n", + " [1.1821e-34, 1.3737e-34, 5.0292e-22, 1.1750e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3774e-06, 1.1987e-06, 9.9999e-01, 4.5626e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1203e-14, 2.8495e-14, 1.0000e+00, 8.3695e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0459e-18, 3.3286e-19, 1.0000e+00, 1.0836e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "195000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8345e-21, 2.3507e-21, 9.8892e-14, 1.8140e-21],\n", + " [1.1856e-34, 1.3779e-34, 4.9623e-22, 1.1785e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4015e-06, 1.2053e-06, 9.9999e-01, 4.5877e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2413e-14, 2.8921e-14, 1.0000e+00, 8.4942e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0690e-18, 3.4023e-19, 1.0000e+00, 1.1076e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "196000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8345e-21, 2.3509e-21, 9.7980e-14, 1.8140e-21],\n", + " [1.1892e-34, 1.3821e-34, 4.8963e-22, 1.1821e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4258e-06, 1.2120e-06, 9.9999e-01, 4.6132e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3640e-14, 2.9353e-14, 1.0000e+00, 8.6207e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0927e-18, 3.4774e-19, 1.0000e+00, 1.1321e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "197000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8346e-21, 2.3511e-21, 9.7078e-14, 1.8141e-21],\n", + " [1.1927e-34, 1.3862e-34, 4.8314e-22, 1.1856e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4504e-06, 1.2188e-06, 9.9999e-01, 4.6388e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4887e-14, 2.9792e-14, 1.0000e+00, 8.7491e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1167e-18, 3.5542e-19, 1.0000e+00, 1.1571e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "198000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8346e-21, 2.3512e-21, 9.6188e-14, 1.8141e-21],\n", + " [1.1962e-34, 1.3902e-34, 4.7674e-22, 1.1891e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4752e-06, 1.2256e-06, 9.9999e-01, 4.6647e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6146e-14, 3.0236e-14, 1.0000e+00, 8.8790e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1412e-18, 3.6320e-19, 1.0000e+00, 1.1824e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "199000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8347e-21, 2.3513e-21, 9.5311e-14, 1.8142e-21],\n", + " [1.1997e-34, 1.3941e-34, 4.7044e-22, 1.1925e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5000e-06, 1.2324e-06, 9.9999e-01, 4.6906e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7418e-14, 3.0685e-14, 1.0000e+00, 9.0100e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1662e-18, 3.7113e-19, 1.0000e+00, 1.2083e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "200000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8347e-21, 2.3515e-21, 9.4448e-14, 1.8142e-21],\n", + " [1.2031e-34, 1.3981e-34, 4.6427e-22, 1.1959e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5251e-06, 1.2393e-06, 9.9999e-01, 4.7168e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8711e-14, 3.1140e-14, 1.0000e+00, 9.1433e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1916e-18, 3.7924e-19, 1.0000e+00, 1.2347e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "201000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8348e-21, 2.3516e-21, 9.3592e-14, 1.8142e-21],\n", + " [1.2065e-34, 1.4021e-34, 4.5818e-22, 1.1993e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5509e-06, 1.2464e-06, 9.9999e-01, 4.7437e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0034e-14, 3.1606e-14, 1.0000e+00, 9.2796e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2178e-18, 3.8757e-19, 1.0000e+00, 1.2618e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "202000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8348e-21, 2.3518e-21, 9.2746e-14, 1.8143e-21],\n", + " [1.2100e-34, 1.4060e-34, 4.5218e-22, 1.2028e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.5769e-06, 1.2536e-06, 9.9999e-01, 4.7708e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1373e-14, 3.2079e-14, 1.0000e+00, 9.4176e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2444e-18, 3.9606e-19, 1.0000e+00, 1.2894e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "203000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8349e-21, 2.3519e-21, 9.1909e-14, 1.8143e-21],\n", + " [1.2134e-34, 1.4100e-34, 4.4628e-22, 1.2062e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6029e-06, 1.2607e-06, 9.9999e-01, 4.7979e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2726e-14, 3.2556e-14, 1.0000e+00, 9.5571e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2716e-18, 4.0470e-19, 1.0000e+00, 1.3175e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "204000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8349e-21, 2.3521e-21, 9.1085e-14, 1.8143e-21],\n", + " [1.2168e-34, 1.4140e-34, 4.4049e-22, 1.2096e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6288e-06, 1.2679e-06, 9.9999e-01, 4.8250e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4088e-14, 3.3036e-14, 1.0000e+00, 9.6974e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2990e-18, 4.1345e-19, 1.0000e+00, 1.3460e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "205000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8349e-21, 2.3523e-21, 9.0275e-14, 1.8144e-21],\n", + " [1.2203e-34, 1.4180e-34, 4.3483e-22, 1.2130e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6548e-06, 1.2750e-06, 9.9999e-01, 4.8521e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5461e-14, 3.3521e-14, 1.0000e+00, 9.8390e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3269e-18, 4.2234e-19, 1.0000e+00, 1.3750e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "206000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8350e-21, 2.3524e-21, 8.9478e-14, 1.8144e-21],\n", + " [1.2237e-34, 1.4219e-34, 4.2928e-22, 1.2165e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6809e-06, 1.2822e-06, 9.9999e-01, 4.8793e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6849e-14, 3.4010e-14, 1.0000e+00, 9.9822e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3553e-18, 4.3139e-19, 1.0000e+00, 1.4044e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "207000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8350e-21, 2.3526e-21, 8.8692e-14, 1.8144e-21],\n", + " [1.2272e-34, 1.4259e-34, 4.2382e-22, 1.2199e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7071e-06, 1.2894e-06, 9.9999e-01, 4.9066e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8254e-14, 3.4506e-14, 1.0000e+00, 1.0127e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3842e-18, 4.4058e-19, 1.0000e+00, 1.4344e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "208000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8351e-21, 2.3527e-21, 8.7915e-14, 1.8145e-21],\n", + " [1.2306e-34, 1.4299e-34, 4.1846e-22, 1.2233e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7335e-06, 1.2967e-06, 9.9999e-01, 4.9342e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9681e-14, 3.5009e-14, 1.0000e+00, 1.0274e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4138e-18, 4.4999e-19, 1.0000e+00, 1.4650e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "209000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8351e-21, 2.3528e-21, 8.7146e-14, 1.8145e-21],\n", + " [1.2341e-34, 1.4338e-34, 4.1317e-22, 1.2267e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7601e-06, 1.3040e-06, 9.9999e-01, 4.9620e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0113e-13, 3.5520e-14, 1.0000e+00, 1.0423e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4440e-18, 4.5960e-19, 1.0000e+00, 1.4963e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "210000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8352e-21, 2.3530e-21, 8.6383e-14, 1.8146e-21],\n", + " [1.2375e-34, 1.4378e-34, 4.0795e-22, 1.2302e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7869e-06, 1.3114e-06, 9.9999e-01, 4.9900e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0259e-13, 3.6038e-14, 1.0000e+00, 1.0574e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4747e-18, 4.6941e-19, 1.0000e+00, 1.5282e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "211000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8352e-21, 2.3531e-21, 8.5629e-14, 1.8146e-21],\n", + " [1.2409e-34, 1.4418e-34, 4.0280e-22, 1.2336e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8109e-06, 1.3180e-06, 9.9999e-01, 5.0150e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0396e-13, 3.6519e-14, 1.0000e+00, 1.0715e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5038e-18, 4.7866e-19, 1.0000e+00, 1.5583e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "212000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8353e-21, 2.3533e-21, 8.4932e-14, 1.8146e-21],\n", + " [1.2444e-34, 1.4458e-34, 3.9811e-22, 1.2370e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.8291e-06, 1.3230e-06, 9.9999e-01, 5.0341e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0508e-13, 3.6917e-14, 1.0000e+00, 1.0831e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5284e-18, 4.8651e-19, 1.0000e+00, 1.5839e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "213000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8353e-21, 2.3534e-21, 8.4342e-14, 1.8147e-21],\n", + " [1.2479e-34, 1.4498e-34, 3.9427e-22, 1.2405e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8475e-06, 1.3281e-06, 9.9999e-01, 5.0533e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0622e-13, 3.7320e-14, 1.0000e+00, 1.0949e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5535e-18, 4.9448e-19, 1.0000e+00, 1.6099e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "214000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8354e-21, 2.3536e-21, 8.3757e-14, 1.8147e-21],\n", + " [1.2513e-34, 1.4537e-34, 3.9045e-22, 1.2439e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8660e-06, 1.3332e-06, 9.9999e-01, 5.0726e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0738e-13, 3.7727e-14, 1.0000e+00, 1.1067e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5789e-18, 5.0259e-19, 1.0000e+00, 1.6363e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "215000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8354e-21, 2.3537e-21, 8.3177e-14, 1.8147e-21],\n", + " [1.2546e-34, 1.4576e-34, 3.8666e-22, 1.2472e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8848e-06, 1.3384e-06, 9.9999e-01, 5.0922e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0854e-13, 3.8139e-14, 1.0000e+00, 1.1187e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6047e-18, 5.1080e-19, 1.0000e+00, 1.6630e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "216000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8354e-21, 2.3538e-21, 8.2602e-14, 1.8147e-21],\n", + " [1.2579e-34, 1.4613e-34, 3.8291e-22, 1.2505e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9034e-06, 1.3435e-06, 9.9999e-01, 5.1116e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0970e-13, 3.8548e-14, 1.0000e+00, 1.1307e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6305e-18, 5.1900e-19, 1.0000e+00, 1.6897e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "217000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8355e-21, 2.3539e-21, 8.2043e-14, 1.8148e-21],\n", + " [1.2611e-34, 1.4650e-34, 3.7925e-22, 1.2537e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9224e-06, 1.3488e-06, 9.9999e-01, 5.1315e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1088e-13, 3.8964e-14, 1.0000e+00, 1.1428e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6566e-18, 5.2730e-19, 1.0000e+00, 1.7168e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "218000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8355e-21, 2.3541e-21, 8.1489e-14, 1.8148e-21],\n", + " [1.2640e-34, 1.4684e-34, 3.7559e-22, 1.2565e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9415e-06, 1.3540e-06, 9.9999e-01, 5.1515e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1207e-13, 3.9385e-14, 1.0000e+00, 1.1551e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6830e-18, 5.3574e-19, 1.0000e+00, 1.7442e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "219000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8356e-21, 2.3542e-21, 8.0939e-14, 1.8148e-21],\n", + " [1.2669e-34, 1.4717e-34, 3.7196e-22, 1.2594e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9608e-06, 1.3593e-06, 9.9999e-01, 5.1716e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1327e-13, 3.9809e-14, 1.0000e+00, 1.1675e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7098e-18, 5.4429e-19, 1.0000e+00, 1.7720e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "220000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8356e-21, 2.3544e-21, 8.0394e-14, 1.8148e-21],\n", + " [1.2697e-34, 1.4750e-34, 3.6838e-22, 1.2622e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9802e-06, 1.3647e-06, 9.9999e-01, 5.1918e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1448e-13, 4.0238e-14, 1.0000e+00, 1.1800e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7370e-18, 5.5293e-19, 1.0000e+00, 1.8002e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "221000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8357e-21, 2.3545e-21, 7.9855e-14, 1.8149e-21],\n", + " [1.2724e-34, 1.4781e-34, 3.6482e-22, 1.2649e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9997e-06, 1.3701e-06, 9.9999e-01, 5.2123e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1571e-13, 4.0671e-14, 1.0000e+00, 1.1926e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7646e-18, 5.6172e-19, 1.0000e+00, 1.8288e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "222000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8357e-21, 2.3546e-21, 7.9321e-14, 1.8150e-21],\n", + " [1.2751e-34, 1.4812e-34, 3.6128e-22, 1.2676e-34]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([5.0193e-06, 1.3755e-06, 9.9999e-01, 5.2327e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1694e-13, 4.1107e-14, 1.0000e+00, 1.2054e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7925e-18, 5.7060e-19, 1.0000e+00, 1.8578e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "223000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8358e-21, 2.3547e-21, 7.8791e-14, 1.8150e-21],\n", + " [1.2778e-34, 1.4843e-34, 3.5780e-22, 1.2703e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0389e-06, 1.3809e-06, 9.9999e-01, 5.2532e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1819e-13, 4.1548e-14, 1.0000e+00, 1.2182e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8208e-18, 5.7963e-19, 1.0000e+00, 1.8871e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "224000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8358e-21, 2.3549e-21, 7.8266e-14, 1.8150e-21],\n", + " [1.2805e-34, 1.4874e-34, 3.5436e-22, 1.2730e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0586e-06, 1.3863e-06, 9.9999e-01, 5.2738e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1945e-13, 4.1994e-14, 1.0000e+00, 1.2313e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8496e-18, 5.8879e-19, 1.0000e+00, 1.9170e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "225000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8359e-21, 2.3550e-21, 7.7745e-14, 1.8151e-21],\n", + " [1.2832e-34, 1.4906e-34, 3.5096e-22, 1.2757e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0785e-06, 1.3918e-06, 9.9999e-01, 5.2946e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2073e-13, 4.2445e-14, 1.0000e+00, 1.2444e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8788e-18, 5.9812e-19, 1.0000e+00, 1.9473e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "226000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8359e-21, 2.3552e-21, 7.7228e-14, 1.8151e-21],\n", + " [1.2859e-34, 1.4937e-34, 3.4758e-22, 1.2784e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0991e-06, 1.3975e-06, 9.9999e-01, 5.3161e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2204e-13, 4.2906e-14, 1.0000e+00, 1.2579e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9088e-18, 6.0765e-19, 1.0000e+00, 1.9784e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "227000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8360e-21, 2.3553e-21, 7.6713e-14, 1.8151e-21],\n", + " [1.2886e-34, 1.4968e-34, 3.4424e-22, 1.2811e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1198e-06, 1.4032e-06, 9.9999e-01, 5.3377e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2336e-13, 4.3372e-14, 1.0000e+00, 1.2715e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9392e-18, 6.1734e-19, 1.0000e+00, 2.0099e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "228000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8360e-21, 2.3554e-21, 7.6202e-14, 1.8152e-21],\n", + " [1.2913e-34, 1.4999e-34, 3.4093e-22, 1.2838e-34]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8288e-07, 2.2470e-07, 1.0000e+00, 8.2452e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2958e-15, 4.6824e-16, 1.0000e+00, 1.3519e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7769e-21, 1.2346e-21, 1.0000e+00, 3.9798e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "229000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9717e-22, 6.2591e-22, 3.0036e-13, 4.9249e-22],\n", + " [1.4775e-35, 1.6827e-35, 3.0626e-21, 1.4782e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7940e-07, 2.2372e-07, 1.0000e+00, 8.2087e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2984e-15, 4.6926e-16, 1.0000e+00, 1.3546e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8140e-21, 1.2468e-21, 1.0000e+00, 4.0191e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "230000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9662e-22, 6.2533e-22, 2.9812e-13, 4.9195e-22],\n", + " [1.4884e-35, 1.6952e-35, 3.0415e-21, 1.4892e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7784e-07, 2.2328e-07, 1.0000e+00, 8.1924e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3076e-15, 4.7269e-16, 1.0000e+00, 1.3642e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8786e-21, 1.2681e-21, 1.0000e+00, 4.0874e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "231000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9580e-22, 6.2439e-22, 2.9494e-13, 4.9114e-22],\n", + " [1.4987e-35, 1.7069e-35, 3.0056e-21, 1.4995e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7798e-07, 2.2334e-07, 1.0000e+00, 8.1941e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3229e-15, 4.7833e-16, 1.0000e+00, 1.3802e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9684e-21, 1.2975e-21, 1.0000e+00, 4.1823e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "232000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9493e-22, 6.2340e-22, 2.9107e-13, 4.9027e-22],\n", + " [1.5087e-35, 1.7184e-35, 2.9578e-21, 1.5096e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([7.8016e-07, 2.2398e-07, 1.0000e+00, 8.2171e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3457e-15, 4.8668e-16, 1.0000e+00, 1.4040e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0888e-21, 1.3370e-21, 1.0000e+00, 4.3094e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "233000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9414e-22, 6.2248e-22, 2.8648e-13, 4.8949e-22],\n", + " [1.5187e-35, 1.7297e-35, 2.8977e-21, 1.5197e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8427e-07, 2.2517e-07, 1.0000e+00, 8.2608e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3757e-15, 4.9766e-16, 1.0000e+00, 1.4355e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2409e-21, 1.3868e-21, 1.0000e+00, 4.4700e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "234000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9337e-22, 6.2162e-22, 2.8125e-13, 4.8874e-22],\n", + " [1.5285e-35, 1.7410e-35, 2.8267e-21, 1.5296e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9001e-07, 2.2683e-07, 1.0000e+00, 8.3214e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4122e-15, 5.1096e-16, 1.0000e+00, 1.4736e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4222e-21, 1.4462e-21, 1.0000e+00, 4.6614e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "235000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9260e-22, 6.2074e-22, 2.7557e-13, 4.8799e-22],\n", + " [1.5385e-35, 1.7523e-35, 2.7484e-21, 1.5395e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9717e-07, 2.2890e-07, 1.0000e+00, 8.3970e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4546e-15, 5.2639e-16, 1.0000e+00, 1.5179e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6313e-21, 1.5147e-21, 1.0000e+00, 4.8820e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "236000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9189e-22, 6.1993e-22, 2.6958e-13, 4.8730e-22],\n", + " [1.5482e-35, 1.7634e-35, 2.6650e-21, 1.5494e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.0537e-07, 2.3127e-07, 1.0000e+00, 8.4836e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5018e-15, 5.4357e-16, 1.0000e+00, 1.5672e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8649e-21, 1.5911e-21, 1.0000e+00, 5.1285e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "237000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9129e-22, 6.1926e-22, 2.6347e-13, 4.8671e-22],\n", + " [1.5581e-35, 1.7746e-35, 2.5794e-21, 1.5593e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1452e-07, 2.3390e-07, 1.0000e+00, 8.5801e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5536e-15, 5.6241e-16, 1.0000e+00, 1.6213e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1216e-21, 1.6752e-21, 1.0000e+00, 5.3995e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "238000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9084e-22, 6.1877e-22, 2.5734e-13, 4.8629e-22],\n", + " [1.5676e-35, 1.7855e-35, 2.4931e-21, 1.5689e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2401e-07, 2.3663e-07, 1.0000e+00, 8.6803e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6074e-15, 5.8200e-16, 1.0000e+00, 1.6776e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3910e-21, 1.7633e-21, 1.0000e+00, 5.6837e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "239000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9044e-22, 6.1835e-22, 2.5141e-13, 4.8591e-22],\n", + " [1.5763e-35, 1.7955e-35, 2.4094e-21, 1.5776e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3357e-07, 2.3938e-07, 1.0000e+00, 8.7811e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6627e-15, 6.0211e-16, 1.0000e+00, 1.7354e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6720e-21, 1.8553e-21, 1.0000e+00, 5.9802e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "240000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9007e-22, 6.1796e-22, 2.4568e-13, 4.8555e-22],\n", + " [1.5851e-35, 1.8055e-35, 2.3295e-21, 1.5865e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4333e-07, 2.4219e-07, 1.0000e+00, 8.8841e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7200e-15, 6.2295e-16, 1.0000e+00, 1.7953e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9679e-21, 1.9521e-21, 1.0000e+00, 6.2926e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "241000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8989e-22, 6.1780e-22, 2.4019e-13, 4.8538e-22],\n", + " [1.5949e-35, 1.8166e-35, 2.2537e-21, 1.5963e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5341e-07, 2.4509e-07, 1.0000e+00, 8.9906e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7796e-15, 6.4460e-16, 1.0000e+00, 1.8575e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2789e-21, 2.0539e-21, 1.0000e+00, 6.6208e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "242000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8982e-22, 6.1778e-22, 2.3490e-13, 4.8532e-22],\n", + " [1.6049e-35, 1.8280e-35, 2.1814e-21, 1.6064e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([8.6370e-07, 2.4805e-07, 1.0000e+00, 9.0991e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8410e-15, 6.6693e-16, 1.0000e+00, 1.9218e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6043e-21, 2.1604e-21, 1.0000e+00, 6.9642e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "243000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8978e-22, 6.1779e-22, 2.2977e-13, 4.8529e-22],\n", + " [1.6148e-35, 1.8393e-35, 2.1118e-21, 1.6163e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7411e-07, 2.5105e-07, 1.0000e+00, 9.2090e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9043e-15, 6.8995e-16, 1.0000e+00, 1.9879e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9443e-21, 2.2717e-21, 1.0000e+00, 7.3231e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "244000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8975e-22, 6.1781e-22, 2.2480e-13, 4.8527e-22],\n", + " [1.6245e-35, 1.8504e-35, 2.0449e-21, 1.6260e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8454e-07, 2.5404e-07, 1.0000e+00, 9.3191e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9686e-15, 7.1332e-16, 1.0000e+00, 2.0551e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2937e-21, 2.3860e-21, 1.0000e+00, 7.6917e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "245000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8972e-22, 6.1785e-22, 2.2004e-13, 4.8526e-22],\n", + " [1.6334e-35, 1.8605e-35, 1.9809e-21, 1.6350e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9372e-07, 2.5668e-07, 1.0000e+00, 9.4160e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0284e-15, 7.3508e-16, 1.0000e+00, 2.1177e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6272e-21, 2.4951e-21, 1.0000e+00, 8.0435e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "246000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8971e-22, 6.1789e-22, 2.1576e-13, 4.8524e-22],\n", + " [1.6424e-35, 1.8707e-35, 1.9244e-21, 1.6440e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0304e-07, 2.5936e-07, 1.0000e+00, 9.5143e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0900e-15, 7.5746e-16, 1.0000e+00, 2.1820e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9744e-21, 2.6087e-21, 1.0000e+00, 8.4101e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "247000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8968e-22, 6.1791e-22, 2.1158e-13, 4.8523e-22],\n", + " [1.6512e-35, 1.8808e-35, 1.8698e-21, 1.6528e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1245e-07, 2.6206e-07, 1.0000e+00, 9.6135e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1529e-15, 7.8033e-16, 1.0000e+00, 2.2477e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3340e-21, 2.7264e-21, 1.0000e+00, 8.7897e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "248000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8965e-22, 6.1793e-22, 2.0753e-13, 4.8520e-22],\n", + " [1.6598e-35, 1.8907e-35, 1.8173e-21, 1.6615e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2192e-07, 2.6478e-07, 1.0000e+00, 9.7135e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2172e-15, 8.0368e-16, 1.0000e+00, 2.3149e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7064e-21, 2.8483e-21, 1.0000e+00, 9.1828e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "249000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8962e-22, 6.1795e-22, 2.0359e-13, 4.8519e-22],\n", + " [1.6685e-35, 1.9005e-35, 1.7668e-21, 1.6702e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3171e-07, 2.6759e-07, 1.0000e+00, 9.8168e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2836e-15, 8.2783e-16, 1.0000e+00, 2.3843e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0941e-21, 2.9751e-21, 1.0000e+00, 9.5920e-21],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "250000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8959e-22, 6.1797e-22, 1.9975e-13, 4.8516e-22],\n", + " [1.6764e-35, 1.9095e-35, 1.7175e-21, 1.6782e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4170e-07, 2.7046e-07, 1.0000e+00, 9.9222e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3519e-15, 8.5267e-16, 1.0000e+00, 2.4557e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4972e-21, 3.1070e-21, 1.0000e+00, 1.0017e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "251000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8956e-22, 6.1798e-22, 1.9602e-13, 4.8514e-22],\n", + " [1.6841e-35, 1.9183e-35, 1.6699e-21, 1.6859e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5188e-07, 2.7338e-07, 1.0000e+00, 1.0030e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4223e-15, 8.7826e-16, 1.0000e+00, 2.5293e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9173e-21, 3.2445e-21, 1.0000e+00, 1.0461e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "252000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8953e-22, 6.1800e-22, 1.9237e-13, 4.8511e-22],\n", + " [1.6916e-35, 1.9270e-35, 1.6237e-21, 1.6935e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([9.6219e-07, 2.7634e-07, 1.0000e+00, 1.0138e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4944e-15, 9.0448e-16, 1.0000e+00, 2.6047e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0353e-20, 3.3870e-21, 1.0000e+00, 1.0921e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "253000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8950e-22, 6.1801e-22, 1.8882e-13, 4.8509e-22],\n", + " [1.6990e-35, 1.9354e-35, 1.5790e-21, 1.7009e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7214e-07, 2.7920e-07, 1.0000e+00, 1.0243e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5660e-15, 9.3052e-16, 1.0000e+00, 2.6795e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0792e-20, 3.5308e-21, 1.0000e+00, 1.1385e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "254000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8947e-22, 6.1803e-22, 1.8544e-13, 4.8507e-22],\n", + " [1.7064e-35, 1.9438e-35, 1.5371e-21, 1.7083e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8080e-07, 2.8168e-07, 1.0000e+00, 1.0335e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6318e-15, 9.5443e-16, 1.0000e+00, 2.7483e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1205e-20, 3.6657e-21, 1.0000e+00, 1.1820e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "255000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8943e-22, 6.1803e-22, 1.8240e-13, 4.8505e-22],\n", + " [1.7136e-35, 1.9520e-35, 1.4999e-21, 1.7155e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8964e-07, 2.8422e-07, 1.0000e+00, 1.0428e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6994e-15, 9.7900e-16, 1.0000e+00, 2.8189e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1631e-20, 3.8053e-21, 1.0000e+00, 1.2270e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "256000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8941e-22, 6.1804e-22, 1.7942e-13, 4.8501e-22],\n", + " [1.7202e-35, 1.9595e-35, 1.4636e-21, 1.7221e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9850e-07, 2.8676e-07, 1.0000e+00, 1.0522e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7680e-15, 1.0040e-15, 1.0000e+00, 2.8907e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2070e-20, 3.9489e-21, 1.0000e+00, 1.2734e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "257000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8936e-22, 6.1804e-22, 1.7653e-13, 4.8499e-22],\n", + " [1.7267e-35, 1.9670e-35, 1.4284e-21, 1.7287e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0074e-06, 2.8931e-07, 1.0000e+00, 1.0616e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8381e-15, 1.0294e-15, 1.0000e+00, 2.9639e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2523e-20, 4.0970e-21, 1.0000e+00, 1.3212e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "258000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8932e-22, 6.1803e-22, 1.7369e-13, 4.8495e-22],\n", + " [1.7332e-35, 1.9745e-35, 1.3943e-21, 1.7353e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0163e-06, 2.9185e-07, 1.0000e+00, 1.0709e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9093e-15, 1.0553e-15, 1.0000e+00, 3.0383e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2989e-20, 4.2493e-21, 1.0000e+00, 1.3703e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "259000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8930e-22, 6.1803e-22, 1.7092e-13, 4.8492e-22],\n", + " [1.7398e-35, 1.9820e-35, 1.3613e-21, 1.7419e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0253e-06, 2.9444e-07, 1.0000e+00, 1.0805e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9819e-15, 1.0817e-15, 1.0000e+00, 3.1142e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3467e-20, 4.4059e-21, 1.0000e+00, 1.4208e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "260000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8925e-22, 6.1802e-22, 1.6822e-13, 4.8488e-22],\n", + " [1.7459e-35, 1.9889e-35, 1.3292e-21, 1.7480e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0346e-06, 2.9711e-07, 1.0000e+00, 1.0902e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0565e-15, 1.1088e-15, 1.0000e+00, 3.1922e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3960e-20, 4.5672e-21, 1.0000e+00, 1.4729e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "261000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8921e-22, 6.1802e-22, 1.6560e-13, 4.8485e-22],\n", + " [1.7513e-35, 1.9951e-35, 1.2978e-21, 1.7534e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0440e-06, 2.9982e-07, 1.0000e+00, 1.1002e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1330e-15, 1.1367e-15, 1.0000e+00, 3.2722e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4471e-20, 4.7343e-21, 1.0000e+00, 1.5269e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "262000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8920e-22, 6.1804e-22, 1.6302e-13, 4.8484e-22],\n", + " [1.7566e-35, 2.0011e-35, 1.2673e-21, 1.7587e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.0537e-06, 3.0260e-07, 1.0000e+00, 1.1105e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2120e-15, 1.1654e-15, 1.0000e+00, 3.3547e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5001e-20, 4.9076e-21, 1.0000e+00, 1.5828e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "263000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8917e-22, 6.1805e-22, 1.6048e-13, 4.8482e-22],\n", + " [1.7613e-35, 2.0066e-35, 1.2372e-21, 1.7634e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0636e-06, 3.0542e-07, 1.0000e+00, 1.1208e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2929e-15, 1.1948e-15, 1.0000e+00, 3.4393e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5548e-20, 5.0867e-21, 1.0000e+00, 1.6406e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "264000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8917e-22, 6.1808e-22, 1.5800e-13, 4.8482e-22],\n", + " [1.7659e-35, 2.0118e-35, 1.2079e-21, 1.7680e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0735e-06, 3.0826e-07, 1.0000e+00, 1.1313e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3755e-15, 1.2248e-15, 1.0000e+00, 3.5257e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6113e-20, 5.2712e-21, 1.0000e+00, 1.7001e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "265000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8916e-22, 6.1812e-22, 1.5557e-13, 4.8482e-22],\n", + " [1.7703e-35, 2.0168e-35, 1.1794e-21, 1.7725e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0834e-06, 3.1111e-07, 1.0000e+00, 1.1418e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4594e-15, 1.2553e-15, 1.0000e+00, 3.6133e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6691e-20, 5.4603e-21, 1.0000e+00, 1.7612e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "266000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8916e-22, 6.1813e-22, 1.5320e-13, 4.8481e-22],\n", + " [1.7745e-35, 2.0217e-35, 1.1519e-21, 1.7767e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0925e-06, 3.1370e-07, 1.0000e+00, 1.1514e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5387e-15, 1.2841e-15, 1.0000e+00, 3.6962e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7247e-20, 5.6419e-21, 1.0000e+00, 1.8198e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "267000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8915e-22, 6.1817e-22, 1.5102e-13, 4.8482e-22],\n", + " [1.7789e-35, 2.0267e-35, 1.1269e-21, 1.7811e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1007e-06, 3.1603e-07, 1.0000e+00, 1.1599e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6126e-15, 1.3109e-15, 1.0000e+00, 3.7734e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7773e-20, 5.8141e-21, 1.0000e+00, 1.8754e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "268000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8918e-22, 6.1825e-22, 1.4904e-13, 4.8484e-22],\n", + " [1.7833e-35, 2.0318e-35, 1.1044e-21, 1.7856e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1089e-06, 3.1838e-07, 1.0000e+00, 1.1686e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6879e-15, 1.3383e-15, 1.0000e+00, 3.8521e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8314e-20, 5.9912e-21, 1.0000e+00, 1.9326e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "269000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8920e-22, 6.1831e-22, 1.4709e-13, 4.8488e-22],\n", + " [1.7879e-35, 2.0370e-35, 1.0825e-21, 1.7902e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1171e-06, 3.2073e-07, 1.0000e+00, 1.1773e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7644e-15, 1.3661e-15, 1.0000e+00, 3.9321e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8869e-20, 6.1725e-21, 1.0000e+00, 1.9911e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "270000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8924e-22, 6.1840e-22, 1.4518e-13, 4.8491e-22],\n", + " [1.7924e-35, 2.0422e-35, 1.0612e-21, 1.7947e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1254e-06, 3.2311e-07, 1.0000e+00, 1.1860e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8424e-15, 1.3945e-15, 1.0000e+00, 4.0136e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9440e-20, 6.3591e-21, 1.0000e+00, 2.0514e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "271000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8926e-22, 6.1846e-22, 1.4330e-13, 4.8494e-22],\n", + " [1.7969e-35, 2.0474e-35, 1.0403e-21, 1.7993e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1339e-06, 3.2552e-07, 1.0000e+00, 1.1949e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9221e-15, 1.4234e-15, 1.0000e+00, 4.0969e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0027e-20, 6.5512e-21, 1.0000e+00, 2.1134e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "272000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8931e-22, 6.1855e-22, 1.4145e-13, 4.8499e-22],\n", + " [1.8014e-35, 2.0526e-35, 1.0199e-21, 1.8039e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.1425e-06, 3.2798e-07, 1.0000e+00, 1.2040e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0038e-15, 1.4531e-15, 1.0000e+00, 4.1823e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0633e-20, 6.7494e-21, 1.0000e+00, 2.1774e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "273000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8935e-22, 6.1864e-22, 1.3963e-13, 4.8504e-22],\n", + " [1.8059e-35, 2.0577e-35, 9.9993e-22, 1.8083e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1512e-06, 3.3050e-07, 1.0000e+00, 1.2133e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0873e-15, 1.4835e-15, 1.0000e+00, 4.2696e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1256e-20, 6.9530e-21, 1.0000e+00, 2.2431e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "274000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8939e-22, 6.1874e-22, 1.3784e-13, 4.8509e-22],\n", + " [1.8099e-35, 2.0623e-35, 9.8029e-22, 1.8124e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1600e-06, 3.3301e-07, 1.0000e+00, 1.2226e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1720e-15, 1.5143e-15, 1.0000e+00, 4.3582e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1893e-20, 7.1612e-21, 1.0000e+00, 2.3104e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "275000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8945e-22, 6.1883e-22, 1.3609e-13, 4.8514e-22],\n", + " [1.8139e-35, 2.0669e-35, 9.6118e-22, 1.8164e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1687e-06, 3.3550e-07, 1.0000e+00, 1.2317e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2567e-15, 1.5451e-15, 1.0000e+00, 4.4467e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2535e-20, 7.3712e-21, 1.0000e+00, 2.3782e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "276000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8949e-22, 6.1893e-22, 1.3440e-13, 4.8519e-22],\n", + " [1.8179e-35, 2.0714e-35, 9.4282e-22, 1.8204e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1777e-06, 3.3806e-07, 1.0000e+00, 1.2412e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3437e-15, 1.5766e-15, 1.0000e+00, 4.5376e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3196e-20, 7.5875e-21, 1.0000e+00, 2.4480e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "277000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8954e-22, 6.1903e-22, 1.3273e-13, 4.8524e-22],\n", + " [1.8213e-35, 2.0754e-35, 9.2470e-22, 1.8238e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1868e-06, 3.4067e-07, 1.0000e+00, 1.2508e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4328e-15, 1.6090e-15, 1.0000e+00, 4.6307e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3876e-20, 7.8097e-21, 1.0000e+00, 2.5197e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "278000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8959e-22, 6.1910e-22, 1.3108e-13, 4.8529e-22],\n", + " [1.8243e-35, 2.0789e-35, 9.0686e-22, 1.8269e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1961e-06, 3.4331e-07, 1.0000e+00, 1.2606e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5236e-15, 1.6420e-15, 1.0000e+00, 4.7256e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4575e-20, 8.0382e-21, 1.0000e+00, 2.5936e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "279000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8961e-22, 6.1918e-22, 1.2946e-13, 4.8533e-22],\n", + " [1.8274e-35, 2.0824e-35, 8.8941e-22, 1.8299e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2054e-06, 3.4597e-07, 1.0000e+00, 1.2704e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6158e-15, 1.6754e-15, 1.0000e+00, 4.8220e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5290e-20, 8.2720e-21, 1.0000e+00, 2.6691e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "280000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8967e-22, 6.1927e-22, 1.2787e-13, 4.8537e-22],\n", + " [1.8304e-35, 2.0859e-35, 8.7240e-22, 1.8329e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2148e-06, 3.4867e-07, 1.0000e+00, 1.2803e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7101e-15, 1.7097e-15, 1.0000e+00, 4.9206e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6027e-20, 8.5128e-21, 1.0000e+00, 2.7468e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "281000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8971e-22, 6.1933e-22, 1.2630e-13, 4.8541e-22],\n", + " [1.8334e-35, 2.0894e-35, 8.5576e-22, 1.8359e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2244e-06, 3.5141e-07, 1.0000e+00, 1.2905e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8065e-15, 1.7447e-15, 1.0000e+00, 5.0214e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6785e-20, 8.7608e-21, 1.0000e+00, 2.8269e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "282000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8975e-22, 6.1942e-22, 1.2476e-13, 4.8546e-22],\n", + " [1.8364e-35, 2.0928e-35, 8.3945e-22, 1.8389e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.2341e-06, 3.5418e-07, 1.0000e+00, 1.3007e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9047e-15, 1.7803e-15, 1.0000e+00, 5.1239e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7564e-20, 9.0152e-21, 1.0000e+00, 2.9091e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "283000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8978e-22, 6.1949e-22, 1.2324e-13, 4.8549e-22],\n", + " [1.8393e-35, 2.0962e-35, 8.2352e-22, 1.8419e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2439e-06, 3.5697e-07, 1.0000e+00, 1.3110e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0046e-15, 1.8166e-15, 1.0000e+00, 5.2283e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8363e-20, 9.2762e-21, 1.0000e+00, 2.9934e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "284000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8982e-22, 6.1955e-22, 1.2175e-13, 4.8552e-22],\n", + " [1.8422e-35, 2.0995e-35, 8.0794e-22, 1.8448e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2537e-06, 3.5978e-07, 1.0000e+00, 1.3214e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1062e-15, 1.8535e-15, 1.0000e+00, 5.3344e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9181e-20, 9.5436e-21, 1.0000e+00, 3.0798e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "285000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8985e-22, 6.1961e-22, 1.2028e-13, 4.8557e-22],\n", + " [1.8451e-35, 2.1029e-35, 7.9275e-22, 1.8477e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2637e-06, 3.6263e-07, 1.0000e+00, 1.3319e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2096e-15, 1.8910e-15, 1.0000e+00, 5.4425e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0020e-20, 9.8179e-21, 1.0000e+00, 3.1684e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "286000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8988e-22, 6.1969e-22, 1.1883e-13, 4.8559e-22],\n", + " [1.8480e-35, 2.1062e-35, 7.7794e-22, 1.8506e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2729e-06, 3.6525e-07, 1.0000e+00, 1.3416e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3075e-15, 1.9266e-15, 1.0000e+00, 5.5449e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0824e-20, 1.0081e-20, 1.0000e+00, 3.2532e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "287000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8992e-22, 6.1976e-22, 1.1750e-13, 4.8563e-22],\n", + " [1.8509e-35, 2.1096e-35, 7.6436e-22, 1.8536e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2807e-06, 3.6746e-07, 1.0000e+00, 1.3497e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3944e-15, 1.9581e-15, 1.0000e+00, 5.6356e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1549e-20, 1.0317e-20, 1.0000e+00, 3.3297e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "288000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8995e-22, 6.1980e-22, 1.1632e-13, 4.8566e-22],\n", + " [1.8538e-35, 2.1129e-35, 7.5252e-22, 1.8564e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2885e-06, 3.6968e-07, 1.0000e+00, 1.3580e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4823e-15, 1.9900e-15, 1.0000e+00, 5.7275e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2287e-20, 1.0559e-20, 1.0000e+00, 3.4077e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "289000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8997e-22, 6.1987e-22, 1.1515e-13, 4.8568e-22],\n", + " [1.8566e-35, 2.1161e-35, 7.4090e-22, 1.8593e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2962e-06, 3.7190e-07, 1.0000e+00, 1.3662e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5711e-15, 2.0222e-15, 1.0000e+00, 5.8203e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3039e-20, 1.0804e-20, 1.0000e+00, 3.4870e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "290000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9000e-22, 6.1993e-22, 1.1401e-13, 4.8572e-22],\n", + " [1.8595e-35, 2.1194e-35, 7.2955e-22, 1.8621e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3041e-06, 3.7413e-07, 1.0000e+00, 1.3744e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6610e-15, 2.0548e-15, 1.0000e+00, 5.9143e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3805e-20, 1.1054e-20, 1.0000e+00, 3.5680e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "291000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9003e-22, 6.1999e-22, 1.1288e-13, 4.8575e-22],\n", + " [1.8623e-35, 2.1227e-35, 7.1840e-22, 1.8650e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3119e-06, 3.7636e-07, 1.0000e+00, 1.3827e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7522e-15, 2.0879e-15, 1.0000e+00, 6.0096e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4587e-20, 1.1310e-20, 1.0000e+00, 3.6505e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "292000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9007e-22, 6.2005e-22, 1.1177e-13, 4.8578e-22],\n", + " [1.8652e-35, 2.1260e-35, 7.0747e-22, 1.8678e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.3198e-06, 3.7860e-07, 1.0000e+00, 1.3910e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8446e-15, 2.1214e-15, 1.0000e+00, 6.1061e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5385e-20, 1.1570e-20, 1.0000e+00, 3.7347e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "293000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9009e-22, 6.2010e-22, 1.1067e-13, 4.8581e-22],\n", + " [1.8681e-35, 2.1292e-35, 6.9673e-22, 1.8707e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3277e-06, 3.8085e-07, 1.0000e+00, 1.3993e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9384e-15, 2.1554e-15, 1.0000e+00, 6.2041e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6200e-20, 1.1837e-20, 1.0000e+00, 3.8209e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "294000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9012e-22, 6.2016e-22, 1.0958e-13, 4.8584e-22],\n", + " [1.8709e-35, 2.1326e-35, 6.8617e-22, 1.8736e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3357e-06, 3.8315e-07, 1.0000e+00, 1.4078e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0337e-15, 2.1900e-15, 1.0000e+00, 6.3038e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7033e-20, 1.2108e-20, 1.0000e+00, 3.9088e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "295000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9015e-22, 6.2022e-22, 1.0851e-13, 4.8587e-22],\n", + " [1.8736e-35, 2.1358e-35, 6.7581e-22, 1.8764e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3439e-06, 3.8546e-07, 1.0000e+00, 1.4164e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1306e-15, 2.2252e-15, 1.0000e+00, 6.4051e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7884e-20, 1.2387e-20, 1.0000e+00, 3.9986e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "296000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9017e-22, 6.2028e-22, 1.0745e-13, 4.8590e-22],\n", + " [1.8764e-35, 2.1389e-35, 6.6562e-22, 1.8791e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3520e-06, 3.8779e-07, 1.0000e+00, 1.4250e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2288e-15, 2.2608e-15, 1.0000e+00, 6.5076e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8752e-20, 1.2670e-20, 1.0000e+00, 4.0902e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "297000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9020e-22, 6.2034e-22, 1.0640e-13, 4.8594e-22],\n", + " [1.8790e-35, 2.1419e-35, 6.5560e-22, 1.8818e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3603e-06, 3.9014e-07, 1.0000e+00, 1.4337e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3284e-15, 2.2969e-15, 1.0000e+00, 6.6117e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9637e-20, 1.2959e-20, 1.0000e+00, 4.1836e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "298000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9023e-22, 6.2040e-22, 1.0538e-13, 4.8596e-22],\n", + " [1.8818e-35, 2.1451e-35, 6.4579e-22, 1.8846e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3686e-06, 3.9250e-07, 1.0000e+00, 1.4424e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4290e-15, 2.3335e-15, 1.0000e+00, 6.7168e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0538e-20, 1.3253e-20, 1.0000e+00, 4.2787e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "299000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9026e-22, 6.2046e-22, 1.0436e-13, 4.8599e-22],\n", + " [1.8845e-35, 2.1482e-35, 6.3622e-22, 1.8873e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3769e-06, 3.9488e-07, 1.0000e+00, 1.4512e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5311e-15, 2.3705e-15, 1.0000e+00, 6.8236e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1456e-20, 1.3553e-20, 1.0000e+00, 4.3757e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "300000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9029e-22, 6.2051e-22, 1.0337e-13, 4.8603e-22],\n", + " [1.8871e-35, 2.1512e-35, 6.2680e-22, 1.8899e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3853e-06, 3.9727e-07, 1.0000e+00, 1.4600e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6344e-15, 2.4080e-15, 1.0000e+00, 6.9315e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2391e-20, 1.3858e-20, 1.0000e+00, 4.4745e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "301000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9031e-22, 6.2057e-22, 1.0238e-13, 4.8606e-22],\n", + " [1.8897e-35, 2.1542e-35, 6.1754e-22, 1.8925e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3937e-06, 3.9967e-07, 1.0000e+00, 1.4689e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7390e-15, 2.4460e-15, 1.0000e+00, 7.0410e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3345e-20, 1.4170e-20, 1.0000e+00, 4.5752e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "302000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9034e-22, 6.2063e-22, 1.0141e-13, 4.8607e-22],\n", + " [1.8923e-35, 2.1572e-35, 6.0845e-22, 1.8951e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4022e-06, 4.0208e-07, 1.0000e+00, 1.4778e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8451e-15, 2.4845e-15, 1.0000e+00, 7.1518e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4317e-20, 1.4487e-20, 1.0000e+00, 4.6778e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "303000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9037e-22, 6.2069e-22, 1.0045e-13, 4.8612e-22],\n", + " [1.8949e-35, 2.1602e-35, 5.9953e-22, 1.8977e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4108e-06, 4.0454e-07, 1.0000e+00, 1.4869e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9530e-15, 2.5237e-15, 1.0000e+00, 7.2647e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5310e-20, 1.4812e-20, 1.0000e+00, 4.7827e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "304000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9040e-22, 6.2074e-22, 9.9504e-14, 4.8614e-22],\n", + " [1.8974e-35, 2.1630e-35, 5.9077e-22, 1.9002e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4195e-06, 4.0702e-07, 1.0000e+00, 1.4961e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0620e-15, 2.5633e-15, 1.0000e+00, 7.3786e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6320e-20, 1.5141e-20, 1.0000e+00, 4.8893e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "305000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9043e-22, 6.2080e-22, 9.8576e-14, 4.8617e-22],\n", + " [1.8999e-35, 2.1659e-35, 5.8223e-22, 1.9027e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4284e-06, 4.0957e-07, 1.0000e+00, 1.5055e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1734e-15, 2.6037e-15, 1.0000e+00, 7.4951e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7354e-20, 1.5480e-20, 1.0000e+00, 4.9985e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "306000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9045e-22, 6.2084e-22, 9.7658e-14, 4.8620e-22],\n", + " [1.9023e-35, 2.1687e-35, 5.7382e-22, 1.9052e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4373e-06, 4.1213e-07, 1.0000e+00, 1.5150e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2868e-15, 2.6449e-15, 1.0000e+00, 7.6136e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8412e-20, 1.5826e-20, 1.0000e+00, 5.1103e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "307000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9048e-22, 6.2090e-22, 9.6750e-14, 4.8622e-22],\n", + " [1.9048e-35, 2.1715e-35, 5.6552e-22, 1.9077e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4464e-06, 4.1472e-07, 1.0000e+00, 1.5245e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4013e-15, 2.6865e-15, 1.0000e+00, 7.7333e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9490e-20, 1.6178e-20, 1.0000e+00, 5.2242e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "308000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9051e-22, 6.2096e-22, 9.5855e-14, 4.8626e-22],\n", + " [1.9073e-35, 2.1744e-35, 5.5740e-22, 1.9102e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4554e-06, 4.1730e-07, 1.0000e+00, 1.5340e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5174e-15, 2.7288e-15, 1.0000e+00, 7.8547e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0589e-20, 1.6537e-20, 1.0000e+00, 5.3402e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "309000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9053e-22, 6.2101e-22, 9.4970e-14, 4.8629e-22],\n", + " [1.9098e-35, 2.1772e-35, 5.4942e-22, 1.9127e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4645e-06, 4.1991e-07, 1.0000e+00, 1.5436e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6350e-15, 2.7715e-15, 1.0000e+00, 7.9777e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1706e-20, 1.6903e-20, 1.0000e+00, 5.4583e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "310000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9057e-22, 6.2106e-22, 9.4099e-14, 4.8632e-22],\n", + " [1.9121e-35, 2.1800e-35, 5.4157e-22, 1.9150e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4738e-06, 4.2258e-07, 1.0000e+00, 1.5534e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7545e-15, 2.8149e-15, 1.0000e+00, 8.1026e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2847e-20, 1.7276e-20, 1.0000e+00, 5.5788e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "311000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9059e-22, 6.2112e-22, 9.3241e-14, 4.8635e-22],\n", + " [1.9144e-35, 2.1826e-35, 5.3389e-22, 1.9173e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4833e-06, 4.2529e-07, 1.0000e+00, 1.5634e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8763e-15, 2.8592e-15, 1.0000e+00, 8.2300e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4014e-20, 1.7657e-20, 1.0000e+00, 5.7019e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "312000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9062e-22, 6.2117e-22, 9.2395e-14, 4.8637e-22],\n", + " [1.9166e-35, 2.1851e-35, 5.2633e-22, 1.9196e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4928e-06, 4.2802e-07, 1.0000e+00, 1.5734e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9999e-15, 2.9042e-15, 1.0000e+00, 8.3593e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5206e-20, 1.8047e-20, 1.0000e+00, 5.8279e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "313000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9065e-22, 6.2122e-22, 9.1555e-14, 4.8640e-22],\n", + " [1.9189e-35, 2.1878e-35, 5.1886e-22, 1.9218e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5024e-06, 4.3076e-07, 1.0000e+00, 1.5836e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1256e-15, 2.9499e-15, 1.0000e+00, 8.4906e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6426e-20, 1.8446e-20, 1.0000e+00, 5.9567e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "314000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9068e-22, 6.2128e-22, 9.0724e-14, 4.8643e-22],\n", + " [1.9211e-35, 2.1904e-35, 5.1151e-22, 1.9241e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5120e-06, 4.3354e-07, 1.0000e+00, 1.5938e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2533e-15, 2.9963e-15, 1.0000e+00, 8.6242e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7671e-20, 1.8853e-20, 1.0000e+00, 6.0882e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "315000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9071e-22, 6.2133e-22, 8.9900e-14, 4.8646e-22],\n", + " [1.9233e-35, 2.1929e-35, 5.0427e-22, 1.9263e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5218e-06, 4.3633e-07, 1.0000e+00, 1.6041e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3823e-15, 3.0433e-15, 1.0000e+00, 8.7592e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8938e-20, 1.9268e-20, 1.0000e+00, 6.2221e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "316000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9074e-22, 6.2137e-22, 8.9090e-14, 4.8648e-22],\n", + " [1.9255e-35, 2.1954e-35, 4.9717e-22, 1.9285e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5315e-06, 4.3913e-07, 1.0000e+00, 1.6143e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5124e-15, 3.0906e-15, 1.0000e+00, 8.8951e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0221e-20, 1.9687e-20, 1.0000e+00, 6.3577e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "317000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9075e-22, 6.2142e-22, 8.8296e-14, 4.8651e-22],\n", + " [1.9277e-35, 2.1979e-35, 4.9024e-22, 1.9307e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5413e-06, 4.4194e-07, 1.0000e+00, 1.6247e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6442e-15, 3.1385e-15, 1.0000e+00, 9.0329e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1528e-20, 2.0115e-20, 1.0000e+00, 6.4957e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "318000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9078e-22, 6.2147e-22, 8.7510e-14, 4.8654e-22],\n", + " [1.9299e-35, 2.2004e-35, 4.8344e-22, 1.9329e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5511e-06, 4.4475e-07, 1.0000e+00, 1.6350e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7772e-15, 3.1869e-15, 1.0000e+00, 9.1721e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2856e-20, 2.0549e-20, 1.0000e+00, 6.6359e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "319000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9080e-22, 6.2151e-22, 8.6736e-14, 4.8657e-22],\n", + " [1.9320e-35, 2.2028e-35, 4.7676e-22, 1.9350e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5610e-06, 4.4758e-07, 1.0000e+00, 1.6455e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9123e-15, 3.2361e-15, 1.0000e+00, 9.3134e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4213e-20, 2.0993e-20, 1.0000e+00, 6.7794e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "320000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9083e-22, 6.2158e-22, 8.5971e-14, 4.8659e-22],\n", + " [1.9340e-35, 2.2053e-35, 4.7018e-22, 1.9371e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5709e-06, 4.5043e-07, 1.0000e+00, 1.6560e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0493e-15, 3.2859e-15, 1.0000e+00, 9.4567e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5595e-20, 2.1445e-20, 1.0000e+00, 6.9253e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "321000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9086e-22, 6.2162e-22, 8.5213e-14, 4.8662e-22],\n", + " [1.9362e-35, 2.2077e-35, 4.6370e-22, 1.9392e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5809e-06, 4.5330e-07, 1.0000e+00, 1.6665e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1880e-15, 3.3363e-15, 1.0000e+00, 9.6019e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7004e-20, 2.1906e-20, 1.0000e+00, 7.0743e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "322000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9088e-22, 6.2167e-22, 8.4463e-14, 4.8665e-22],\n", + " [1.9382e-35, 2.2100e-35, 4.5731e-22, 1.9413e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.5897e-06, 4.5581e-07, 1.0000e+00, 1.6758e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3137e-15, 3.3821e-15, 1.0000e+00, 9.7333e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8291e-20, 2.2327e-20, 1.0000e+00, 7.2101e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "323000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9090e-22, 6.2169e-22, 8.3789e-14, 4.8666e-22],\n", + " [1.9400e-35, 2.2121e-35, 4.5160e-22, 1.9430e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5970e-06, 4.5789e-07, 1.0000e+00, 1.6835e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4226e-15, 3.4216e-15, 1.0000e+00, 9.8471e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9419e-20, 2.2696e-20, 1.0000e+00, 7.3295e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "324000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9092e-22, 6.2174e-22, 8.3204e-14, 4.8670e-22],\n", + " [1.9417e-35, 2.2141e-35, 4.4668e-22, 1.9448e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6043e-06, 4.5998e-07, 1.0000e+00, 1.6912e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5326e-15, 3.4617e-15, 1.0000e+00, 9.9623e-15],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0567e-20, 2.3072e-20, 1.0000e+00, 7.4507e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "325000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9094e-22, 6.2178e-22, 8.2622e-14, 4.8671e-22],\n", + " [1.9434e-35, 2.2161e-35, 4.4182e-22, 1.9465e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6116e-06, 4.6208e-07, 1.0000e+00, 1.6989e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6439e-15, 3.5022e-15, 1.0000e+00, 1.0079e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1732e-20, 2.3453e-20, 1.0000e+00, 7.5739e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "326000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9096e-22, 6.2183e-22, 8.2045e-14, 4.8674e-22],\n", + " [1.9452e-35, 2.2181e-35, 4.3702e-22, 1.9483e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6190e-06, 4.6419e-07, 1.0000e+00, 1.7067e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7565e-15, 3.5431e-15, 1.0000e+00, 1.0196e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2918e-20, 2.3841e-20, 1.0000e+00, 7.6990e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "327000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9099e-22, 6.2187e-22, 8.1473e-14, 4.8677e-22],\n", + " [1.9469e-35, 2.2201e-35, 4.3226e-22, 1.9500e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6262e-06, 4.6627e-07, 1.0000e+00, 1.7144e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8683e-15, 3.5838e-15, 1.0000e+00, 1.0313e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4098e-20, 2.4227e-20, 1.0000e+00, 7.8238e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "328000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9101e-22, 6.2191e-22, 8.0915e-14, 4.8678e-22],\n", + " [1.9486e-35, 2.2220e-35, 4.2765e-22, 1.9517e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6335e-06, 4.6836e-07, 1.0000e+00, 1.7220e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9809e-15, 3.6248e-15, 1.0000e+00, 1.0431e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5293e-20, 2.4619e-20, 1.0000e+00, 7.9501e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "329000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9103e-22, 6.2196e-22, 8.0364e-14, 4.8680e-22],\n", + " [1.9502e-35, 2.2239e-35, 4.2311e-22, 1.9534e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6408e-06, 4.7045e-07, 1.0000e+00, 1.7298e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0095e-14, 3.6662e-15, 1.0000e+00, 1.0550e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6506e-20, 2.5015e-20, 1.0000e+00, 8.0784e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "330000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9106e-22, 6.2200e-22, 7.9818e-14, 4.8683e-22],\n", + " [1.9519e-35, 2.2259e-35, 4.1862e-22, 1.9551e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6482e-06, 4.7256e-07, 1.0000e+00, 1.7375e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0209e-14, 3.7079e-15, 1.0000e+00, 1.0670e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7733e-20, 2.5416e-20, 1.0000e+00, 8.2080e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "331000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9107e-22, 6.2205e-22, 7.9277e-14, 4.8685e-22],\n", + " [1.9534e-35, 2.2276e-35, 4.1418e-22, 1.9566e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6555e-06, 4.7468e-07, 1.0000e+00, 1.7453e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0325e-14, 3.7501e-15, 1.0000e+00, 1.0792e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8975e-20, 2.5823e-20, 1.0000e+00, 8.3394e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "332000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9110e-22, 6.2208e-22, 7.8742e-14, 4.8688e-22],\n", + " [1.9548e-35, 2.2293e-35, 4.0979e-22, 1.9580e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.6630e-06, 4.7681e-07, 1.0000e+00, 1.7532e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0443e-14, 3.7928e-15, 1.0000e+00, 1.0914e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.0237e-20, 2.6236e-20, 1.0000e+00, 8.4727e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "333000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9112e-22, 6.2211e-22, 7.8210e-14, 4.8689e-22],\n", + " [1.9562e-35, 2.2309e-35, 4.0544e-22, 1.9594e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6706e-06, 4.7898e-07, 1.0000e+00, 1.7612e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0562e-14, 3.8361e-15, 1.0000e+00, 1.1039e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1524e-20, 2.6657e-20, 1.0000e+00, 8.6087e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "334000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9114e-22, 6.2216e-22, 7.7685e-14, 4.8692e-22],\n", + " [1.9577e-35, 2.2325e-35, 4.0116e-22, 1.9608e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6783e-06, 4.8119e-07, 1.0000e+00, 1.7694e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0683e-14, 3.8801e-15, 1.0000e+00, 1.1166e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2835e-20, 2.7085e-20, 1.0000e+00, 8.7472e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "335000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9116e-22, 6.2219e-22, 7.7162e-14, 4.8694e-22],\n", + " [1.9591e-35, 2.2342e-35, 3.9693e-22, 1.9623e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6861e-06, 4.8342e-07, 1.0000e+00, 1.7776e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0805e-14, 3.9246e-15, 1.0000e+00, 1.1294e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4167e-20, 2.7521e-20, 1.0000e+00, 8.8880e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "336000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9117e-22, 6.2223e-22, 7.6644e-14, 4.8695e-22],\n", + " [1.9605e-35, 2.2358e-35, 3.9273e-22, 1.9637e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6939e-06, 4.8566e-07, 1.0000e+00, 1.7858e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0929e-14, 3.9697e-15, 1.0000e+00, 1.1423e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5520e-20, 2.7963e-20, 1.0000e+00, 9.0309e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "337000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9120e-22, 6.2226e-22, 7.6128e-14, 4.8697e-22],\n", + " [1.9619e-35, 2.2375e-35, 3.8860e-22, 1.9651e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7018e-06, 4.8792e-07, 1.0000e+00, 1.7942e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1055e-14, 4.0154e-15, 1.0000e+00, 1.1555e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6897e-20, 2.8414e-20, 1.0000e+00, 9.1764e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "338000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9121e-22, 6.2230e-22, 7.5618e-14, 4.8699e-22],\n", + " [1.9633e-35, 2.2391e-35, 3.8450e-22, 1.9665e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7098e-06, 4.9019e-07, 1.0000e+00, 1.8026e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1182e-14, 4.0614e-15, 1.0000e+00, 1.1687e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8292e-20, 2.8870e-20, 1.0000e+00, 9.3239e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "339000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9123e-22, 6.2234e-22, 7.5113e-14, 4.8701e-22],\n", + " [1.9647e-35, 2.2407e-35, 3.8047e-22, 1.9680e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7178e-06, 4.9248e-07, 1.0000e+00, 1.8110e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1310e-14, 4.1080e-15, 1.0000e+00, 1.1821e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9707e-20, 2.9333e-20, 1.0000e+00, 9.4734e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "340000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9125e-22, 6.2237e-22, 7.4612e-14, 4.8703e-22],\n", + " [1.9661e-35, 2.2423e-35, 3.7648e-22, 1.9694e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7258e-06, 4.9479e-07, 1.0000e+00, 1.8195e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1440e-14, 4.1552e-15, 1.0000e+00, 1.1957e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1143e-20, 2.9802e-20, 1.0000e+00, 9.6251e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "341000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9127e-22, 6.2240e-22, 7.4115e-14, 4.8706e-22],\n", + " [1.9674e-35, 2.2438e-35, 3.7252e-22, 1.9706e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7339e-06, 4.9711e-07, 1.0000e+00, 1.8281e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1571e-14, 4.2028e-15, 1.0000e+00, 1.2094e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2601e-20, 3.0279e-20, 1.0000e+00, 9.7792e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "342000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9129e-22, 6.2243e-22, 7.3621e-14, 4.8706e-22],\n", + " [1.9686e-35, 2.2452e-35, 3.6861e-22, 1.9718e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.7420e-06, 4.9943e-07, 1.0000e+00, 1.8366e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1703e-14, 4.2509e-15, 1.0000e+00, 1.2233e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4080e-20, 3.0763e-20, 1.0000e+00, 9.9354e-20],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "343000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9130e-22, 6.2247e-22, 7.3132e-14, 4.8709e-22],\n", + " [1.9698e-35, 2.2466e-35, 3.6474e-22, 1.9731e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7501e-06, 5.0173e-07, 1.0000e+00, 1.8451e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1835e-14, 4.2989e-15, 1.0000e+00, 1.2371e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5561e-20, 3.1247e-20, 1.0000e+00, 1.0092e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "344000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9132e-22, 6.2250e-22, 7.2654e-14, 4.8710e-22],\n", + " [1.9711e-35, 2.2481e-35, 3.6098e-22, 1.9743e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7581e-06, 5.0403e-07, 1.0000e+00, 1.8536e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1968e-14, 4.3472e-15, 1.0000e+00, 1.2510e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7058e-20, 3.1737e-20, 1.0000e+00, 1.0250e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "345000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9133e-22, 6.2253e-22, 7.2181e-14, 4.8713e-22],\n", + " [1.9723e-35, 2.2495e-35, 3.5727e-22, 1.9756e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7661e-06, 5.0633e-07, 1.0000e+00, 1.8621e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2101e-14, 4.3956e-15, 1.0000e+00, 1.2649e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8566e-20, 3.2230e-20, 1.0000e+00, 1.0410e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "346000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9135e-22, 6.2257e-22, 7.1713e-14, 4.8714e-22],\n", + " [1.9735e-35, 2.2509e-35, 3.5362e-22, 1.9768e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7741e-06, 5.0860e-07, 1.0000e+00, 1.8705e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2235e-14, 4.4441e-15, 1.0000e+00, 1.2789e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0008e-19, 3.2726e-20, 1.0000e+00, 1.0570e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "347000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9138e-22, 6.2260e-22, 7.1254e-14, 4.8716e-22],\n", + " [1.9747e-35, 2.2523e-35, 3.5004e-22, 1.9780e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7821e-06, 5.1090e-07, 1.0000e+00, 1.8790e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2370e-14, 4.4933e-15, 1.0000e+00, 1.2930e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0163e-19, 3.3231e-20, 1.0000e+00, 1.0733e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "348000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9140e-22, 6.2264e-22, 7.0797e-14, 4.8718e-22],\n", + " [1.9760e-35, 2.2538e-35, 3.4650e-22, 1.9793e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7902e-06, 5.1322e-07, 1.0000e+00, 1.8875e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2506e-14, 4.5430e-15, 1.0000e+00, 1.3073e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0320e-19, 3.3744e-20, 1.0000e+00, 1.0899e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "349000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9141e-22, 6.2267e-22, 7.0343e-14, 4.8720e-22],\n", + " [1.9772e-35, 2.2552e-35, 3.4300e-22, 1.9805e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7983e-06, 5.1554e-07, 1.0000e+00, 1.8961e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2645e-14, 4.5931e-15, 1.0000e+00, 1.3217e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0479e-19, 3.4265e-20, 1.0000e+00, 1.1067e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "350000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9144e-22, 6.2270e-22, 6.9893e-14, 4.8723e-22],\n", + " [1.9784e-35, 2.2566e-35, 3.3954e-22, 1.9818e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8065e-06, 5.1787e-07, 1.0000e+00, 1.9047e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2784e-14, 4.6439e-15, 1.0000e+00, 1.3364e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0640e-19, 3.4792e-20, 1.0000e+00, 1.1238e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "351000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9144e-22, 6.2273e-22, 6.9446e-14, 4.8723e-22],\n", + " [1.9796e-35, 2.2581e-35, 3.3611e-22, 1.9830e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8147e-06, 5.2021e-07, 1.0000e+00, 1.9133e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2924e-14, 4.6949e-15, 1.0000e+00, 1.3510e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0803e-19, 3.5324e-20, 1.0000e+00, 1.1409e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "352000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9146e-22, 6.2276e-22, 6.9005e-14, 4.8726e-22],\n", + " [1.9808e-35, 2.2594e-35, 3.3274e-22, 1.9842e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.8228e-06, 5.2254e-07, 1.0000e+00, 1.9219e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3065e-14, 4.7460e-15, 1.0000e+00, 1.3657e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0967e-19, 3.5860e-20, 1.0000e+00, 1.1583e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "353000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9149e-22, 6.2280e-22, 6.8570e-14, 4.8728e-22],\n", + " [1.9820e-35, 2.2608e-35, 3.2943e-22, 1.9854e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8310e-06, 5.2488e-07, 1.0000e+00, 1.9305e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3208e-14, 4.7977e-15, 1.0000e+00, 1.3806e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1133e-19, 3.6404e-20, 1.0000e+00, 1.1759e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "354000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9151e-22, 6.2283e-22, 6.8139e-14, 4.8729e-22],\n", + " [1.9831e-35, 2.2620e-35, 3.2614e-22, 1.9865e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8393e-06, 5.2725e-07, 1.0000e+00, 1.9393e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3352e-14, 4.8502e-15, 1.0000e+00, 1.3957e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1302e-19, 3.6956e-20, 1.0000e+00, 1.1937e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "355000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9152e-22, 6.2286e-22, 6.7710e-14, 4.8731e-22],\n", + " [1.9841e-35, 2.2632e-35, 3.2289e-22, 1.9875e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8476e-06, 5.2963e-07, 1.0000e+00, 1.9481e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3498e-14, 4.9032e-15, 1.0000e+00, 1.4110e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1474e-19, 3.7517e-20, 1.0000e+00, 1.2118e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "356000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9153e-22, 6.2289e-22, 6.7284e-14, 4.8732e-22],\n", + " [1.9850e-35, 2.2643e-35, 3.1966e-22, 1.9885e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8560e-06, 5.3202e-07, 1.0000e+00, 1.9569e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3645e-14, 4.9567e-15, 1.0000e+00, 1.4264e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1648e-19, 3.8086e-20, 1.0000e+00, 1.2302e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "357000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9155e-22, 6.2292e-22, 6.6861e-14, 4.8734e-22],\n", + " [1.9861e-35, 2.2655e-35, 3.1647e-22, 1.9895e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8644e-06, 5.3442e-07, 1.0000e+00, 1.9658e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3794e-14, 5.0108e-15, 1.0000e+00, 1.4420e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1824e-19, 3.8663e-20, 1.0000e+00, 1.2489e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "358000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9157e-22, 6.2295e-22, 6.6440e-14, 4.8735e-22],\n", + " [1.9870e-35, 2.2667e-35, 3.1331e-22, 1.9905e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8728e-06, 5.3684e-07, 1.0000e+00, 1.9747e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3945e-14, 5.0655e-15, 1.0000e+00, 1.4577e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2003e-19, 3.9250e-20, 1.0000e+00, 1.2678e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "359000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9159e-22, 6.2298e-22, 6.6023e-14, 4.8737e-22],\n", + " [1.9880e-35, 2.2677e-35, 3.1018e-22, 1.9914e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8813e-06, 5.3926e-07, 1.0000e+00, 1.9837e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4096e-14, 5.1207e-15, 1.0000e+00, 1.4736e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2185e-19, 3.9843e-20, 1.0000e+00, 1.2870e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "360000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9160e-22, 6.2301e-22, 6.5609e-14, 4.8739e-22],\n", + " [1.9889e-35, 2.2689e-35, 3.0709e-22, 1.9924e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8898e-06, 5.4169e-07, 1.0000e+00, 1.9926e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4249e-14, 5.1762e-15, 1.0000e+00, 1.4896e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2368e-19, 4.0443e-20, 1.0000e+00, 1.3064e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "361000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9162e-22, 6.2303e-22, 6.5201e-14, 4.8741e-22],\n", + " [1.9899e-35, 2.2700e-35, 3.0404e-22, 1.9933e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8983e-06, 5.4412e-07, 1.0000e+00, 2.0016e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4404e-14, 5.2323e-15, 1.0000e+00, 1.5058e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2555e-19, 4.1051e-20, 1.0000e+00, 1.3261e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "362000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9164e-22, 6.2307e-22, 6.4795e-14, 4.8743e-22],\n", + " [1.9908e-35, 2.2711e-35, 3.0103e-22, 1.9943e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.9069e-06, 5.4656e-07, 1.0000e+00, 2.0106e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4560e-14, 5.2890e-15, 1.0000e+00, 1.5221e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2743e-19, 4.1667e-20, 1.0000e+00, 1.3460e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "363000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9165e-22, 6.2311e-22, 6.4392e-14, 4.8745e-22],\n", + " [1.9917e-35, 2.2722e-35, 2.9806e-22, 1.9952e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9154e-06, 5.4901e-07, 1.0000e+00, 2.0197e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4717e-14, 5.3460e-15, 1.0000e+00, 1.5385e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2934e-19, 4.2291e-20, 1.0000e+00, 1.3661e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "364000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9166e-22, 6.2312e-22, 6.3992e-14, 4.8746e-22],\n", + " [1.9927e-35, 2.2733e-35, 2.9512e-22, 1.9962e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9240e-06, 5.5146e-07, 1.0000e+00, 2.0287e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4875e-14, 5.4035e-15, 1.0000e+00, 1.5551e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3127e-19, 4.2923e-20, 1.0000e+00, 1.3865e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "365000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9169e-22, 6.2316e-22, 6.3597e-14, 4.8748e-22],\n", + " [1.9937e-35, 2.2744e-35, 2.9221e-22, 1.9972e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9326e-06, 5.5391e-07, 1.0000e+00, 2.0378e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5035e-14, 5.4614e-15, 1.0000e+00, 1.5717e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3322e-19, 4.3561e-20, 1.0000e+00, 1.4072e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "366000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9171e-22, 6.2318e-22, 6.3206e-14, 4.8750e-22],\n", + " [1.9946e-35, 2.2755e-35, 2.8935e-22, 1.9981e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9411e-06, 5.5633e-07, 1.0000e+00, 2.0468e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5193e-14, 5.5189e-15, 1.0000e+00, 1.5883e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3517e-19, 4.4197e-20, 1.0000e+00, 1.4278e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "367000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9172e-22, 6.2322e-22, 6.2823e-14, 4.8751e-22],\n", + " [1.9956e-35, 2.2766e-35, 2.8658e-22, 1.9991e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9496e-06, 5.5877e-07, 1.0000e+00, 2.0557e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5353e-14, 5.5770e-15, 1.0000e+00, 1.6050e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3714e-19, 4.4843e-20, 1.0000e+00, 1.4486e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "368000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9174e-22, 6.2325e-22, 6.2444e-14, 4.8753e-22],\n", + " [1.9965e-35, 2.2778e-35, 2.8382e-22, 2.0000e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9581e-06, 5.6121e-07, 1.0000e+00, 2.0648e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5515e-14, 5.6358e-15, 1.0000e+00, 1.6219e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3915e-19, 4.5498e-20, 1.0000e+00, 1.4698e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "369000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9175e-22, 6.2328e-22, 6.2066e-14, 4.8755e-22],\n", + " [1.9974e-35, 2.2788e-35, 2.8109e-22, 2.0010e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9667e-06, 5.6366e-07, 1.0000e+00, 2.0738e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5678e-14, 5.6950e-15, 1.0000e+00, 1.6390e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4117e-19, 4.6162e-20, 1.0000e+00, 1.4913e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "370000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9177e-22, 6.2330e-22, 6.1692e-14, 4.8756e-22],\n", + " [1.9983e-35, 2.2799e-35, 2.7839e-22, 2.0019e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9753e-06, 5.6613e-07, 1.0000e+00, 2.0829e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5842e-14, 5.7549e-15, 1.0000e+00, 1.6563e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4324e-19, 4.6836e-20, 1.0000e+00, 1.5130e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "371000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9179e-22, 6.2334e-22, 6.1320e-14, 4.8758e-22],\n", + " [1.9993e-35, 2.2811e-35, 2.7572e-22, 2.0029e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9840e-06, 5.6861e-07, 1.0000e+00, 2.0921e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6009e-14, 5.8155e-15, 1.0000e+00, 1.6737e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4533e-19, 4.7520e-20, 1.0000e+00, 1.5352e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "372000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9180e-22, 6.2336e-22, 6.0949e-14, 4.8760e-22],\n", + " [2.0002e-35, 2.2821e-35, 2.7308e-22, 2.0038e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.9928e-06, 5.7110e-07, 1.0000e+00, 2.1013e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6178e-14, 5.8767e-15, 1.0000e+00, 1.6913e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4745e-19, 4.8213e-20, 1.0000e+00, 1.5576e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "373000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9181e-22, 6.2339e-22, 6.0582e-14, 4.8762e-22],\n", + " [2.0012e-35, 2.2833e-35, 2.7046e-22, 2.0047e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0015e-06, 5.7360e-07, 1.0000e+00, 2.1106e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6348e-14, 5.9384e-15, 1.0000e+00, 1.7091e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4960e-19, 4.8916e-20, 1.0000e+00, 1.5803e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "374000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9184e-22, 6.2342e-22, 6.0217e-14, 4.8763e-22],\n", + " [2.0021e-35, 2.2844e-35, 2.6787e-22, 2.0057e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0103e-06, 5.7612e-07, 1.0000e+00, 2.1199e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6520e-14, 6.0010e-15, 1.0000e+00, 1.7271e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5178e-19, 4.9630e-20, 1.0000e+00, 1.6034e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "375000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9185e-22, 6.2346e-22, 5.9854e-14, 4.8765e-22],\n", + " [2.0030e-35, 2.2854e-35, 2.6530e-22, 2.0066e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0192e-06, 5.7864e-07, 1.0000e+00, 2.1292e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6693e-14, 6.0640e-15, 1.0000e+00, 1.7453e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5399e-19, 5.0354e-20, 1.0000e+00, 1.6268e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "376000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9186e-22, 6.2348e-22, 5.9493e-14, 4.8766e-22],\n", + " [2.0040e-35, 2.2866e-35, 2.6276e-22, 2.0076e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0280e-06, 5.8118e-07, 1.0000e+00, 2.1386e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6869e-14, 6.1277e-15, 1.0000e+00, 1.7636e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5624e-19, 5.1087e-20, 1.0000e+00, 1.6505e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "377000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9188e-22, 6.2350e-22, 5.9135e-14, 4.8768e-22],\n", + " [2.0049e-35, 2.2876e-35, 2.6025e-22, 2.0085e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0369e-06, 5.8372e-07, 1.0000e+00, 2.1480e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7046e-14, 6.1921e-15, 1.0000e+00, 1.7822e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5852e-19, 5.1832e-20, 1.0000e+00, 1.6746e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "378000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9189e-22, 6.2353e-22, 5.8779e-14, 4.8770e-22],\n", + " [2.0059e-35, 2.2887e-35, 2.5775e-22, 2.0095e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0459e-06, 5.8628e-07, 1.0000e+00, 2.1574e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7226e-14, 6.2572e-15, 1.0000e+00, 1.8010e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6083e-19, 5.2588e-20, 1.0000e+00, 1.6990e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "379000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9191e-22, 6.2356e-22, 5.8425e-14, 4.8771e-22],\n", + " [2.0068e-35, 2.2898e-35, 2.5529e-22, 2.0104e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0549e-06, 5.8885e-07, 1.0000e+00, 2.1669e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7407e-14, 6.3230e-15, 1.0000e+00, 1.8199e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6317e-19, 5.3354e-20, 1.0000e+00, 1.7238e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "380000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9193e-22, 6.2358e-22, 5.8073e-14, 4.8773e-22],\n", + " [2.0078e-35, 2.2909e-35, 2.5284e-22, 2.0114e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0639e-06, 5.9143e-07, 1.0000e+00, 2.1765e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7589e-14, 6.3895e-15, 1.0000e+00, 1.8390e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6555e-19, 5.4132e-20, 1.0000e+00, 1.7490e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "381000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9194e-22, 6.2361e-22, 5.7723e-14, 4.8774e-22],\n", + " [2.0087e-35, 2.2921e-35, 2.5042e-22, 2.0124e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0730e-06, 5.9403e-07, 1.0000e+00, 2.1861e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7775e-14, 6.4568e-15, 1.0000e+00, 1.8584e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6797e-19, 5.4921e-20, 1.0000e+00, 1.7745e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "382000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9196e-22, 6.2365e-22, 5.7377e-14, 4.8776e-22],\n", + " [2.0097e-35, 2.2932e-35, 2.4803e-22, 2.0133e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.0821e-06, 5.9663e-07, 1.0000e+00, 2.1957e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7962e-14, 6.5246e-15, 1.0000e+00, 1.8779e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7042e-19, 5.5722e-20, 1.0000e+00, 1.8004e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "383000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9198e-22, 6.2366e-22, 5.7031e-14, 4.8777e-22],\n", + " [2.0106e-35, 2.2943e-35, 2.4565e-22, 2.0142e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0913e-06, 5.9925e-07, 9.9999e-01, 2.2054e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8150e-14, 6.5933e-15, 1.0000e+00, 1.8977e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7290e-19, 5.6533e-20, 1.0000e+00, 1.8266e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "384000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9198e-22, 6.2370e-22, 5.6688e-14, 4.8779e-22],\n", + " [2.0115e-35, 2.2953e-35, 2.4331e-22, 2.0152e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1004e-06, 6.0184e-07, 9.9999e-01, 2.2150e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8338e-14, 6.6614e-15, 1.0000e+00, 1.9174e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7538e-19, 5.7345e-20, 1.0000e+00, 1.8528e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "385000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9200e-22, 6.2373e-22, 5.6353e-14, 4.8781e-22],\n", + " [2.0125e-35, 2.2965e-35, 2.4102e-22, 2.0161e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1095e-06, 6.0444e-07, 9.9999e-01, 2.2246e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8528e-14, 6.7303e-15, 1.0000e+00, 1.9372e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7789e-19, 5.8166e-20, 1.0000e+00, 1.8794e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "386000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9202e-22, 6.2377e-22, 5.6020e-14, 4.8782e-22],\n", + " [2.0134e-35, 2.2976e-35, 2.3876e-22, 2.0171e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1186e-06, 6.0704e-07, 9.9999e-01, 2.2342e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8719e-14, 6.7996e-15, 1.0000e+00, 1.9572e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8044e-19, 5.8998e-20, 1.0000e+00, 1.9063e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "387000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9203e-22, 6.2378e-22, 5.5690e-14, 4.8784e-22],\n", + " [2.0144e-35, 2.2987e-35, 2.3652e-22, 2.0180e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1277e-06, 6.0964e-07, 9.9999e-01, 2.2438e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8910e-14, 6.8690e-15, 1.0000e+00, 1.9772e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8299e-19, 5.9834e-20, 1.0000e+00, 1.9333e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "388000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9205e-22, 6.2381e-22, 5.5365e-14, 4.8786e-22],\n", + " [2.0153e-35, 2.2998e-35, 2.3432e-22, 2.0190e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1368e-06, 6.1223e-07, 9.9999e-01, 2.2534e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9102e-14, 6.9387e-15, 1.0000e+00, 1.9973e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8557e-19, 6.0675e-20, 1.0000e+00, 1.9606e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "389000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9207e-22, 6.2384e-22, 5.5043e-14, 4.8787e-22],\n", + " [2.0162e-35, 2.3009e-35, 2.3216e-22, 2.0200e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1459e-06, 6.1483e-07, 9.9999e-01, 2.2630e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9296e-14, 7.0093e-15, 1.0000e+00, 2.0176e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8818e-19, 6.1530e-20, 1.0000e+00, 1.9882e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "390000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9208e-22, 6.2387e-22, 5.4725e-14, 4.8789e-22],\n", + " [2.0171e-35, 2.3019e-35, 2.3002e-22, 2.0208e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1552e-06, 6.1750e-07, 9.9999e-01, 2.2729e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9494e-14, 7.0811e-15, 1.0000e+00, 2.0383e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9084e-19, 6.2397e-20, 1.0000e+00, 2.0162e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "391000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9210e-22, 6.2390e-22, 5.4407e-14, 4.8790e-22],\n", + " [2.0176e-35, 2.3025e-35, 2.2786e-22, 2.0213e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1646e-06, 6.2018e-07, 9.9999e-01, 2.2828e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9693e-14, 7.1536e-15, 1.0000e+00, 2.0591e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9352e-19, 6.3275e-20, 1.0000e+00, 2.0446e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "392000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9211e-22, 6.2392e-22, 5.4092e-14, 4.8791e-22],\n", + " [2.0181e-35, 2.3030e-35, 2.2573e-22, 2.0218e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.1740e-06, 6.2287e-07, 9.9999e-01, 2.2927e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9895e-14, 7.2266e-15, 1.0000e+00, 2.0802e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9624e-19, 6.4163e-20, 1.0000e+00, 2.0734e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "393000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9212e-22, 6.2395e-22, 5.3779e-14, 4.8793e-22],\n", + " [2.0185e-35, 2.3036e-35, 2.2363e-22, 2.0223e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1835e-06, 6.2557e-07, 9.9999e-01, 2.3027e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0097e-14, 7.3003e-15, 1.0000e+00, 2.1014e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9899e-19, 6.5062e-20, 1.0000e+00, 2.1024e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "394000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9213e-22, 6.2397e-22, 5.3468e-14, 4.8795e-22],\n", + " [2.0190e-35, 2.3041e-35, 2.2154e-22, 2.0228e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1929e-06, 6.2827e-07, 9.9999e-01, 2.3127e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0302e-14, 7.3747e-15, 1.0000e+00, 2.1228e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0178e-19, 6.5974e-20, 1.0000e+00, 2.1319e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "395000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9215e-22, 6.2399e-22, 5.3160e-14, 4.8796e-22],\n", + " [2.0195e-35, 2.3047e-35, 2.1948e-22, 2.0233e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2024e-06, 6.3099e-07, 9.9999e-01, 2.3227e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0509e-14, 7.4499e-15, 1.0000e+00, 2.1445e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0460e-19, 6.6897e-20, 1.0000e+00, 2.1618e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "396000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9216e-22, 6.2401e-22, 5.2853e-14, 4.8797e-22],\n", + " [2.0200e-35, 2.3052e-35, 2.1744e-22, 2.0237e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2120e-06, 6.3371e-07, 9.9999e-01, 2.3328e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0717e-14, 7.5256e-15, 1.0000e+00, 2.1663e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0746e-19, 6.7834e-20, 1.0000e+00, 2.1920e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "397000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9217e-22, 6.2405e-22, 5.2549e-14, 4.8798e-22],\n", + " [2.0204e-35, 2.3059e-35, 2.1542e-22, 2.0242e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2215e-06, 6.3645e-07, 9.9999e-01, 2.3429e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0928e-14, 7.6021e-15, 1.0000e+00, 2.1883e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1036e-19, 6.8780e-20, 1.0000e+00, 2.2227e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "398000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9219e-22, 6.2408e-22, 5.2247e-14, 4.8801e-22],\n", + " [2.0209e-35, 2.3064e-35, 2.1342e-22, 2.0247e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2311e-06, 6.3918e-07, 9.9999e-01, 2.3530e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1140e-14, 7.6790e-15, 1.0000e+00, 2.2105e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1329e-19, 6.9736e-20, 1.0000e+00, 2.2536e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "399000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9220e-22, 6.2409e-22, 5.1948e-14, 4.8801e-22],\n", + " [2.0214e-35, 2.3070e-35, 2.1145e-22, 2.0251e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2407e-06, 6.4193e-07, 9.9999e-01, 2.3631e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1353e-14, 7.7564e-15, 1.0000e+00, 2.2328e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1624e-19, 7.0702e-20, 1.0000e+00, 2.2848e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "400000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9222e-22, 6.2411e-22, 5.1653e-14, 4.8802e-22],\n", + " [2.0218e-35, 2.3075e-35, 2.0950e-22, 2.0256e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2504e-06, 6.4469e-07, 9.9999e-01, 2.3734e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1568e-14, 7.8348e-15, 1.0000e+00, 2.2553e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1924e-19, 7.1681e-20, 1.0000e+00, 2.3165e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "401000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9222e-22, 6.2414e-22, 5.1359e-14, 4.8803e-22],\n", + " [2.0222e-35, 2.3080e-35, 2.0758e-22, 2.0260e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2601e-06, 6.4747e-07, 9.9999e-01, 2.3836e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1786e-14, 7.9138e-15, 1.0000e+00, 2.2781e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2228e-19, 7.2674e-20, 1.0000e+00, 2.3486e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "402000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9224e-22, 6.2416e-22, 5.1066e-14, 4.8806e-22],\n", + " [2.0227e-35, 2.3085e-35, 2.0567e-22, 2.0265e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.2699e-06, 6.5025e-07, 9.9999e-01, 2.3939e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2006e-14, 7.9937e-15, 1.0000e+00, 2.3011e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2536e-19, 7.3681e-20, 1.0000e+00, 2.3812e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "403000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9225e-22, 6.2419e-22, 5.0775e-14, 4.8807e-22],\n", + " [2.0231e-35, 2.3090e-35, 2.0378e-22, 2.0269e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2797e-06, 6.5305e-07, 9.9999e-01, 2.4043e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2228e-14, 8.0745e-15, 1.0000e+00, 2.3244e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2848e-19, 7.4702e-20, 1.0000e+00, 2.4142e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "404000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9227e-22, 6.2421e-22, 5.0486e-14, 4.8808e-22],\n", + " [2.0236e-35, 2.3095e-35, 2.0191e-22, 2.0273e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2881e-06, 6.5548e-07, 9.9999e-01, 2.4132e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2426e-14, 8.1462e-15, 1.0000e+00, 2.3451e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3128e-19, 7.5618e-20, 1.0000e+00, 2.4438e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "405000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9227e-22, 6.2423e-22, 5.0228e-14, 4.8809e-22],\n", + " [2.0240e-35, 2.3100e-35, 2.0024e-22, 2.0278e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2937e-06, 6.5706e-07, 9.9999e-01, 2.4191e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2568e-14, 8.1981e-15, 1.0000e+00, 2.3600e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3334e-19, 7.6291e-20, 1.0000e+00, 2.4656e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "406000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9230e-22, 6.2427e-22, 5.0034e-14, 4.8811e-22],\n", + " [2.0244e-35, 2.3105e-35, 1.9899e-22, 2.0282e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2993e-06, 6.5865e-07, 9.9999e-01, 2.4250e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2711e-14, 8.2500e-15, 1.0000e+00, 2.3750e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3542e-19, 7.6968e-20, 1.0000e+00, 2.4875e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "407000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9230e-22, 6.2429e-22, 4.9841e-14, 4.8812e-22],\n", + " [2.0248e-35, 2.3110e-35, 1.9776e-22, 2.0286e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3049e-06, 6.6024e-07, 9.9999e-01, 2.4309e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2855e-14, 8.3023e-15, 1.0000e+00, 2.3900e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3750e-19, 7.7651e-20, 1.0000e+00, 2.5097e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "408000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9232e-22, 6.2431e-22, 4.9648e-14, 4.8814e-22],\n", + " [2.0252e-35, 2.3115e-35, 1.9654e-22, 2.0290e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3104e-06, 6.6182e-07, 9.9999e-01, 2.4368e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2999e-14, 8.3544e-15, 1.0000e+00, 2.4051e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3960e-19, 7.8334e-20, 1.0000e+00, 2.5318e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "409000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9233e-22, 6.2434e-22, 4.9458e-14, 4.8814e-22],\n", + " [2.0257e-35, 2.3120e-35, 1.9534e-22, 2.0295e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3159e-06, 6.6339e-07, 9.9999e-01, 2.4426e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3143e-14, 8.4066e-15, 1.0000e+00, 2.4201e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4169e-19, 7.9017e-20, 1.0000e+00, 2.5538e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "410000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9234e-22, 6.2435e-22, 4.9270e-14, 4.8816e-22],\n", + " [2.0261e-35, 2.3125e-35, 1.9415e-22, 2.0299e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3214e-06, 6.6496e-07, 9.9999e-01, 2.4484e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3287e-14, 8.4589e-15, 1.0000e+00, 2.4352e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4379e-19, 7.9706e-20, 1.0000e+00, 2.5762e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "411000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9236e-22, 6.2438e-22, 4.9084e-14, 4.8819e-22],\n", + " [2.0265e-35, 2.3130e-35, 1.9296e-22, 2.0303e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3270e-06, 6.6655e-07, 9.9999e-01, 2.4543e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3432e-14, 8.5117e-15, 1.0000e+00, 2.4504e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4593e-19, 8.0403e-20, 1.0000e+00, 2.5987e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "412000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9237e-22, 6.2441e-22, 4.8897e-14, 4.8820e-22],\n", + " [2.0269e-35, 2.3135e-35, 1.9179e-22, 2.0308e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.3326e-06, 6.6815e-07, 9.9999e-01, 2.4603e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3578e-14, 8.5650e-15, 1.0000e+00, 2.4657e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4808e-19, 8.1106e-20, 1.0000e+00, 2.6215e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "413000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9238e-22, 6.2443e-22, 4.8712e-14, 4.8821e-22],\n", + " [2.0274e-35, 2.3140e-35, 1.9063e-22, 2.0312e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3383e-06, 6.6977e-07, 9.9999e-01, 2.4662e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3726e-14, 8.6186e-15, 1.0000e+00, 2.4812e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5025e-19, 8.1815e-20, 1.0000e+00, 2.6444e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "414000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9240e-22, 6.2446e-22, 4.8528e-14, 4.8822e-22],\n", + " [2.0278e-35, 2.3146e-35, 1.8948e-22, 2.0316e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3439e-06, 6.7137e-07, 9.9999e-01, 2.4722e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3873e-14, 8.6721e-15, 1.0000e+00, 2.4967e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5242e-19, 8.2526e-20, 1.0000e+00, 2.6674e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "415000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9241e-22, 6.2448e-22, 4.8345e-14, 4.8824e-22],\n", + " [2.0282e-35, 2.3150e-35, 1.8834e-22, 2.0321e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3495e-06, 6.7297e-07, 9.9999e-01, 2.4781e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4022e-14, 8.7261e-15, 1.0000e+00, 2.5122e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5461e-19, 8.3242e-20, 1.0000e+00, 2.6906e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "416000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9242e-22, 6.2450e-22, 4.8164e-14, 4.8824e-22],\n", + " [2.0287e-35, 2.3156e-35, 1.8721e-22, 2.0325e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3553e-06, 6.7460e-07, 9.9999e-01, 2.4842e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4171e-14, 8.7805e-15, 1.0000e+00, 2.5278e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5682e-19, 8.3966e-20, 1.0000e+00, 2.7140e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "417000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9244e-22, 6.2454e-22, 4.7983e-14, 4.8826e-22],\n", + " [2.0291e-35, 2.3161e-35, 1.8608e-22, 2.0330e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3611e-06, 6.7626e-07, 9.9999e-01, 2.4903e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4322e-14, 8.8354e-15, 1.0000e+00, 2.5436e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5907e-19, 8.4699e-20, 1.0000e+00, 2.7377e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "418000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9245e-22, 6.2455e-22, 4.7803e-14, 4.8827e-22],\n", + " [2.0295e-35, 2.3166e-35, 1.8496e-22, 2.0334e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3668e-06, 6.7790e-07, 9.9999e-01, 2.4964e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4473e-14, 8.8903e-15, 1.0000e+00, 2.5595e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6131e-19, 8.5430e-20, 1.0000e+00, 2.7614e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "419000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9246e-22, 6.2458e-22, 4.7626e-14, 4.8829e-22],\n", + " [2.0299e-35, 2.3171e-35, 1.8386e-22, 2.0338e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3726e-06, 6.7955e-07, 9.9999e-01, 2.5025e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4625e-14, 8.9454e-15, 1.0000e+00, 2.5753e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6357e-19, 8.6169e-20, 1.0000e+00, 2.7853e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "420000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9248e-22, 6.2460e-22, 4.7449e-14, 4.8830e-22],\n", + " [2.0303e-35, 2.3176e-35, 1.8277e-22, 2.0342e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3783e-06, 6.8120e-07, 9.9999e-01, 2.5086e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4777e-14, 9.0008e-15, 1.0000e+00, 2.5913e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6584e-19, 8.6915e-20, 1.0000e+00, 2.8094e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "421000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9248e-22, 6.2463e-22, 4.7273e-14, 4.8832e-22],\n", + " [2.0308e-35, 2.3181e-35, 1.8168e-22, 2.0347e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3841e-06, 6.8285e-07, 9.9999e-01, 2.5147e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4931e-14, 9.0566e-15, 1.0000e+00, 2.6074e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6814e-19, 8.7665e-20, 1.0000e+00, 2.8336e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "422000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9249e-22, 6.2466e-22, 4.7097e-14, 4.8833e-22],\n", + " [2.0312e-35, 2.3186e-35, 1.8060e-22, 2.0351e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.3899e-06, 6.8450e-07, 9.9999e-01, 2.5208e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5085e-14, 9.1128e-15, 1.0000e+00, 2.6235e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7045e-19, 8.8422e-20, 1.0000e+00, 2.8581e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "423000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9252e-22, 6.2468e-22, 4.6923e-14, 4.8834e-22],\n", + " [2.0316e-35, 2.3191e-35, 1.7953e-22, 2.0356e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3957e-06, 6.8615e-07, 9.9999e-01, 2.5269e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5240e-14, 9.1692e-15, 1.0000e+00, 2.6398e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7278e-19, 8.9184e-20, 1.0000e+00, 2.8828e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "424000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9252e-22, 6.2471e-22, 4.6749e-14, 4.8836e-22],\n", + " [2.0321e-35, 2.3197e-35, 1.7847e-22, 2.0360e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4015e-06, 6.8782e-07, 9.9999e-01, 2.5331e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5396e-14, 9.2259e-15, 1.0000e+00, 2.6561e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7514e-19, 8.9953e-20, 1.0000e+00, 2.9077e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "425000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9254e-22, 6.2474e-22, 4.6575e-14, 4.8837e-22],\n", + " [2.0325e-35, 2.3202e-35, 1.7741e-22, 2.0364e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4074e-06, 6.8947e-07, 9.9999e-01, 2.5392e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5553e-14, 9.2829e-15, 1.0000e+00, 2.6725e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7751e-19, 9.0728e-20, 1.0000e+00, 2.9328e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "426000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9255e-22, 6.2475e-22, 4.6403e-14, 4.8839e-22],\n", + " [2.0329e-35, 2.3207e-35, 1.7635e-22, 2.0369e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4133e-06, 6.9117e-07, 9.9999e-01, 2.5455e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5712e-14, 9.3407e-15, 1.0000e+00, 2.6892e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7991e-19, 9.1516e-20, 1.0000e+00, 2.9582e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "427000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9256e-22, 6.2477e-22, 4.6231e-14, 4.8840e-22],\n", + " [2.0333e-35, 2.3212e-35, 1.7531e-22, 2.0373e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4193e-06, 6.9288e-07, 9.9999e-01, 2.5518e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5872e-14, 9.3991e-15, 1.0000e+00, 2.7060e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8234e-19, 9.2309e-20, 1.0000e+00, 2.9838e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "428000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9257e-22, 6.2480e-22, 4.6060e-14, 4.8841e-22],\n", + " [2.0337e-35, 2.3217e-35, 1.7427e-22, 2.0377e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4253e-06, 6.9459e-07, 9.9999e-01, 2.5581e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6033e-14, 9.4577e-15, 1.0000e+00, 2.7228e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8478e-19, 9.3107e-20, 1.0000e+00, 3.0097e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "429000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9258e-22, 6.2483e-22, 4.5889e-14, 4.8843e-22],\n", + " [2.0342e-35, 2.3222e-35, 1.7324e-22, 2.0382e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4312e-06, 6.9631e-07, 9.9999e-01, 2.5645e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6195e-14, 9.5164e-15, 1.0000e+00, 2.7398e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8725e-19, 9.3913e-20, 1.0000e+00, 3.0358e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "430000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9260e-22, 6.2485e-22, 4.5719e-14, 4.8845e-22],\n", + " [2.0346e-35, 2.3227e-35, 1.7221e-22, 2.0386e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4373e-06, 6.9805e-07, 9.9999e-01, 2.5709e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6359e-14, 9.5761e-15, 1.0000e+00, 2.7569e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8974e-19, 9.4730e-20, 1.0000e+00, 3.0621e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "431000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9260e-22, 6.2487e-22, 4.5550e-14, 4.8846e-22],\n", + " [2.0350e-35, 2.3232e-35, 1.7119e-22, 2.0390e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4435e-06, 6.9981e-07, 9.9999e-01, 2.5774e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6524e-14, 9.6363e-15, 1.0000e+00, 2.7742e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9226e-19, 9.5556e-20, 1.0000e+00, 3.0887e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "432000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9262e-22, 6.2490e-22, 4.5382e-14, 4.8846e-22],\n", + " [2.0354e-35, 2.3236e-35, 1.7018e-22, 2.0394e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.4496e-06, 7.0157e-07, 9.9999e-01, 2.5839e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6690e-14, 9.6964e-15, 1.0000e+00, 2.7915e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9479e-19, 9.6382e-20, 1.0000e+00, 3.1155e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "433000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9264e-22, 6.2492e-22, 4.5215e-14, 4.8848e-22],\n", + " [2.0358e-35, 2.3241e-35, 1.6917e-22, 2.0398e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4559e-06, 7.0335e-07, 9.9999e-01, 2.5904e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6856e-14, 9.7569e-15, 1.0000e+00, 2.8089e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9732e-19, 9.7213e-20, 1.0000e+00, 3.1424e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "434000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9265e-22, 6.2494e-22, 4.5051e-14, 4.8849e-22],\n", + " [2.0362e-35, 2.3246e-35, 1.6819e-22, 2.0403e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4619e-06, 7.0510e-07, 9.9999e-01, 2.5969e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7019e-14, 9.8163e-15, 1.0000e+00, 2.8260e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9982e-19, 9.8032e-20, 1.0000e+00, 3.1688e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "435000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9266e-22, 6.2497e-22, 4.4892e-14, 4.8851e-22],\n", + " [2.0367e-35, 2.3251e-35, 1.6724e-22, 2.0407e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4680e-06, 7.0686e-07, 9.9999e-01, 2.6034e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7183e-14, 9.8760e-15, 1.0000e+00, 2.8432e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0235e-19, 9.8858e-20, 1.0000e+00, 3.1955e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "436000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9267e-22, 6.2499e-22, 4.4732e-14, 4.8852e-22],\n", + " [2.0371e-35, 2.3256e-35, 1.6629e-22, 2.0411e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4742e-06, 7.0863e-07, 9.9999e-01, 2.6099e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7349e-14, 9.9364e-15, 1.0000e+00, 2.8605e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0489e-19, 9.9691e-20, 1.0000e+00, 3.2225e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "437000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9268e-22, 6.2501e-22, 4.4574e-14, 4.8854e-22],\n", + " [2.0375e-35, 2.3261e-35, 1.6535e-22, 2.0415e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4805e-06, 7.1041e-07, 9.9999e-01, 2.6165e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7515e-14, 9.9972e-15, 1.0000e+00, 2.8780e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0747e-19, 1.0053e-19, 1.0000e+00, 3.2497e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "438000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9270e-22, 6.2504e-22, 4.4416e-14, 4.8855e-22],\n", + " [2.0379e-35, 2.3266e-35, 1.6441e-22, 2.0420e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4867e-06, 7.1220e-07, 9.9999e-01, 2.6231e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7683e-14, 1.0058e-14, 1.0000e+00, 2.8956e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1006e-19, 1.0138e-19, 1.0000e+00, 3.2772e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "439000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9271e-22, 6.2506e-22, 4.4259e-14, 4.8857e-22],\n", + " [2.0384e-35, 2.3271e-35, 1.6348e-22, 2.0424e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4929e-06, 7.1400e-07, 9.9999e-01, 2.6297e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7852e-14, 1.0120e-14, 1.0000e+00, 2.9133e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1268e-19, 1.0224e-19, 1.0000e+00, 3.3048e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "440000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9273e-22, 6.2509e-22, 4.4102e-14, 4.8858e-22],\n", + " [2.0388e-35, 2.3276e-35, 1.6255e-22, 2.0428e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4992e-06, 7.1579e-07, 9.9999e-01, 2.6363e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8022e-14, 1.0182e-14, 1.0000e+00, 2.9311e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1532e-19, 1.0311e-19, 1.0000e+00, 3.3328e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "441000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9274e-22, 6.2512e-22, 4.3946e-14, 4.8860e-22],\n", + " [2.0392e-35, 2.3281e-35, 1.6163e-22, 2.0432e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5055e-06, 7.1760e-07, 9.9999e-01, 2.6430e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8193e-14, 1.0244e-14, 1.0000e+00, 2.9490e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1798e-19, 1.0398e-19, 1.0000e+00, 3.3609e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "442000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9276e-22, 6.2514e-22, 4.3791e-14, 4.8861e-22],\n", + " [2.0396e-35, 2.3286e-35, 1.6071e-22, 2.0437e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.5118e-06, 7.1941e-07, 9.9999e-01, 2.6496e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8365e-14, 1.0307e-14, 1.0000e+00, 2.9670e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2066e-19, 1.0486e-19, 1.0000e+00, 3.3893e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "443000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9276e-22, 6.2515e-22, 4.3635e-14, 4.8863e-22],\n", + " [2.0401e-35, 2.3291e-35, 1.5980e-22, 2.0441e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5181e-06, 7.2123e-07, 9.9999e-01, 2.6563e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8538e-14, 1.0370e-14, 1.0000e+00, 2.9852e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2337e-19, 1.0574e-19, 1.0000e+00, 3.4179e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "444000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9279e-22, 6.2518e-22, 4.3481e-14, 4.8864e-22],\n", + " [2.0405e-35, 2.3296e-35, 1.5889e-22, 2.0445e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5244e-06, 7.2305e-07, 9.9999e-01, 2.6630e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8713e-14, 1.0434e-14, 1.0000e+00, 3.0035e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2610e-19, 1.0664e-19, 1.0000e+00, 3.4468e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "445000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9279e-22, 6.2521e-22, 4.3327e-14, 4.8865e-22],\n", + " [2.0409e-35, 2.3301e-35, 1.5800e-22, 2.0450e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5308e-06, 7.2487e-07, 9.9999e-01, 2.6697e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8888e-14, 1.0498e-14, 1.0000e+00, 3.0218e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2885e-19, 1.0754e-19, 1.0000e+00, 3.4759e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "446000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9281e-22, 6.2524e-22, 4.3174e-14, 4.8868e-22],\n", + " [2.0413e-35, 2.3307e-35, 1.5710e-22, 2.0454e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5371e-06, 7.2669e-07, 9.9999e-01, 2.6764e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9063e-14, 1.0561e-14, 1.0000e+00, 3.0401e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3161e-19, 1.0844e-19, 1.0000e+00, 3.5051e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "447000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9282e-22, 6.2526e-22, 4.3022e-14, 4.8868e-22],\n", + " [2.0418e-35, 2.3312e-35, 1.5622e-22, 2.0459e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5436e-06, 7.2854e-07, 9.9999e-01, 2.6832e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9240e-14, 1.0626e-14, 1.0000e+00, 3.0587e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3440e-19, 1.0935e-19, 1.0000e+00, 3.5346e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "448000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9284e-22, 6.2529e-22, 4.2871e-14, 4.8871e-22],\n", + " [2.0422e-35, 2.3316e-35, 1.5534e-22, 2.0463e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5500e-06, 7.3039e-07, 9.9999e-01, 2.6901e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9418e-14, 1.0691e-14, 1.0000e+00, 3.0773e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3721e-19, 1.1027e-19, 1.0000e+00, 3.5644e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "449000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9285e-22, 6.2530e-22, 4.2722e-14, 4.8872e-22],\n", + " [2.0426e-35, 2.3321e-35, 1.5447e-22, 2.0467e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5565e-06, 7.3225e-07, 9.9999e-01, 2.6969e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9597e-14, 1.0756e-14, 1.0000e+00, 3.0961e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4003e-19, 1.1120e-19, 1.0000e+00, 3.5943e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "450000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9285e-22, 6.2533e-22, 4.2572e-14, 4.8873e-22],\n", + " [2.0430e-35, 2.3326e-35, 1.5360e-22, 2.0471e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5630e-06, 7.3411e-07, 9.9999e-01, 2.7038e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9778e-14, 1.0821e-14, 1.0000e+00, 3.1149e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4289e-19, 1.1213e-19, 1.0000e+00, 3.6245e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "451000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9288e-22, 6.2535e-22, 4.2423e-14, 4.8875e-22],\n", + " [2.0435e-35, 2.3331e-35, 1.5274e-22, 2.0476e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5695e-06, 7.3597e-07, 9.9999e-01, 2.7106e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9958e-14, 1.0887e-14, 1.0000e+00, 3.1339e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4576e-19, 1.1307e-19, 1.0000e+00, 3.6548e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "452000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9289e-22, 6.2536e-22, 4.2275e-14, 4.8875e-22],\n", + " [2.0439e-35, 2.3336e-35, 1.5189e-22, 2.0480e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.5760e-06, 7.3783e-07, 9.9999e-01, 2.7175e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0139e-14, 1.0953e-14, 1.0000e+00, 3.1529e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4865e-19, 1.1402e-19, 1.0000e+00, 3.6854e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "453000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9290e-22, 6.2540e-22, 4.2128e-14, 4.8877e-22],\n", + " [2.0443e-35, 2.3341e-35, 1.5104e-22, 2.0484e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5825e-06, 7.3969e-07, 9.9999e-01, 2.7244e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0322e-14, 1.1020e-14, 1.0000e+00, 3.1720e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5156e-19, 1.1497e-19, 1.0000e+00, 3.7163e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "454000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9291e-22, 6.2542e-22, 4.1981e-14, 4.8877e-22],\n", + " [2.0447e-35, 2.3346e-35, 1.5020e-22, 2.0488e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5891e-06, 7.4158e-07, 9.9999e-01, 2.7313e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0506e-14, 1.1087e-14, 1.0000e+00, 3.1912e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5450e-19, 1.1593e-19, 1.0000e+00, 3.7473e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "455000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9292e-22, 6.2544e-22, 4.1835e-14, 4.8879e-22],\n", + " [2.0451e-35, 2.3351e-35, 1.4936e-22, 2.0493e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5957e-06, 7.4349e-07, 9.9999e-01, 2.7384e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0691e-14, 1.1154e-14, 1.0000e+00, 3.2107e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5747e-19, 1.1690e-19, 1.0000e+00, 3.7787e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "456000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9293e-22, 6.2546e-22, 4.1690e-14, 4.8881e-22],\n", + " [2.0455e-35, 2.3356e-35, 1.4854e-22, 2.0497e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6024e-06, 7.4541e-07, 9.9999e-01, 2.7454e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0878e-14, 1.1222e-14, 1.0000e+00, 3.2302e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6046e-19, 1.1788e-19, 1.0000e+00, 3.8103e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "457000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9294e-22, 6.2548e-22, 4.1546e-14, 4.8882e-22],\n", + " [2.0460e-35, 2.3360e-35, 1.4771e-22, 2.0501e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6091e-06, 7.4733e-07, 9.9999e-01, 2.7525e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1066e-14, 1.1290e-14, 1.0000e+00, 3.2499e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6347e-19, 1.1887e-19, 1.0000e+00, 3.8423e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "458000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9295e-22, 6.2551e-22, 4.1403e-14, 4.8883e-22],\n", + " [2.0464e-35, 2.3365e-35, 1.4690e-22, 2.0505e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6158e-06, 7.4926e-07, 9.9999e-01, 2.7596e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1254e-14, 1.1359e-14, 1.0000e+00, 3.2696e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6651e-19, 1.1986e-19, 1.0000e+00, 3.8744e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "459000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9297e-22, 6.2551e-22, 4.1260e-14, 4.8885e-22],\n", + " [2.0468e-35, 2.3370e-35, 1.4609e-22, 2.0510e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6225e-06, 7.5116e-07, 9.9999e-01, 2.7667e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1442e-14, 1.1427e-14, 1.0000e+00, 3.2893e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6953e-19, 1.2085e-19, 1.0000e+00, 3.9064e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "460000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9298e-22, 6.2553e-22, 4.1119e-14, 4.8886e-22],\n", + " [2.0473e-35, 2.3376e-35, 1.4529e-22, 2.0514e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6293e-06, 7.5311e-07, 9.9999e-01, 2.7738e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1632e-14, 1.1497e-14, 1.0000e+00, 3.3092e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7260e-19, 1.2186e-19, 1.0000e+00, 3.9388e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "461000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9299e-22, 6.2556e-22, 4.0979e-14, 4.8887e-22],\n", + " [2.0476e-35, 2.3380e-35, 1.4449e-22, 2.0518e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6362e-06, 7.5508e-07, 9.9999e-01, 2.7811e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1824e-14, 1.1566e-14, 1.0000e+00, 3.3293e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7570e-19, 1.2287e-19, 1.0000e+00, 3.9716e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "462000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9299e-22, 6.2557e-22, 4.0838e-14, 4.8888e-22],\n", + " [2.0479e-35, 2.3384e-35, 1.4370e-22, 2.0521e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.6431e-06, 7.5706e-07, 9.9999e-01, 2.7884e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2017e-14, 1.1637e-14, 1.0000e+00, 3.3495e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7882e-19, 1.2389e-19, 1.0000e+00, 4.0046e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "463000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9302e-22, 6.2560e-22, 4.0699e-14, 4.8889e-22],\n", + " [2.0483e-35, 2.3388e-35, 1.4291e-22, 2.0525e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6501e-06, 7.5907e-07, 9.9999e-01, 2.7958e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2213e-14, 1.1708e-14, 1.0000e+00, 3.3700e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8199e-19, 1.2493e-19, 1.0000e+00, 4.0382e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "464000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9303e-22, 6.2561e-22, 4.0560e-14, 4.8890e-22],\n", + " [2.0487e-35, 2.3393e-35, 1.4213e-22, 2.0529e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6571e-06, 7.6109e-07, 9.9999e-01, 2.8033e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2410e-14, 1.1780e-14, 1.0000e+00, 3.3906e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8519e-19, 1.2598e-19, 1.0000e+00, 4.0720e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "465000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9304e-22, 6.2564e-22, 4.0422e-14, 4.8891e-22],\n", + " [2.0491e-35, 2.3396e-35, 1.4135e-22, 2.0532e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6641e-06, 7.6309e-07, 9.9999e-01, 2.8106e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2604e-14, 1.1851e-14, 1.0000e+00, 3.4110e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8835e-19, 1.2701e-19, 1.0000e+00, 4.1053e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "466000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9305e-22, 6.2565e-22, 4.0286e-14, 4.8893e-22],\n", + " [2.0494e-35, 2.3401e-35, 1.4059e-22, 2.0536e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6710e-06, 7.6509e-07, 9.9999e-01, 2.8179e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2800e-14, 1.1922e-14, 1.0000e+00, 3.4314e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9153e-19, 1.2805e-19, 1.0000e+00, 4.1390e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "467000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9305e-22, 6.2567e-22, 4.0152e-14, 4.8892e-22],\n", + " [2.0498e-35, 2.3405e-35, 1.3984e-22, 2.0540e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6780e-06, 7.6709e-07, 9.9999e-01, 2.8253e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2997e-14, 1.1994e-14, 1.0000e+00, 3.4520e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9474e-19, 1.2911e-19, 1.0000e+00, 4.1730e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "468000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9306e-22, 6.2569e-22, 4.0018e-14, 4.8894e-22],\n", + " [2.0501e-35, 2.3409e-35, 1.3909e-22, 2.0543e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6850e-06, 7.6910e-07, 9.9999e-01, 2.8327e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3194e-14, 1.2066e-14, 1.0000e+00, 3.4728e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9798e-19, 1.3017e-19, 1.0000e+00, 4.2072e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "469000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9308e-22, 6.2570e-22, 3.9884e-14, 4.8896e-22],\n", + " [2.0505e-35, 2.3413e-35, 1.3834e-22, 2.0547e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6920e-06, 7.7111e-07, 9.9999e-01, 2.8401e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3393e-14, 1.2138e-14, 1.0000e+00, 3.4936e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0124e-19, 1.3123e-19, 1.0000e+00, 4.2418e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "470000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9310e-22, 6.2572e-22, 3.9751e-14, 4.8896e-22],\n", + " [2.0509e-35, 2.3417e-35, 1.3760e-22, 2.0550e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6989e-06, 7.7309e-07, 9.9999e-01, 2.8474e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3590e-14, 1.2210e-14, 1.0000e+00, 3.5141e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0447e-19, 1.3229e-19, 1.0000e+00, 4.2759e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "471000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9310e-22, 6.2573e-22, 3.9620e-14, 4.8897e-22],\n", + " [2.0512e-35, 2.3421e-35, 1.3687e-22, 2.0554e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7058e-06, 7.7507e-07, 9.9999e-01, 2.8547e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3787e-14, 1.2282e-14, 1.0000e+00, 3.5348e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0772e-19, 1.3335e-19, 1.0000e+00, 4.3103e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "472000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9311e-22, 6.2576e-22, 3.9491e-14, 4.8899e-22],\n", + " [2.0516e-35, 2.3426e-35, 1.3615e-22, 2.0558e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.7128e-06, 7.7706e-07, 9.9999e-01, 2.8620e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3986e-14, 1.2354e-14, 1.0000e+00, 3.5556e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1099e-19, 1.3442e-19, 1.0000e+00, 4.3449e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "473000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9312e-22, 6.2577e-22, 3.9362e-14, 4.8900e-22],\n", + " [2.0519e-35, 2.3430e-35, 1.3544e-22, 2.0561e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7197e-06, 7.7905e-07, 9.9999e-01, 2.8693e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4185e-14, 1.2427e-14, 1.0000e+00, 3.5765e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1429e-19, 1.3551e-19, 1.0000e+00, 4.3798e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "474000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9312e-22, 6.2578e-22, 3.9232e-14, 4.8900e-22],\n", + " [2.0523e-35, 2.3434e-35, 1.3473e-22, 2.0565e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7267e-06, 7.8105e-07, 9.9999e-01, 2.8767e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4386e-14, 1.2500e-14, 1.0000e+00, 3.5975e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1762e-19, 1.3660e-19, 1.0000e+00, 4.4150e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "475000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9314e-22, 6.2581e-22, 3.9104e-14, 4.8902e-22],\n", + " [2.0526e-35, 2.3438e-35, 1.3402e-22, 2.0568e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7337e-06, 7.8305e-07, 9.9999e-01, 2.8841e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4588e-14, 1.2573e-14, 1.0000e+00, 3.6186e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2098e-19, 1.3769e-19, 1.0000e+00, 4.4505e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "476000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9315e-22, 6.2582e-22, 3.8976e-14, 4.8903e-22],\n", + " [2.0530e-35, 2.3442e-35, 1.3332e-22, 2.0572e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7408e-06, 7.8509e-07, 9.9999e-01, 2.8916e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4792e-14, 1.2647e-14, 1.0000e+00, 3.6400e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2438e-19, 1.3880e-19, 1.0000e+00, 4.4864e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "477000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9316e-22, 6.2584e-22, 3.8849e-14, 4.8904e-22],\n", + " [2.0534e-35, 2.3446e-35, 1.3262e-22, 2.0576e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7479e-06, 7.8714e-07, 9.9999e-01, 2.8991e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4998e-14, 1.2723e-14, 1.0000e+00, 3.6616e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2780e-19, 1.3993e-19, 1.0000e+00, 4.5227e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "478000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9317e-22, 6.2585e-22, 3.8722e-14, 4.8905e-22],\n", + " [2.0537e-35, 2.3450e-35, 1.3192e-22, 2.0579e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7551e-06, 7.8921e-07, 9.9999e-01, 2.9068e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5205e-14, 1.2798e-14, 1.0000e+00, 3.6833e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3126e-19, 1.4106e-19, 1.0000e+00, 4.5592e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "479000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9317e-22, 6.2587e-22, 3.8595e-14, 4.8906e-22],\n", + " [2.0541e-35, 2.3455e-35, 1.3123e-22, 2.0583e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7624e-06, 7.9128e-07, 9.9999e-01, 2.9144e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5415e-14, 1.2874e-14, 1.0000e+00, 3.7051e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3475e-19, 1.4220e-19, 1.0000e+00, 4.5961e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "480000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9319e-22, 6.2587e-22, 3.8469e-14, 4.8906e-22],\n", + " [2.0544e-35, 2.3459e-35, 1.3054e-22, 2.0586e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7698e-06, 7.9340e-07, 9.9999e-01, 2.9222e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5626e-14, 1.2951e-14, 1.0000e+00, 3.7273e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3828e-19, 1.4335e-19, 1.0000e+00, 4.6335e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "481000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9319e-22, 6.2590e-22, 3.8344e-14, 4.8908e-22],\n", + " [2.0548e-35, 2.3463e-35, 1.2985e-22, 2.0590e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7772e-06, 7.9552e-07, 9.9999e-01, 2.9300e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5838e-14, 1.3028e-14, 1.0000e+00, 3.7495e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4184e-19, 1.4452e-19, 1.0000e+00, 4.6711e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "482000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9321e-22, 6.2590e-22, 3.8219e-14, 4.8908e-22],\n", + " [2.0551e-35, 2.3467e-35, 1.2917e-22, 2.0593e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.7846e-06, 7.9765e-07, 9.9999e-01, 2.9378e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6053e-14, 1.3106e-14, 1.0000e+00, 3.7719e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4543e-19, 1.4569e-19, 1.0000e+00, 4.7091e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "483000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9321e-22, 6.2592e-22, 3.8094e-14, 4.8908e-22],\n", + " [2.0555e-35, 2.3470e-35, 1.2850e-22, 2.0597e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7922e-06, 7.9983e-07, 9.9999e-01, 2.9458e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6270e-14, 1.3185e-14, 1.0000e+00, 3.7946e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4907e-19, 1.4689e-19, 1.0000e+00, 4.7476e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "484000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9322e-22, 6.2593e-22, 3.7970e-14, 4.8909e-22],\n", + " [2.0558e-35, 2.3475e-35, 1.2782e-22, 2.0600e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7998e-06, 8.0201e-07, 9.9999e-01, 2.9539e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6488e-14, 1.3265e-14, 1.0000e+00, 3.8175e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5275e-19, 1.4809e-19, 1.0000e+00, 4.7866e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "485000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9322e-22, 6.2593e-22, 3.7845e-14, 4.8910e-22],\n", + " [2.0562e-35, 2.3479e-35, 1.2715e-22, 2.0604e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8075e-06, 8.0421e-07, 9.9999e-01, 2.9620e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6709e-14, 1.3345e-14, 1.0000e+00, 3.8406e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5646e-19, 1.4930e-19, 1.0000e+00, 4.8258e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "486000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9322e-22, 6.2596e-22, 3.7722e-14, 4.8911e-22],\n", + " [2.0565e-35, 2.3482e-35, 1.2648e-22, 2.0607e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8152e-06, 8.0641e-07, 9.9999e-01, 2.9701e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6930e-14, 1.3426e-14, 1.0000e+00, 3.8638e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6021e-19, 1.5053e-19, 1.0000e+00, 4.8653e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "487000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9323e-22, 6.2595e-22, 3.7598e-14, 4.8911e-22],\n", + " [2.0569e-35, 2.3486e-35, 1.2582e-22, 2.0611e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8229e-06, 8.0862e-07, 9.9999e-01, 2.9783e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7154e-14, 1.3507e-14, 1.0000e+00, 3.8871e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6398e-19, 1.5176e-19, 1.0000e+00, 4.9052e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "488000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9322e-22, 6.2595e-22, 3.7476e-14, 4.8911e-22],\n", + " [2.0572e-35, 2.3490e-35, 1.2516e-22, 2.0614e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8306e-06, 8.1084e-07, 9.9999e-01, 2.9864e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7378e-14, 1.3588e-14, 1.0000e+00, 3.9106e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6777e-19, 1.5301e-19, 1.0000e+00, 4.9453e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "489000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9325e-22, 6.2597e-22, 3.7353e-14, 4.8912e-22],\n", + " [2.0575e-35, 2.3494e-35, 1.2451e-22, 2.0617e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8384e-06, 8.1307e-07, 9.9999e-01, 2.9946e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7604e-14, 1.3670e-14, 1.0000e+00, 3.9342e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7161e-19, 1.5426e-19, 1.0000e+00, 4.9859e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "490000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9324e-22, 6.2598e-22, 3.7231e-14, 4.8912e-22],\n", + " [2.0579e-35, 2.3498e-35, 1.2385e-22, 2.0621e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8462e-06, 8.1531e-07, 9.9999e-01, 3.0029e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7831e-14, 1.3753e-14, 1.0000e+00, 3.9580e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7548e-19, 1.5552e-19, 1.0000e+00, 5.0269e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "491000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9325e-22, 6.2600e-22, 3.7110e-14, 4.8913e-22],\n", + " [2.0582e-35, 2.3501e-35, 1.2320e-22, 2.0624e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8541e-06, 8.1756e-07, 9.9999e-01, 3.0111e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8060e-14, 1.3836e-14, 1.0000e+00, 3.9820e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7938e-19, 1.5680e-19, 1.0000e+00, 5.0681e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "492000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9325e-22, 6.2599e-22, 3.6989e-14, 4.8914e-22],\n", + " [2.0585e-35, 2.3505e-35, 1.2256e-22, 2.0627e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.8619e-06, 8.1982e-07, 9.9999e-01, 3.0195e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8290e-14, 1.3920e-14, 1.0000e+00, 4.0061e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8331e-19, 1.5809e-19, 1.0000e+00, 5.1097e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "493000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9326e-22, 6.2600e-22, 3.6868e-14, 4.8914e-22],\n", + " [2.0588e-35, 2.3509e-35, 1.2191e-22, 2.0631e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8698e-06, 8.2208e-07, 9.9999e-01, 3.0278e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8522e-14, 1.4004e-14, 1.0000e+00, 4.0303e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8728e-19, 1.5939e-19, 1.0000e+00, 5.1516e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "494000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9326e-22, 6.2602e-22, 3.6748e-14, 4.8915e-22],\n", + " [2.0591e-35, 2.3513e-35, 1.2127e-22, 2.0634e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8777e-06, 8.2435e-07, 9.9999e-01, 3.0362e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8755e-14, 1.4089e-14, 1.0000e+00, 4.0547e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9128e-19, 1.6069e-19, 1.0000e+00, 5.1939e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "495000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9327e-22, 6.2602e-22, 3.6628e-14, 4.8914e-22],\n", + " [2.0595e-35, 2.3517e-35, 1.2064e-22, 2.0637e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8857e-06, 8.2663e-07, 9.9999e-01, 3.0445e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8990e-14, 1.4175e-14, 1.0000e+00, 4.0793e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9532e-19, 1.6201e-19, 1.0000e+00, 5.2366e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "496000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9328e-22, 6.2604e-22, 3.6508e-14, 4.8916e-22],\n", + " [2.0598e-35, 2.3520e-35, 1.2001e-22, 2.0640e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8937e-06, 8.2891e-07, 9.9999e-01, 3.0529e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9226e-14, 1.4261e-14, 1.0000e+00, 4.1041e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9938e-19, 1.6334e-19, 1.0000e+00, 5.2796e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "497000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9329e-22, 6.2604e-22, 3.6389e-14, 4.8916e-22],\n", + " [2.0601e-35, 2.3524e-35, 1.1937e-22, 2.0644e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9016e-06, 8.3121e-07, 9.9999e-01, 3.0614e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9464e-14, 1.4347e-14, 1.0000e+00, 4.1289e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0348e-19, 1.6468e-19, 1.0000e+00, 5.3229e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "498000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9329e-22, 6.2604e-22, 3.6270e-14, 4.8916e-22],\n", + " [2.0605e-35, 2.3527e-35, 1.1875e-22, 2.0647e-35]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9097e-06, 8.3350e-07, 9.9999e-01, 3.0698e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9703e-14, 1.4434e-14, 1.0000e+00, 4.1539e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0761e-19, 1.6604e-19, 1.0000e+00, 5.3667e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "499000 actions: tensor([2, 2, 2])\n", + "loss= tensor(2.3605, grad_fn=) , return= 16145.578125\n", + "discReturns/1000= tensor([5.1083, 5.4351, 5.6023])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.9329e-22, 6.2605e-22, 3.6152e-14, 4.8917e-22],\n", + " [2.0608e-35, 2.3531e-35, 1.1812e-22, 2.0650e-35]],\n", + " grad_fn=)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.00200.00
1204.50195.50
2206.75193.25
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.00 200.00\n", + "1 204.50 195.50\n", + "2 206.75 193.25" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAp2klEQVR4nO3deXxV5b3v8c8vEyEkJBAChAyEQZB5CoJglTrP89yqKC3Vl72tna7U1lbvOb3H9vZq22NvLac1qFXUU7XOWmqr1oDM8+BEQhIIMyFhCJme+8daQKCQ7ITsrJ2d7/v1Wq/srGHnx+bhx5NnPev3mHMOERGJLjFBByAiIm1PyV1EJAopuYuIRCEldxGRKKTkLiISheKCDgCgV69eLi8vL+gwREQ6lKVLl+50zmWc6FhEJPe8vDyWLFkSdBgiIh2KmW062TENy4iIRCEldxGRKKTkLiIShSJizP1EamtrKSsro7q6OuhQmpSYmEh2djbx8fFBhyIickTEJveysjJSUlLIy8vDzIIO54Scc+zatYuysjIGDBgQdDgiIkdE7LBMdXU16enpEZvYAcyM9PT0iP/tQkQ6n4hN7kBEJ/bDOkKMItL5ROywjIhItKqurWftlkpWlFbQt3sil43ObPOfoeTejHfeeYdvf/vb1NfX87WvfY1Zs2YFHZKIdCDOOTbtOsCK0gqWl+xhRWkF68orqa331tK4amw/Jff2Vl9fz7333su8efPIzs5m4sSJXHnllQwfPjzo0EQkQu09WMvK0gqWl1SwotRL5nsO1AKQlBDL6OxUvvalgYzNSWNcThq9uyeGJQ4l9yYsWrSIwYMHM3DgQABuvvlmXn31VSV3EQGgrr6BDVurWF5awQo/mX+xYz8AZnBa72QuGN6Hcbk9GJuTxpA+KcTGtM99ug6R3B9+fS3rtlS26XsO79edn14xoslzNm/eTE5OzpHvs7OzWbhwYZvGISIdR/neg36P3EvmqzZXUF3bAECv5ATG5qRx7fhsxuakMTo7lZTE4J5/6RDJPSgnWl9Ws2NEOocDNXWsLtt7pFe+vHQP2yoPAZAQG8OIrO7cekZ/xuZ6wyvZPbpGVH7oEMm9uR52uGRnZ1NaWnrk+7KyMvr16xdILCISPg0Njo0797HM75UvL6ng021V1Dd4Hbz+6UmcOTCdsTlpjM3twbDMFLrExQYcddM6RHIPysSJE/nss88oKioiKyuL559/nueeey7osETkFO3eX8OK0j1Hh1hKK6iqrgMgJTGOsTlpXDBsEGNz0xiTnUZ6cpeAI245JfcmxMXF8fjjj3PRRRdRX1/PXXfdxYgRwfwWISKtc6iunvXlVUemIS4vqaBk9wEAYmOMoX1SuHJMP2/2Sm4PBvbqRkw73fQMp2aTu5nlAE8DfYEGYLZz7tdm1hN4AcgDioEbnXN7/GtGA78HuvvXTHTOdchn9C+99FIuvfTSoMMQkRA45yjbc5BljRL5ui2V1NR7Nz37dk9kXG4aX5mUy9icNEZlp5KUEJ193FD+VHXA95xzy8wsBVhqZvOA6cB7zrlHzGwWMAu438zigD8BtznnVppZOlAbpvhFpBOrrK5lVeneI/PJl5dUsGt/DQCJ8TGMzk7jzql5/lh5GpmpXQOOuP00m9ydc+VAuf+6yszWA1nAVcA0/7SngPeB+4ELgVXOuZX+NbvaPGoR6XTqGxyfbqs68nDQ8pIKPt+xj8OT2gZldOPLp/f2h1fSGNonhbjYiC6fFVYt+n3EzPKAccBCoI+f+HHOlZtZb/+0IYAzs3eBDOB559wvTvBeM4GZALm5ua3+A4hIdNpWWX3khufykj2s3ryXAzX1APRIimdcbg+uGNOPcblpjM5OI7Wr1lRoLOTkbmbJwEvAfc65yibmc8YBZwETgQPAe2a21Dn3XuOTnHOzgdkA+fn5/zqhXEQ6jeraelZv3ntkPvmKkgq27PVu08XHGsP7pXJjfs6RXnluz6SImlMeiUJK7mYWj5fYn3XOvezv3mZmmX6vPRPY7u8vAz5wzu30r30LGA+8d/z7ikjn09DgKNq1339c30vmG8qrqPPnlGf36MqEvJ7M8BP58MzuJMZH9pzySBTKbBkD/gisd8492ujQa8AdwCP+11f9/e8C/9PMkoAa4BzgsbYMWkQ6jj37a1hRdvgpzwpWllaw96A3xyK5SxxjclL5xjkDGZfTgzE5aWSkdLw55ZEolJ77VOA2YLWZrfD3PYCX1F80sxlACXADgHNuj5k9CiwGHPCWc+7Ntg68Pdx111288cYb9O7dmzVr1gQdjkjEq6lrYMPWyiMzV1aUVlC00yukFWMwpE8Kl47qe2RO+aCM5HYrpNXZhDJb5iPgZJ/+eSe55k940yE7tOnTp/PNb36T22+/PehQRCKOc47NFQePSeRrNu/lUJ03pzwjpQvjctK4IT+bcTk9GJ2dSrcu0TmnPBLpk27C2WefTXFxcdBhiESEfYfqWFVWcUwy31HlFdLqEhfDqKxUbpvc3ytvm5tGv9RE3fQMUMdI7m/Pgq2r2/Y9+46CSx5p2/cUiRL1DY7Pt+87pv7Kp9uq8O95MrBXN740uBfjctMYm9OD0zNTiO/Ec8ojUcdI7iISVjuqDh2zDNyqsr3sO+QV0krtGs/YnDQuGtHXT+ZppCUlBByxNKdjJHf1sEXazOHFmQ8n8hWlFZTtOQhAXIwxLLM714zLOpLIB/TqpuGVDqhjJHcRaZXmFmfOSuvK2Jw0pk/x6q+MzErVnPIooeTehFtuuYX333+fnTt3kp2dzcMPP8yMGTOCDkvkpEJZnHnGWQMZlxvexZkleEruTZg7d27QIYicVCQvzizBU3IX6SDK9x488pRnpC/OLMFTcheJQB19cWYJXkQnd+dcxDdY51TQUk7N8Yszryip4JPjFmeePDCdcR1ocWYJXsQm98TERHbt2kV6enrEJnjnHLt27SIxUTelJHShLM58bwdfnFmCF7HJPTs7m7KyMnbs2BF0KE1KTEwkOzs76DAkQnXWxZkleBGb3OPj4xkwYEDQYYiETIszSyRRyxJppWYXZ87qvIszS/CU3EVC0JLFmcfmpHF63869OLMET8ld5CQ2VxzkhcWlLNy466SLM4/NSWNMjhZnlsij5C7SiHOOxcV7KCgs4t21WwEYlaXFmaXjUXIXwZvV8vrKcgoKi1i7pZLUrvF8/eyB3H5mHllpGiuXjkfJXTq17ZXV/OnjTTy3qISd+2o4rXcyP7tmJNeMy9JMFunQ1HqlU1pZWkFBYRFvri6nrsFx7tDeTJ+ax1mDe2nIRaJCs8ndzHKAp4G+QAMw2zn3azPrCbwA5AHFwI3OuT2NrssF1gEPOed+2fahi7RMbX0D76zZSkFhEctKKkjuEsdXJvVn+pQ88np1Czo8kTYVSs+9Dviec26ZmaUAS81sHjAdeM8594iZzQJmAfc3uu4x4O22DlikpXbvr2HuohKeWbCJrZXV9E9P4ieXD+eG/GxVTpSo1Wxyd86VA+X+6yozWw9kAVcB0/zTngLex0/uZnY1sBHY39YBi4Rqw9ZKCj4q5i8rNnOoroGzBvfiZ9eMZNrQ3qprLlGvRWPuZpYHjAMWAn38xI9zrtzMevvndMNL8hcA32/TaEWaUd/geG/9NgoKi1mwcReJ8TFcOz6bO6fmMaRPStDhibSbkJO7mSUDLwH3Oecqm7jp9DDwmHNuX1M3psxsJjATIDc3N+SARU6ksrqWFxeX8tSCYkp3H6RfaiL3X3w6t5yRQ1pSQtDhibS7kJK7mcXjJfZnnXMv+7u3mVmm32vPBLb7+ycB15vZL4A0oMHMqp1zjzd+T+fcbGA2QH5+voqiS6ts3LGPOfOL+fPSMg7U1DMxrwc/vGQYFw7vo8f/pVMLZbaMAX8E1jvnHm106DXgDuAR/+urAM65LzW69iFg3/GJXeRUNDQ4/vn5TgoKi3j/kx0kxMZw+ZhM7pwygFHZqUGHJxIRQum5TwVuA1ab2Qp/3wN4Sf1FM5sBlAA3hCVCEd/+Q3W8vKyMOfOL+WLHfjJSuvCd84dw66RcMlK0oIVIY6HMlvkIONng+XnNXPtQK2ISOUbp7gM8vaCY5xeXUlVdx+jsVB67aQyXjepHQpyGXkRORE+oSkRyzrGwaDcFhUXMW7cNM+PikX25a2oe43N76ClSkWYouUtEqa6t57UVWyiYX8z68kp6JMVz9zmD+Ork/vRTAS+RkCm5S0TYVlnNMwu8Al6799cwtE8Kj1w7iqvHZZEYHxt0eCIdjpK7BGpZyR7mFBbz1upy6p3jvNP7cNfUPM4clK6hF5FToOQu7a6mroG315TzZGExK0srSOkSxx1T8rj9zP70T1cBL5G2oOQu7WbXvkM8t7CEZz7exPaqQwzo1Y2HrxzBdROySe6ipijSlvQvSsJu7Za9zCks5tWVW6ipa+DsIRn8/Lo8zhmSQYwKeImEhZK7hEV9g2Peuq08WVjMoqLddI2P5cb8bKZPyWNwbxXwEgk3JXdpU3sP1PLCkhKemr+JzRUHyUrrygOXns5N+bmkJql2ukh7UXKXNvH59n3MmV/ES0s3c7C2nkkDevLg5cM4f5gKeIkEQcldWq2hwfHBpzt4srCIf362k4S4GK4a04/pU/MY0U8FvESCpOQuLbbvUB0vLS3jqfnFbNy5n94pXfjeBV4Br/RkFfASiQRK7hKykl0HmDO/mP9eUkrVoTrG5KTx65vHcsnITBXwEokwSu7SJOccC77YxZOFxby3YRuxZlw6KpM7p+YxLrdH0OGJyEkoucsJVdfW85flm5kzv5gNW6vo2S2Be6cN5quT+9M3NTHo8ESkGUrucozyvQd5ZsEm5i4qYc+BWoZlducX14/myjH9VMBLpANRcheccywr2cOThcW8s2YrzjkuGN6HO6cOYNKAnirgJdIBKbl3YjV1Dby5egsFhcWsKttL98Q4Zpw1gNsm9yenZ1LQ4YnIKVBy74R2VB3i2YWbeHZhCTuqDjEooxv/dvVIrh2XRTcV8BKJCvqX3Ims2byXJwuLeGNlOTX1DUwbmsGdUwfwpcG9VMBLJMoouUe5uvoG3l27jTnzi1hcvIekhFhuOSOH26fkMSgjOejwRCRMmk3uZpYDPA30BRqA2c65X5tZT+AFIA8oBm50zu0xswuAR4AEoAb4gXPu7+EJX06m4kANcxeV8syCYrbsrSanZ1d+fNkwbpyYQ/dEFfASiXah9NzrgO8555aZWQqw1MzmAdOB95xzj5jZLGAWcD+wE7jCObfFzEYC7wJZ4QlfjvfptioKCot5ZXkZ1bUNnDkwnYeuHMF5w/oQq6EXkU6j2eTunCsHyv3XVWa2Hi9ZXwVM8097CngfuN85t7zR5WuBRDPr4pw71IZxSyMNDY5/fLKdgsJiPvp8J13iYrhmXBZ3TMljWGb3oMMTkQC0aMzdzPKAccBCoI+f+HHOlZtZ7xNcch2w/ESJ3cxmAjMBcnNzWxi2AFRV1/LfS8p4akExm3YdoG/3RH5w0VBuOSOXnt0Sgg5PRAIUcnI3s2TgJeA+51xlcw+2mNkI4OfAhSc67pybDcwGyM/Pd6HGIVC8cz9z5hfz56Vl7DtUx4T+Pfj+hUO5eGRf4lU7XUQIMbmbWTxeYn/WOfeyv3ubmWX6vfZMYHuj87OBV4DbnXNftHXQnZFzjo8+38mcwmL+/sl24mKMy0f3Y/qUPMbkpAUdnohEmFBmyxjwR2C9c+7RRodeA+7AmxlzB/Cqf34a8CbwQ+dcYVsH3NkcrKnn5eVlzCks5rPt++iVnMD/OPc0vjopl97dVcBLRE4slJ77VOA2YLWZrfD3PYCX1F80sxlACXCDf+ybwGDgQTN70N93oXNuOxKyzRUHeXpBMc8vKmXvwVpG9OvOL28YwxVjMukSpwJeItK0UGbLfAScbID9vBOc/+/Av59iXJ2Sc47FxXsoKCzi3bVbAbh4ZF/unDqA/P49VMBLREKmJ1QjwKG6el5fWU5BYRFrt1SS2jWer589kNvPzCMrrWvQ4YlIB6TkHqDtVdX86eMSnlu4iZ37ajitdzI/u2Yk14zLIilBfzUi0nrKIAFYVVZBQWExb6zaQl2D49yhvblz6gCmDk7X0IuItAkl93ZSW9/AO2u2UlBYxLKSCpK7xPGVSf2ZPiWPvF7dgg5PRKKMknuY7d5fw9xFJTyzYBNbK6vpn57ET68YzvUTsklRAS8RCRMl9zDZsLWSgo+K+cuKzRyqa+Cswb342TUj+fLQ3qqdLiJhp+TehuobHO+t30ZBYTELNu4iMT6G6yZkM31KHkP6pAQdnoh0IkrubaCyupYXF5fy9IJNlOw+QL/URGZdcjo3T8whLUkFvESk/Sm5n4KNO/YdKeB1oKaeiXk9mHXJ6Vw4vA9xKuAlIgFScm8h5xwffraTgsIi3v9kBwmxMVwxph93Ts1jZFZq0OGJiABK7iE7UFPHS8s2M6ewiC927CcjpQvfOX8It07KJSOlS9DhiYgcQ8m9GaW7D/D0gmJeWFxKZXUdo7NTeeymMVw2qh8JcRp6EZHIpOR+As45FhbtpqCwiHnrtmFmXDKyL3dOzWN8rgp4iUjkU3JvpLq2ntdWbKFgfjHryyvpkRTP3ecM4rYz+5OZqgJeItJxKLkD2yqreWbBJp5bVMLu/TUM7ZPCI9eO4upxWSTGq3a6iHQ8nTq5Ly/ZQ0FhMW+tLqfeOc4f1oc7p+Zx5kAV8BKRjq3TJfeaugbeXlNOQWExK0orSOkSxx1T8rjjzDxy05OCDk9EpE10muS+a98hnltYwjMfb2J71SEG9urGw1eO4LoJ2SR36TQfg4h0ElGf1dZtqaSgsIhXV26hpq6Bs4dk8PPr8zjntAwV8BKRqBWVyb2+wTFv3VYKCotZWLSbrvGx3JjvFfAa3FsFvEQk+jWb3M0sB3ga6As0ALOdc782s57AC0AeUAzc6Jzb41/zQ2AGUA98yzn3bliiP87eA7W8sKSEp+ZvYnPFQbLSuvLApadzU34uqUmqnS4inUcoPfc64HvOuWVmlgIsNbN5wHTgPefcI2Y2C5gF3G9mw4GbgRFAP+BvZjbEOVcfnj8CfL59H3PmF/HS0s0crK1n0oCePHj5cC4Y3odYDb2ISCfUbHJ3zpUD5f7rKjNbD2QBVwHT/NOeAt4H7vf3P++cOwQUmdnnwBnAgrYOfmNJCfufvYPfVp3NBzETuXxMDtOn5jGinwp4iUjn1qIxdzPLA8YBC4E+fuLHOVduZr3907KAjxtdVubvO/69ZgIzAXJzc1scOEDKwc10qdnMEwm/oj4lm9jMr0Pa7a16LxGRaBJy5SszSwZeAu5zzlU2deoJ9rl/2eHcbOdcvnMuPyMjI9QwjpEx9Ewyf7QObn6O2PQB8LefwqPD4fX7YPuGVr2niEg0CKnnbmbxeIn9Wefcy/7ubWaW6ffaM4Ht/v4yIKfR5dnAlrYK+HgxcXFw+mXetnUNLHwCVs6FpQUw8Msw+R4YfAHEqIKjiHQezWY8857D/yOw3jn3aKNDrwF3+K/vAF5ttP9mM+tiZgOA04BFbRdyE/qOhKseh++sg3MfhB2fwHM3wuMT4OMn4FBVu4QhIhI0c+5fRkyOPcHsLOCfwGq8qZAAD+CNu78I5AIlwA3Oud3+NT8C7sKbaXOfc+7tpn5Gfn6+W7JkySn8MU6ivhbWv+Yl9rJFkJAC474Kk2ZCz4Ft//NERNqRmS11zuWf8Fhzyb09hC25N7Z5qZfk174CDXUw5CKYdDcMnAYqEiYiHZCSe2NVW2HJk962fwdkDINJ34DRN0GCCoeJSMfRVHLvfHcZU/rClx+A+9bA1b+D2Hh44z54bDjM+ynsLQs6QhGRU9b5eu7Hcw5KFsDHv4MNbwAGw67whmxyJ2vIRkQiVlM996gsHNYiZtB/irdVlMDiP8DSp2DdXyBzDEy6B0ZeC3Fdgo5URCRknW9YpilpuXDB/4LvroPLH4O6Q/CXu+GxkfCP/4CqbUFHKCISEg3LNMU52PgPb5bNZ+9CTLzXi590N2SNDzo6EenkNCzTWmYw6Fxv2/UFLJoNy/8Eq16AnElekh92hXdTVkQkgqjn3lLVlbDiWVj4e9hTBN2zYOLXYMJ0SOoZdHQi0olonns4NNTDZ3/1ZtkUfQBxiTD6Ru8GbJ/hQUcnIp2AhmXCISYWhl7ibdvX+wXLXoBlT8OAs70kP+Qi7zwRkXamnntbOrAblj0Fi/4AlWXQIw/OmOnVs0nUAiIi0rY0LNPe6utgw+veLJvSjyEhGcbeCmd8A3oNDjo6EYkSGpZpb7FxMOIab9uy3Lv5unSON9vmtAu9WTaDztXTryISNuq5t5d9271iZYv/CPu3Q6+hXunhMbdAQregoxORDkiFwyJBcm+YNgu+swau+T3Ed4U3vwePDoO//tgrfSAi0kbUcw+Kc1C6CBb+Dta9BjhvqcBJ93h1bjRkIyLN0Jh7JDKD3EnetrfML1g2B9a/Dn1HeePyI6+H+MSgIxWRDkjDMpEgNRvOf8hb+/WK33gPSL16Lzw2Av7+71BZHnSEItLBaFgmEjkHRR96D0Z98rb3INTwq2HyPZB9wt/ARKQT0rBMR2MGA8/xtt0bYdF/eQXL1vwZsvK9JD/8KhUsE5GTanZYxsyeNLPtZram0b4xZrbAzFab2etm1t3fH29mT/n715vZD8MZfKfQcyBc/B9ejflLfgEH98BLM+BXo+DD/wP7dwYdoYhEoFDG3OcAFx+37w/ALOfcKOAV4Af+/huALv7+CcA3zCyvbULt5LqkeAt5f3MJ3Prf0HuYNx7/6HBvfH7r6qAjFJEI0mxyd859COw+bvdQ4EP/9TzgusOnA93MLA7oCtQAlW0TqgAQEwNDLoTbXoF7F8G4r8Cal+GJs6DgMm+2TUN90FGKSMBaO1tmDXCl//oGIMd//WdgP1AOlAC/dM4d/x8DAGY208yWmNmSHTt2tDKMTi5jqLcc4HfXwQX/5j0I9cJX4TdjYf5/wsGKoCMUkYC0NrnfBdxrZkuBFLweOsAZQD3QDxgAfM/MBp7oDZxzs51z+c65/IyMjFaGIQB07QFTvwXfWg43PgOpOd5Tr48Ogze+Czs+DTpCEWlnrZot45zbAFwIYGZDgMv8Q7cC7zjnaoHtZlYI5AMb2yBWaU5sHAy/0tvKV3oFy5Y/A0v+CIPO82bZDDrPG9oRkajWqn/lZtbb/xoD/Bh4wj9UApxrnm7AZGBDWwQqLZQ5Bq7+f96DUV/+MWxbC89eD7+dCAtnw6F9QUcoImEUylTIucACYKiZlZnZDOAWM/sUL3FvAQr8038LJOONyS8GCpxzq8ISuYQmOQPO+QHctxqu/YO3aMjbP/CGbN55AHYXBR2hiISBnlDtjEoX+wXLXvVm1gy9FCbfDXlfUsEykQ5ET6jKsXImelvlFq++/NIC+ORN6D3Cm0s/+kavJLGIdFi6s9aZde8H5z0I31kLVz7u9dpf/5b3YNTfHoa9m4OOUERaScMycpRzUPyRX7DsLcC8GjaT74HsiRqyEYkwGpaR0JjBgC95255ir2DZsmdg7cvQb7xXY37ENRCXEHSkItIM9dylaYf2wcq53pz5XZ9Bch/InwH5d3pLB4pIYJrquSu5S2gaGuCLv3tDNp/Pg9gEb6WoyXd7c+pFpN1pWEZOXUwMnHa+t+38zOvJr3gOVj4HuWd6QzanX+49JSsigVPPXVrvYIW3iMii33tFy1JzYOLXYPztkNQz6OhEop6GZSS8Guq95QAXPgHF/4S4rjDmJq8333tY0NGJRC0Ny0h4xcTCsMu9besaL8mvmAtL58DAaTDpHjjtQhUsE2lH6rlLeOzf5T35uviPULXFWy7wjG/A2FshsXvQ0YlEBQ3LSHDqa2H9a/DxE1C2CBJSYNxX4YyvQ/qgoKMT6dCU3CUybF7qJfm1r0BDHQy5yBuXHzhNT7+KtIKSu0SWqq3ecM2SJ+HATsgY5hcsuwkSkoKOTqTDaCq56w6XtL+UvnDuj7yCZVf/DmLj4Y37vBrz834CFaVBRyjS4annLsFzDkoWwMe/gw1vAObNvJl0D+RO1pCNyEloKqRENjPoP8XbKkr8gmVPeYuJZI7xxuVHXgdxXYKOVKTD0LCMRJa0XLjw3+C76+Hyx6C2Gv5yDzw2Av7xv6FqW9ARinQIGpaRyOYcbPyHN8vms3chJh5GXuv15rPGBx2dSKA0LCMdlxkMOtfbdn0Bi2Z79WxWvQA5k7wkP+wK76asiBzR7LCMmT1pZtvNbE2jfWPMbIGZrTaz182se6Njo/1ja/3jieEKXjqZ9EFwyc+9IZuLH4F92+HPd8Kvx8A//y8c2B10hCIRo9lhGTM7G9gHPO2cG+nvWwx83zn3gZndBQxwzj1oZnHAMuA259xKM0sHKpxz9U39DA3LSKs01MNnf/Vm2RR9AHGJ3uLek+6GPiOCjk4k7E5pnrtz7kPg+C7RUOBD//U84Dr/9YXAKufcSv/aXc0ldpFWi4mFoZfAHa/BPQu8h6BWvQi/mwJPXQEb3vT+AxDphFo7W2YNcKX/+gYgx389BHBm9q6ZLTOz/3mqAYqEpM9wuPI33pDN+Q/Bro3w/K3wn+NhwW+hem/QEYq0q9Ym97uAe81sKZAC1Pj744CzgK/4X68xs/NO9AZmNtPMlpjZkh07drQyDJHjJPWEs74D314JN8yB5L7w7gPw6HB46wew8/OgIxRpF61K7s65Dc65C51zE4C5wBf+oTLgA+fcTufcAeAt4ITz1Zxzs51z+c65/IyMjNaEIXJysXEw4hqY8S7MfN9bAnBJATw+Af50PXz+N2+apUiUalVyN7Pe/tcY4MfAE/6hd4HRZpbk31w9B1jXFoGKtFq/cXDt771aNtN+COUr4U/XwW/PgMV/gJr9QUco0uZCmQo5F1gADDWzMjObAdxiZp8CG4AtQAGAc24P8CiwGFgBLHPOvRmm2EVaJqUPTJsF31kD1/we4pPgze95Bcve/RHs2RR0hCJtRk+oSuflHJQugoW/g3WvAQ6GXgqT74H+U1WwTCKenlAVOREzyJ3kbXvLvCGapXO8ypR9RsHku2Hk9RCv5/Ck41HPXaSxmgOw+kWvls2O9ZDUCwafD9n53tZnpEodSMRQz10kVAlJMGE6jL8Dij70Vov64u+w6nnveFwiZI49muyz8iE1W0M4EnHUcxdpjnOwtxTKlnjb5iWwZQXUH/KOJ/c9Ntn3GwddkgMNWToH9dxFToWZV2c+LdcrNwxQVwPb1hxN9mWL/VWkAIuB3sMhawJkT/SSfq+hEKPlE6T9qOcu0lYO7IbNS71EfzjpHy570KW716PPzvcSflY+JOvhPTk16rmLtIeknnDaBd4G0NAAu7/wh3MWe8n+o1/B4Vp6af2PTfaZo7WUoLQZJXeRcImJgV6nedvYW7x9NQe8J2QPJ/uShbDmJf/8eC/BZ/kJP3sC9Bigm7XSKkruIu0pIQn6n+lth1WWHx23L1sKy5+BRb/3jiWl+8ne3/qNh65pgYQuHYuSu0jQumdC9yu85QIB6uu8OfaNZ+d89lfAvz/Wa+ixs3N6D/cKpYk0ohuqIh1B9V7YvMzv4fvbgZ3esfgk72Zt49k53fsFG6+0i6ZuqCq5i3REzsGe4mNn52xdBfX+0gop/Y727rMneg9eJSQFGbGEgWbLiEQbM+g5wNtGXe/tqzsEW1cfOztn/Wv++bHeurKHh3KyJ0L6YM29j2LquYtEs/07j33QavMyOFTpHeuS6s3IOZzssyZAt/Rg45UWUc9dpLPq1guGXuxt4M293/npsWP3//wluAbveI8BR8fts/O96phxCcHFL62m5C7SmcTEQO/TvW3cV719h/ZB+YqjwznF//QqYwLEdvHm3h/u2WdP9MowaO59xNOwjIj8q72bj47bl/mF0uoOese6ZRyb7LPGQ5eUQMPtrDQsIyItk5rlbSOu9r6vr4Vta/1k78/Q+eQt/2SDjNOPnZ2TcTrExAYVvaCeu4i01sE9/lTMpUd7+Qf3eMcSko8WSjt8wzalT7DxRiH13EWk7XXt4a1SNfh873vnYPfGY2fnzP9PaKjzjqfmNEr2+ZA5BuK7Bhd/lFNyF5G2YQbpg7xtzE3evtqDUL7q2Nk5a1/xjsXEecsWHpmdMxF6DtTN2jbSbHI3syeBy4HtzrmR/r4xwBNAMlAMfMU5V9nomlxgHfCQc+6XYYhbRDqC+K5HFyE/rGpbo2S/GFbOhcX/5R3r2qPRjdp872ZtUs9gYu/gmh1zN7OzgX3A042S+2Lg+865D8zsLmCAc+7BRte8BDQAC0NJ7hpzF+nEGuphxyfHzs7Zvp4jhdLSBzeanaNFyhs7pTF359yHZpZ33O6hwIf+63nAu8CD/g+7GtgI7G9lvCLSmcTEQp/h3jbhDm/foSrYsvxoGeTP3/N6+KBFykPU2jH3NcCVwKvADUAOgJl1A+4HLgC+39QbmNlMYCZAbm5uK8MQkajUJQUGnO1t0GiRcj/Zb14Ci/4LFjzuHdci5f+itcn9LuA3ZvYT4DXAL0XHw8Bjzrl91sz/os652cBs8IZlWhmHiHQGxyxSfp23L5RFyhvPzulki5S3Krk75zYAFwKY2RDgMv/QJOB6M/sFkAY0mFm1c+7xNohVROSouATvhmvWePxBgH9dpHztK7B0jnfsyCLlE48m/ShepLxVyd3MejvntptZDPBjvJkzOOe+1Oich4B9Suwi0m5CWqT8sU6xSHkoUyHnAtOAXmZWBvwUSDaze/1TXgYKwhahiEhrtXSR8tgE6DsqKhYpV/kBEZHjFynfsgxqD3jHjixS7if7rAmQmBpsvD6VHxARaUoULlKunruISCgicJFyLZAtItLWmlukvHvW0adqw7RIuYZlRETa2qksUn54dk4YFylXz11EJJyaWqQ8MRXG3QYX/axVb62eu4hIUJpcpHyxVxcnDJTcRUTa04kWKQ/HjwnbO4uISGCU3EVEopCSu4hIFFJyFxGJQkruIiJRSMldRCQKKbmLiEQhJXcRkSgUEeUHzGwHsOkU3qIXsLONwmlLiqtlFFfLKK6Wica4+jvnTrhWYEQk91NlZktOVl8hSIqrZRRXyyiululscWlYRkQkCim5i4hEoWhJ7rODDuAkFFfLKK6WUVwt06niiooxdxEROVa09NxFRKQRJXcRkSgU0cndzC42s0/M7HMzm3WC42Zmv/GPrzKz8aFeG+a4vuLHs8rM5pvZmEbHis1stZmtMLM2XVswhLimmdle/2evMLOfhHptmOP6QaOY1phZvZn19I+F8/N60sy2m9makxwPqn01F1dQ7au5uIJqX83F1e7ty8xyzOwfZrbezNaa2bdPcE5425dzLiI3IBb4AhgIJAArgeHHnXMp8DZgwGRgYajXhjmuKUAP//Ulh+Pyvy8GegX0eU0D3mjNteGM67jzrwD+Hu7Py3/vs4HxwJqTHG/39hViXO3evkKMq93bVyhxBdG+gExgvP86Bfi0vfNXJPfczwA+d85tdM7VAM8DVx13zlXA087zMZBmZpkhXhu2uJxz851ze/xvPwbCs0hiC+MK07Vt/d63AHPb6Gc3yTn3IbC7iVOCaF/NxhVQ+wrl8zqZQD+v47RL+3LOlTvnlvmvq4D1QNZxp4W1fUVycs8CSht9X8a/fjgnOyeUa8MZV2Mz8P53PswBfzWzpWY2s41iaklcZ5rZSjN728xGtPDacMaFmSUBFwMvNdodrs8rFEG0r5Zqr/YVqvZuXyELqn2ZWR4wDlh43KGwtq9IXiDbTrDv+HmbJzsnlGtbK+T3NrMv4/3jO6vR7qnOuS1m1huYZ2Yb/J5He8S1DK8WxT4zuxT4C3BaiNeGM67DrgAKnXONe2Hh+rxCEUT7Clk7t69QBNG+WqLd25eZJeP9Z3Kfc67y+MMnuKTN2lck99zLgJxG32cDW0I8J5RrwxkXZjYa+ANwlXNu1+H9zrkt/tftwCt4v4K1S1zOuUrn3D7/9VtAvJn1CuXacMbVyM0c9ytzGD+vUATRvkISQPtqVkDtqyXatX2ZWTxeYn/WOffyCU4Jb/tq6xsJbbXh/VaxERjA0ZsKI4475zKOvSGxKNRrwxxXLvA5MOW4/d2AlEav5wMXt2NcfTn64NoZQIn/2QX6efnnpeKNm3Zrj8+r0c/I4+Q3CNu9fYUYV7u3rxDjavf2FUpcQbQv/8/9NPCrJs4Ja/tqsw83HBve3eRP8e4c/8jfdzdwd6MP8Lf+8dVAflPXtmNcfwD2ACv8bYm/f6D/F7USWBtAXN/0f+5KvBtxU5q6tr3i8r+fDjx/3HXh/rzmAuVALV5vaUaEtK/m4gqqfTUXV1Dtq8m4gmhfeENlDljV6O/p0vZsXyo/ICIShSJ5zF1ERFpJyV1EJAopuYuIRCEldxGRKKTkLiIShZTcRUSikJK7iEgU+v86J4Xz/px33QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16145.578125\n", + "1 11771.578125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05108.2500004160.250000
15435.0625003875.062500
25602.2656253736.265625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5108.250000 4160.250000\n", + "1 5435.062500 3875.062500\n", + "2 5602.265625 3736.265625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0126.500135.500
1128.750133.250
2129.875132.125
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 126.500 135.500\n", + "1 128.750 133.250\n", + "2 129.875 132.125" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkE0lEQVR4nO3de3Scd33n8fdP98tIsqy7LcmyLFm2LJMQ5BAb4sS5WXISu93C2WQ5DWmgIVtygG6BNmVL2LKc0gO97C707LJA27SQtEsvMUnkxCGEkIQkOFfLV8l32ZZ180WSrdvMb//4jTQjRbZ1G83Mo8/rnOdY88zzjL4aP/740W9+z/cx1lpERMRbEqJdgIiIzD2Fu4iIByncRUQ8SOEuIuJBCncREQ9KinYBAPn5+baioiLaZYiIxJU333yzy1pbMNlzMRHuFRUV7Nq1K9pliIjEFWPMscs9p2EZEREPUriLiHiQwl1ExINiYsxdRCRahoeHaWtrY2BgINqlXFZaWhqlpaUkJydPeR+Fu4gsaG1tbWRlZVFRUYExJtrlvI+1lu7ubtra2li+fPmU99OwjIgsaAMDA+Tl5cVksAMYY8jLy5v2bxYKdxFZ8GI12EfNpL74DvfBPtjxCBx7FQL+aFcjIhIz4jvc23fDr38Af9sIf7EKnvp9OPRz8I9EuzIRkSnbsWMHNTU1VFVV8c1vfnNOXjO+P1Bdth6+fAgOPgv7tsO7T8CuH0J6LtTcCbXboPImSEqNdqUiIpPy+/189rOfZefOnZSWlrJu3Tq2bt1KbW3trF43vsMdIDUL1n7MLUMXofV5F/R7n4R3/hFSs2FlA9RuhRW3QkpGtCsWERnzxhtvUFVVRWVlJQD33HMPTz75pMJ9nJQMF+K1W2FkEA6/CHu3w4GnYfc/Q3IGVN8Oq7fCys3uPwYRkaD/9tM97D11YU5fs3ZJNo/eveayz588eZKysrKxx6Wlpbz++uuz/r7eCvdwSakuwFduBv9fw9GX3Rn9vp+6s/rEVKi61QV9TYMbyhERmWeT3cd6LmbveDfcwyUmw4pNbtnybTj+WijoDzwDCUmw/CZ3xr/qLsjMj3bFIhIFVzrDjpTS0lJOnDgx9ritrY0lS5bM+nXje7bMTCQkQsVHoPHP4QvN8OmfwQ2/Bz2H4Kefh29Xw9/dBW/8X7hwOtrViojHrVu3jpaWFo4cOcLQ0BBPPPEEW7dunfXrLowz98tJSIDSerfc/qfQ/p4bo9+3HZ75olvKPuyGbmq3wqLyaFcsIh6TlJTEd77zHTZv3ozf7+eBBx5gzZrZ/wZhJhvvmW/19fU25m7W0bE/OOtmO5zZ7daVXOtCfvU2yK+KankiMjf27dvH6tWro13GVU1WpzHmTWtt/WTbL+wz9yspXOWWm74M3YdCH8T+7E/dUrgmGPRboXA1xPjlyyKysCjcpyJvBXz0C245d8IF/b7t8OI34cU/g7yq0NBNybUKehGJOoX7dC0qg/W/55bedtj/lBu6eeV/wMt/6cblV291V8curXfj+iIi80zhPhtZxbDu027p73YXS+3dDq//H/jVdyCrBFbf7cJ+2QY3U0dEZB4o3OdKZh5cd59bLp0L9bt56zF443uQkQ+rgv1ulm90c+9FRCJE4R4J6Yvgmv/olsE+aN3pPozd/RN46+8hbRHUbHFj9JWbIDkt2hWLiMco3CMt1QdrftMtw5fg0Atu6Gb/0/DujyHF51okrN7q+t6kZEa7YhGZZw888ABPPfUUhYWFNDc3z8lrKtznU3K6G5pZdSeMDMGRl2Dfky7om/8FktKh+jY3j37lZkjLjnbFIjIP7r//fh5++GHuu+++OXtNhXu0JKW4IK++De78Kzj2SrDfzVNuqmViihuyqd3qhnAyFke7YhGJkI0bN3L06NE5fU2FeyxITHI3Fam8CRq/BW1vhNogtDwLJhGW3+iGblbfDb7CaFcs4k1Nf+Tu8DaXitdC49zcXWk6FO6xJiEBym9wy+ZvwKm3Qzcfefq/wNN/4KZVjgZ9ztJoVywiMUjhHsuMgaXXueXWR+HMnlC/mx1/6Jal9aE2CIuXR7tikfgWhTPsSFG4xwtjoLjOLZv+GLpa3Nn8vu2w86tuKV7r5tGv3gYFK6NdsYhEka6Nj1f51bDxi/CZl+Dz78LtX4ekNHjhv8N318F3PwwvfMONH8ZA508Rubx7772X9evXc+DAAUpLS/nBD34w69dUy1+vOX8y1O/m+KtgA7C4MtgGYZsb4lFjM5Exavkr8SFnKXz4M27p63Bz6Pc+Cb/6rmtullMW6ndT9mE1NhPxKIW7l/kKof533HKxBw40uTH6X38fXvsb8BW5e8bWboVlH3VTMkXEE/SveaHIWAwf/IRbBi5Ay3PujP6dH8OuH0D64rDGZje5i6xEFghrLSaGhytnMnyucF+I0rJh7cfcMnQRWp93Qb/n3+Htf4DUHKhpcEM3Vbe6tgkiHpWWlkZ3dzd5eXkxGfDWWrq7u0lLm16DQX2gKiHDA3D4RTd0s/9pGDgHyZmuoVntNqi+wzVCE/GQ4eFh2traGBgYiHYpl5WWlkZpaSnJyeNbhV/pA1WFu0zOPwxHfxnsYPkU9He6qZYrbnVj9CsbXGtjEYmaWYW7MeaHwF1Ah7W2Lrju68A2IAB0APdba0+F7VMO7AW+Zq399tUKVLjHuIAfjv8q2O/mp9B7ChKSXS+c1Vvdh7KZedGuUmTBmW24bwT6gMfCwj3bWnsh+PXngFpr7UNh+/wLLvhfV7h7TCAAJ990rYr3bodzx8AkQMVHQ/1usoqjXaXIgjCree7W2peMMRUT1l0Ie5gJjP0PYYz5DeAw0D+TYiXGJSRA2Tq33P51OP1uqN/NM1+EZ77k5s/XBoN+UXm0KxZZkKY05h4M96dGz9yD674B3AecBzZZazuNMZnA88DtwBeBvsuduRtjHgQeBCgvL//QsWPHZvmjSFRZC537Q62KzwTvJrPkg8F+N1shb0V0axTxmFl/oDpZuIc99wiQZq191BjzbeANa+0/G2O+xhXCPZyGZTyo+1CoVfGpt926ojoX8rVboWCV2iCIzFKkw30Z8LS1ts4Y80ugLPjUIty4+1ettd+50usr3D3u3HH3Qeze7XDidcBCXnWoVXHJNQp6kRmY894yxphqa21L8OFWYD+AtfbGsG2+hjtzv2KwywKwqBzWf9Ytve0u6Pdth5f/Cn75F7BoWTDot8HSD6nfjcgcuGq4G2MeB24G8o0xbcCjwBZjTA3uzPwY8NDlX0EkTFYxXP+7bunvchdL7dsOr/1vePV/QdYS90Fs7VYoXw8JidGuWCQu6SImiQ2XzsHBHW7opvV58A9CZkGosVnFjZCYfNWXEVlIdIWqxJfBvlBjs5adMNwPaYtcY7PVW2HFJkhKjXaVIlGnfu4SX1J9UPcf3DJ8CVp/5oZu9j0F7/wIUrJg5WY3xbLqNkjJiHbFIjFH4S6xLTkdVt/llpEhOPILd0a//2lo/gkkZ7iAH21slpYd7YpFYoKGZSQ++Ufg2MuhxmZ9ZyAxBVbc4oZuahpdD3sRD9OYu3hbwA8n3gi1QbjQBglJsHxjqLGZryDaVYrMOYW7LBzWwqm3XMjvfRLOHnGNzco3hPrdZC+JdpUic0LhLguTta7HzWi/m879bn3pulAbhNyKqJYoMhsKdxGAzoOhVsXt77l1JdcEg34b5FdHtz6RaVK4i0zUcyQ0Rn8yeOwVrA71uylao343EvMU7iJXcr7NzaHftx2OvQpYWFwZGropuVZtECQmKdxFpqqvw02t3LsdjrwE1u/uHZtXDQUrXavi/OCfiyshKSXaFcsCpnAXmYmLPa4NQvtu6DroPpA9dzz0fEKSC/iCGsivcYFfsNL9R6CrZmUeqP2AyExkLIZr7nHLqKF+6GqBzgPQdcD92bEf9j/jzvIBMJC7LBj4o0vwjF9X0Mo8UbiLTEdKJiy51i3hRgbd3adGA390Ofxz8A+FtstaEhb4YWf8mXnz+VPIAqBwF5kLSalQVOuWcP4ROHfMDemMBn7XAXjrH1y3y1EZeePH80fDP6tEs3ZkRhTuIpGUmORuDJ63wrUsHhUIwIWTwcDfHzrj3/OvMHA+tF1qdljghwV/TrnuWCVXpHAXiYaEBFhU5pbq20LrrXUzdsYN7+x3H+y+84+h7ZLS3UVXE4d3Fi/XTU0EULiLxBZjIKvILcs3jn/uYk9w1k7Y8M7x12D3/wttk5DsfksYC/zgklcNyWnz+7NIVCncReJFxmIov8Et4Qb7QqE/esbf3uxuRG4DbhuT4G5EHj6eX1DjhnxSs+b/Z5GIU7iLxLtUHyy9zi3hhgeg59D4D3M7D7h71AaGQ9tll04yg6dG/fDjnMJdxKuS01yPnKI149f7R1wr5NHx/NEz/l2vwsil0HaZBZPP4PEVaQZPHFC4iyw0iUnuw9j8anf7wlGBAJw/ETa8Ewz+3T+BwbAZPGk5779Aq6DG/QagGTwxQ+EuIk5CgruyNncZrLwjtN5a6G1//wVaB3fA2/8Q2i45I3iWP2EGT26F+w9F5pXecRG5MmMgu8QtlTePf66/e3zodx2Aoy/De/8U2iYxBfKqJpnBU+Uu/pKIULiLyMxl5kHmBli2Yfz6gQuuB0/48M6pd2DPvwPBZoUm0c3LHzfEE5zBk5I5zz+I9yjcRWTupWVD6YfcEm74EnS3jr9Aq/MAtDwLgZHQdjnl46/Iza9xj9Nz5/fniGMKdxGZP8npULzWLeH8w9BzePzwTud+N8QzMhDazlc0YXgnGP6ZBZrBM4HCXUSiLzE5NCwTLuB3PfTDL9DqPADvPgFDvaHt0nPfP7xTsAqyly7Y0Fe4i0jsSgiOyy9eDjUNofXWQu/p91+gte+n8Nbfh7ZL8U0yg6fGzeDx+K0TFe4iEn+Mgewlbllxy/jn+rvCum0G76B1+EV49/HQNompocZr4Wf8i1d45taJCncR8ZbMfLdUfGT8+oHz0Hlw/Ayetl3Q/K+Mm8GTt+L9V+XG4a0TFe4isjCk5UDZOreEG7oI3S3jZ/B0HYQDTeNvnbiofMJtE4MzeNJy5v1HmQqFu4gsbCkZUHKNW8KNDAUbrx0Y/4Hu4V+AfzC0XVbJZWbw5M/vzzGBwl1EZDJJKVC42i3hAn44ezQ0nj8a/u/8CIb6Qttl5E1ygVaN+5xgHmbwKNxFRKYjITF068SaxtB6a4O3TtzvxvZHg3/Pv8HAudB2KVnjA7/0eli2fs7LvGq4G2N+CNwFdFhr64Lrvg5sAwJAB3C/tfaUMeZ24JtACjAEfMla+8KcVy0iEmuMgZxSt1RNuHVif+f7Z/C0Pu/O9td+PCLhbqy1V6nXbAT6gMfCwj3bWnsh+PXngFpr7UPGmA8CZ4JBXwc8a61derUi6uvr7a5du2b7s4iIxJdLZ11LhuwlM9rdGPOmtbZ+sueueuZurX3JGFMxYd2FsIeZBOcRWWvfDlu/B0gzxqRaawcREZHx0nMj1i9nxmPuxphvAPcB54FNk2zyW8Dblwt2Y8yDwIMA5eXlMy1DREQmMePbplhrv2KtLQN+BDwc/pwxZg3w58BnrrD/96y19dba+oKCgpmWISIik5iLe2L9GHeWDoAxphT4N+A+a+2hOXh9ERGZphmFuzGmOuzhVmB/cP0i4GngEWvtK7OuTkREZmQqUyEfB24G8o0xbcCjwBZjTA1uKuQx4KHg5g8DVcCfGGP+JLjuDmttx1wXLiIil3fVqZDzQVMhRUSm70pTIedizF1ERGKMwl1ExIMU7iIiHqRwFxHxIIW7iIgHKdxFRDxI4S4i4kEKdxERD1K4i4h4kMJdRMSDFO4iIh6kcBcR8SCFu4iIByncRUQ8SOEuIuJBCncREQ9SuIuIeJDCXUTEgxTuIiIepHAXEfEghbuIiAcp3EVEPEjhLiLiQQp3EREPUriLiHiQwl1ExIMU7iIiHqRwFxHxIIW7iIgHKdxFRDxI4S4i4kEKdxERD1K4i4h4kMJdRMSDFO4iIh501XA3xvzQGNNhjGkOW/d1Y8x7xph3jDHPGWOWhD33iDGm1RhzwBizOVKFi4jI5U3lzP3vgIYJ675lrf2AtfZa4CngqwDGmFrgHmBNcJ+/McYkzlm1IiIyJVcNd2vtS0DPhHUXwh5mAjb49TbgCWvtoLX2CNAKXD9HtYqIyBQlzXRHY8w3gPuA88Cm4OqlwGthm7UF1022/4PAgwDl5eUzLUNERCYx4w9UrbVfsdaWAT8CHg6uNpNtepn9v2etrbfW1hcUFMy0DBGRuDbiD0TkdWd85h7mx8DTwKO4M/WysOdKgVNz8D1EROKWtZbOvkFaz/TR2tlHy5k+Wjv6aOnoY1NNAd/6+DVz/j1nFO7GmGprbUvw4VZgf/Dr7cCPjTF/CSwBqoE3Zl2liEgcCAQsp85forUjGN5jYd7LhYGRse2y0pKoKvRxy6oCPlKVH5FarhruxpjHgZuBfGNMG+4MfYsxpgYIAMeAhwCstXuMMf8M7AVGgM9aa/0RqVxEJEpG/AGO91wcO/s+NPpnZx8Xh0KRl5eZQlWhj7uvWUJ1oY+qwiyqi3wUZqVizGSj2HPHWDvpkPi8qq+vt7t27Yp2GSIi4wyO+DnadZGWjt5xQX64s5+hsLHykpw0qgp9VBX6qC7MGvt6cWZKROszxrxpra2f7Lm5GHMXEYlrF4dGONTRT2tn79h4eGtHH8d6LuIPuBNgY6AsN4PqQh831RRQVeCjuiiLFQWZZKUlR/kneD+Fu4gsGOcvDQeDO3Qm3nKmj5PnLo1tk5RgqMjPpKY4izs/UDJ2Fr6iwEdacvxck6lwFxFPsdbS3T8UPAMPhXhrRx8dvYNj26UmJbCiwMeHluVyz7oyN6RS5GNZXibJifHfdkvhLiJxyVrL6fMDY8EdHuTnLg6PbedLTWJFoY+NKwuCY+JuXHxpbjqJCZH9UDOaFO4iEtP8AcuJsJkp4UHeHzYzJTcjmerCLBrrSoIzU9yZeHF2WsRnpsQihbuIxIShkQDHuvvHAtyNh/dyuKufoZHQzJSi7FSqCn18vL4sbIaKjzxfahSrjz0KdxGZV5eG/BzqdHPCW870jU0zPNZ9kZFAaGp2aW461aPDKQU+qorch5o56bE3MyUWKdxFJCJ6B4YnDKW4IG87e4nRy2sSEwzL8tz0woa64rE54pUFmWSkKJ5mQ++eiMxKd9/g+0K8taOP9gsDY9ukJCVQmZ/JNaWL+Nh1oZkpFXmZpCTF/8yUWKRwF5GrstZy5sLguCs1R0O8p39obLuMlESqCn1sqMobu1qzutBH2eIMT89MiUUKdxEZEwhY2s5eGrtSczTED3X00TsYanyVk55MdaGPO2qLgmfhbjilJDuNBIV4TFC4iyxAw/4Ax7ov0trRG9a5sI/DXX0MDIdmphRkpVJd6OM3r1tKdaGPFcGz8XxfyoKcXhhPFO4iHjYw7OdwZz8tHb1jnQtbO/o40tU/bmbK0kXpbjhlRd7YeHhVQRY5GZqZEq8U7iIe0Dc4Mm5GymiQn+i5yGiGJxhYlpdJVaGP22qLxi70WVHgIzNVUeA1+hsViSNn+4cm3MnHfcB5+nxoZkpyoqEy30fdkhx+49ql42amxFPjK5kdhbtIjLHW0tk7OHaF5miYH+rso6svNDMlPTmRFYWZ3FCZN+5KzfLFGSR5oPGVzI7CXSRKAgHLyXOXaO3sozXsSs2Wjj56J9ySrbrQxy2rCt1FPkU+qgp8LF2UrpkpclkKd5EIG/EHOBZsfDV+XLyfS8Ohxlf5PndLtm3XLhm7UrO60EfBPNySTbxH4S4yRwZH/Bzp6h93J5/RmSnht2RbkpPGikIf914fPjPFR26Eb8kmC4vCXWSa+gdHONQZ3rnQjYcf6+4fm5liDJQvdj1Tbl5VMHYmHqu3ZBPvUbiLXEYgYGk+dZ69py6Mu9x+4i3Zludnsqo4i7s/UDJ2kU9lgWamSHQp3EXC+AOWXx/tYUdzOzua28eaX43ekq2+Ipd7CsrcUEphFsvyMjxxSzbxHoW7LHjD/gC/OtRNU3M7O/e209U3RGpSAjetLODLdTXUL1vs+Vuyifco3GVBGhj283JLF03N7Ty/7wznLw2TkZLIplWFNNYVs6mmUFdtSlzT0SsLxsWhEX5xoJOm5nZe2N9B3+AIWWlJ3L66iIa6YjauLNA4uXiGwl08rXdgmBf2d9C0u50XD3YwMBwgNyOZO9eW0Li2mA0r8nWzCPEkhbt4zrmLQ+zce4am5nZebuliyB+gICuVj3+ojMa6Yq5fvliX54vnKdzFEzp7B3lur5vh8qtD3YwELEsXpfPb65fRWFfMdeW5ulRfFhSFu8St0+cvsaO5nabmdnYd7SFgoSIvg0/fWEljXTEfKM3RZfuyYCncJa6c6LlIU/Npmprbefv4OQBWFvl4+JZqGuuKWVWcpUAXQeEucaC1o48dwUDfc+oCAGuWZPPFO1bSUFdCVaEvyhWKxB6Fu8Qcay3723tp2u0CvaWjD4APli/ij7esomFNCeV5GVGuUiS2KdwlJlhrea/tPE3N7exoPs3R7osYA+sqFvO1u2vZXFdMSU56tMsUiRsKd4maQMDy5vGzNO1u59k97Zw8d4nEBMOGFXn87sZK7qgtpiArNdplisQlhbvMqxF/gDeO9Lgz9D3tdPYOkpKYwI3V+Xzhtmpury1iUYb6movM1lXD3RjzQ+AuoMNaWxdc9y3gbmAIOAT8jrX2nDEmGfg+cF3wtR+z1v5ZpIqX+DA0EuCVQ13s2N3Ozn1n6OkfIi05gZtXFtK4tphbVhWqx7nIHJvKmfvfAd8BHgtbtxN4xFo7Yoz5c+AR4A+BjwOp1tq1xpgMYK8x5nFr7dG5LVti3cCwn5cOdo415uodGMGXmsQtwcZcN9UUkJGiXxxFIuWq/7qstS8ZYyomrHsu7OFrwMdGnwIyjTFJQDruzP7C3JQqsa5/cISfH+igqbmdn+/v4OKQn5z0ZDavKaaxrpiPVOWrMZfIPJmLU6cHgH8Kfv0TYBtwGsgAft9a2zPZTsaYB4EHAcrLy+egDImG85eG+dk+18flpYOdDI4EyMtMYdu1S2msK2b9ijzdzEIkCmYV7saYrwAjwI+Cq64H/MASIBf4pTHmeWvt4Yn7Wmu/B3wPoL6+3s6mDplfPf1D7NzrLvt/pbWLYb+lODuNe68vp6GumHUVi3VjC5Eom3G4G2M+ifug9VZr7Wg4/ydgh7V2GOgwxrwC1APvC3eJLx0XBnh2jwv014/04A9YSnPTuX9DBY1rS7i2dJEac4nEkBmFuzGmAfcB6k3W2othTx0HbjHG/CNuWOYG4K9nW6REx8lzl2jafZodze28efws1kJlQSYP3VRJY10Ja5Zkq4+LSIyaylTIx4GbgXxjTBvwKG52TCqwM/iP+zVr7UPAd4G/BZoBA/yttfa9yJQukXC0q3/sKtF3284DsKo4i8/fWs2WtSVUF/oU6CJxYCqzZe6dZPUPLrNtH246pMSRljO9PLO7nabm0+xv7wXgA6U5fLmhhsa6EpbnZ0a5QhGZLk00XoCstew5dSHYC/00hzr7Aahflst/vXM1DXXFlOaqMZdIPFO4LxCBgOWdtnNjgX6i5xIJBj68PI9Pbqhg85piirLTol2miMwRhbuH+QOWXUeDfVya22m/MEByomHDinw+e3MVt9cWkedTYy4RL1K4e8ywP8Brh7tpam7nuT3tdPUNkZKUwMbqAr7cUMOtq4vISVcfFxGvU7h7wOCIn5dbusb6uJy7OExGSiKbagppqCtm06pCfKn6qxZZSPQvPk5dGvLzi4Ouj8sL+zroHRwhKzWJ22qLaKgr5qaVBerjIrKAKdzjSO/AMC/s72BHczsvHujk0rCf3IxkGtcW01hXwoaqPFKTFOgionCPeecvDrNz3xmadp/mly1dDPkDFGSl8lsfWkpjXQkfXr6YJDXmEpEJFO4xqKtvkOf2nKGp+TS/OtTNSMCyJCeNT9xQzpa1JVxXnqvGXCJyRQr3GNF+foAdzadpam7n10d7CFhYlpfBp25cTmNdCdeU5uiyfxGZMoV7FJ3ouTh2UdFbx88BUF3o4+FNVTTUlbC6JEuBLiIzonCfZ4c6+8YCvfmku0lVbUk2f3D7ShrXFlNVmBXlCkXECxTuEWat5UCwMdeO5tMcPNMHwLVli3ikcRUNdcUsy1NjLhGZWwr3CLDWsvvk+bHL/o909WMMrFu2mK/eVUtDXTFLFqVHu0wR8TCF+xwJBCxvHT87Fugnz10iMcGwvjKPT310OXesKaIwS425RGR+KNxnYcQf4I2jPewIBnpH7yDJiYaPVuXz+duquX11EbmZKdEuU0QWIIX7NA2NBHj1UBc7mtt5bu8ZevqHSEtO4KaVBTTWlXDL6kKy09SYS0SiS+E+BQPDfl462MmOYGOuCwMjZKYkcsvqIhrrirm5poCMFL2VIhI7lEiX0T84wosHOmlqPs3P93fQP+QnO8015mqsK+HG6nw15hKRmKVwD3NhYJif7TtD0+52fnGwk8GRAHmZKWy9dgkNdSWsr8wjJUl9XEQk9i34cD/bP8TOva6Py8utXQz7LYVZqdyzroyGuhLWVeSqMZeIxJ0FGe4dvQM8u+cMO5pP89rhHvwBy9JF6XxyfQWNa4v5YFkuCWrMJSJxbMGE+8lzl4JTFk+z69hZrIXK/Ew+s7GSxroS6pZmq4+LiHiGp8P9WHc/Tc3tNDW38+6JcwDUFGXxuVuq2bK2hJVFPgW6iHiS58K95UzvWKDvO+0ac61dmsOXNtfQWFdMZYEvyhWKiERe3Ie7tZa9py8EOy2209rhGnNdV76Ir2xZTUNdMWWLM6JcpYjI/IrrcH+v7RwP//htjvdcJMHA9csX89s3rGHzmmKKc9THRUQWrrgO97LcDJbnZ/Kfb17B7bVF5PtSo12SiEhMiOtwz81M4e8fuD7aZYiIxBxdnSMi4kEKdxERD1K4i4h4kMJdRMSDFO4iIh6kcBcR8SCFu4iIByncRUQ8yFhro10DxphO4NgsXiIf6JqjcuaS6poe1TU9qmt6vFjXMmttwWRPxES4z5YxZpe1tj7adUykuqZHdU2P6pqehVaXhmVERDxI4S4i4kFeCffvRbuAy1Bd06O6pkd1Tc+CqssTY+4iIjKeV87cRUQkjMJdRMSDYjrcjTENxpgDxphWY8wfTfK8Mcb8z+Dz7xljrpvqvhGu6xPBet4zxrxqjLkm7Lmjxpjdxph3jDG75rmum40x54Pf+x1jzFenum+E6/pSWE3Nxhi/MWZx8LlIvl8/NMZ0GGOaL/N8tI6vq9UVrePranVF6/i6Wl3zfnwZY8qMMT83xuwzxuwxxnx+km0ie3xZa2NyARKBQ0AlkAK8C9RO2GYL0AQY4Abg9anuG+G6NgC5wa8bR+sKPj4K5Efp/boZeGom+0ayrgnb3w28EOn3K/jaG4HrgObLPD/vx9cU65r342uKdc378TWVuqJxfAElwHXBr7OAg/OdX7F85n490GqtPWytHQKeALZN2GYb8Jh1XgMWGWNKprhvxOqy1r5qrT0bfPgaUDpH33tWdUVo37l+7XuBx+foe1+RtfYloOcKm0Tj+LpqXVE6vqbyfl1OVN+vCebl+LLWnrbWvhX8uhfYByydsFlEj69YDvelwImwx228/8253DZT2TeSdYX7FO5/51EWeM4Y86Yx5sE5qmk6da03xrxrjGkyxqyZ5r6RrAtjTAbQAPxL2OpIvV9TEY3ja7rm6/iaqvk+vqYsWseXMaYC+CDw+oSnInp8xfINss0k6ybO27zcNlPZd6am/NrGmE24f3wfDVv9EWvtKWNMIbDTGLM/eOYxH3W9hetF0WeM2QL8O1A9xX0jWdeou4FXrLXhZ2GRer+mIhrH15TN8/E1FdE4vqZj3o8vY4wP95/JF6y1FyY+Pckuc3Z8xfKZextQFva4FDg1xW2msm8k68IY8wHg+8A2a2336Hpr7angnx3Av+F+BZuXuqy1F6y1fcGvnwGSjTH5U9k3knWFuYcJvzJH8P2aimgcX1MShePrqqJ0fE3HvB5fxphkXLD/yFr7r5NsEtnja64/SJirBfdbxWFgOaEPFdZM2OZOxn8g8cZU941wXeVAK7BhwvpMICvs61eBhnmsq5jQhWvXA8eD711U36/gdjm4cdPM+Xi/wr5HBZf/gHDej68p1jXvx9cU65r342sqdUXj+Ar+3I8Bf32FbSJ6fM3ZmxuJBfdp8kHcJ8dfCa57CHgo7A38bvD53UD9lfadx7q+D5wF3gkuu4LrK4N/Ue8Ce6JQ18PB7/su7oO4DVfad77qCj6+H3hiwn6Rfr8eB04Dw7izpU/FyPF1tbqidXxdra5oHV9XrCsaxxduqMwC74X9PW2Zz+NL7QdERDwolsfcRURkhhTuIiIepHAXEfEghbuIiAcp3EVEPEjhLiLiQQp3EREP+v99sYclQietXQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning_1)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning['entry'],loss['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/test2.ipynb b/learningAgents/naive_policy_gradient/test/test2.ipynb new file mode 100644 index 0000000..827420f --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/test2.ipynb @@ -0,0 +1,8850 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1_000_000, discountFactor =0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 actions: tensor([3, 1, 3])\n", + "loss= tensor(8.5972, grad_fn=) , return= 16156.8125\n", + "discReturns/1000= tensor([6.4214, 6.5907, 5.5786])\n", + "actionProbs tensor([[0.3286, 0.3392, 0.3316, 0.3318],\n", + " [0.3324, 0.3323, 0.3339, 0.3332],\n", + " [0.3390, 0.3285, 0.3346, 0.3350]], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 3, 2])\n", + "loss= tensor(10.7480, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[0.2824, 0.1744, 0.5969, 0.3024],\n", + " [0.3242, 0.3013, 0.2806, 0.3261],\n", + " [0.3934, 0.5243, 0.1225, 0.3715]], grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([2, 0, 1])\n", + "loss= tensor(7.8665, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([6.4173, 6.5452, 5.5306])\n", + "actionProbs tensor([[0.2951, 0.2840, 0.4037, 0.2193],\n", + " [0.3287, 0.3363, 0.3281, 0.3129],\n", + " [0.3762, 0.3797, 0.2682, 0.4677]], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([0, 3, 2])\n", + "loss= tensor(8.4739, grad_fn=) , return= 16071.078125\n", + "discReturns/1000= tensor([6.4077, 6.4770, 5.6023])\n", + "actionProbs tensor([[0.3476, 0.3499, 0.3314, 0.2664],\n", + " [0.3336, 0.3336, 0.3341, 0.3275],\n", + " [0.3188, 0.3165, 0.3345, 0.4061]], grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([0, 2, 0])\n", + "loss= tensor(8.5201, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([6.4073, 6.4753, 5.5689])\n", + "actionProbs tensor([[0.3301, 0.3539, 0.3489, 0.2708],\n", + " [0.3341, 0.3316, 0.3342, 0.3313],\n", + " [0.3357, 0.3145, 0.3169, 0.3980]], grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([2, 3, 3])\n", + "loss= tensor(7.9764, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([6.4197, 6.5570, 5.6348])\n", + "actionProbs tensor([[0.3087, 0.3108, 0.4016, 0.2911],\n", + " [0.3351, 0.3348, 0.3288, 0.3303],\n", + " [0.3562, 0.3544, 0.2696, 0.3787]], grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([3, 3, 3])\n", + "loss= tensor(8.6772, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.3256, 0.3489, 0.3854, 0.3115],\n", + " [0.3412, 0.3360, 0.3336, 0.3221],\n", + " [0.3332, 0.3151, 0.2811, 0.3665]], grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([3, 3, 3])\n", + "loss= tensor(8.6203, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.2421, 0.2995, 0.3926, 0.3446],\n", + " [0.3361, 0.3361, 0.3369, 0.3209],\n", + " [0.4218, 0.3644, 0.2705, 0.3346]], grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([3, 2, 2])\n", + "loss= tensor(8.6322, grad_fn=) , return= 16196.25\n", + "discReturns/1000= tensor([6.4225, 6.5962, 5.6210])\n", + "actionProbs tensor([[1.5882e-05, 2.5634e-04, 2.1196e-04, 4.6841e-01],\n", + " [5.5804e-03, 2.0103e-02, 1.8710e-02, 3.0317e-01],\n", + " [9.9440e-01, 9.7964e-01, 9.8108e-01, 2.2842e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([3, 3, 3])\n", + "loss= tensor(3.3007, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.8612e-07, 8.0090e-05, 2.1400e-05, 7.3793e-02],\n", + " [1.1663e-03, 1.0852e-02, 5.6212e-03, 2.2881e-01],\n", + " [9.9883e-01, 9.8907e-01, 9.9436e-01, 6.9740e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6138, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.5829e-07, 2.6023e-05, 1.4338e-05, 6.2198e-02],\n", + " [6.7807e-04, 7.3606e-03, 5.3987e-03, 2.1184e-01],\n", + " [9.9932e-01, 9.9261e-01, 9.9459e-01, 7.2596e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.5315, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[6.3690e-08, 2.1721e-06, 1.8790e-06, 5.8306e-02],\n", + " [3.1426e-04, 1.6998e-03, 1.5175e-03, 1.9521e-01],\n", + " [9.9969e-01, 9.9830e-01, 9.9848e-01, 7.4649e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.3721, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[3.0246e-08, 2.9942e-06, 6.2092e-07, 2.2259e-01],\n", + " [1.3759e-04, 1.3827e-03, 5.9490e-04, 2.9462e-01],\n", + " [9.9986e-01, 9.9861e-01, 9.9940e-01, 4.8279e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.2460, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.4388e-07, 1.4764e-05, 8.8994e-06, 7.0919e-01],\n", + " [7.5112e-04, 6.0675e-03, 4.9288e-03, 2.0312e-01],\n", + " [9.9925e-01, 9.9392e-01, 9.9506e-01, 8.7698e-02]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([3, 3, 3])\n", + "loss= tensor(3.5155, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.7373e-06, 1.2727e-05, 9.9829e-05, 9.2344e-02],\n", + " [6.8391e-03, 9.1174e-03, 2.1370e-02, 2.4354e-01],\n", + " [9.9316e-01, 9.9087e-01, 9.7853e-01, 6.6412e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6073, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[7.2063e-08, 1.4871e-06, 5.4445e-06, 5.7875e-02],\n", + " [1.0088e-03, 3.5806e-03, 5.7766e-03, 1.9221e-01],\n", + " [9.9899e-01, 9.9642e-01, 9.9422e-01, 7.4992e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.2634, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[2.3458e-08, 1.3848e-06, 3.8618e-06, 6.5873e-01],\n", + " [6.5929e-04, 3.6538e-03, 5.0796e-03, 2.0044e-01],\n", + " [9.9934e-01, 9.9634e-01, 9.9492e-01, 1.4083e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.5754, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[9.1633e-08, 3.2491e-06, 6.3334e-06, 1.4541e-01],\n", + " [1.9192e-03, 7.9411e-03, 8.8721e-03, 2.4797e-01],\n", + " [9.9808e-01, 9.9206e-01, 9.9112e-01, 6.0662e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6652, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[8.7142e-09, 5.7233e-07, 2.0734e-06, 7.3182e-02],\n", + " [1.0711e-03, 5.5944e-03, 7.0187e-03, 1.7468e-01],\n", + " [9.9893e-01, 9.9441e-01, 9.9298e-01, 7.5214e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([3, 3, 3])\n", + "loss= tensor(4.6548, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.3689e-09, 1.4372e-07, 7.7128e-07, 5.2753e-01],\n", + " [1.4396e-03, 6.2140e-03, 7.3469e-03, 1.6393e-01],\n", + " [9.9856e-01, 9.9379e-01, 9.9265e-01, 3.0855e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([3, 3, 3])\n", + "loss= tensor(3.1496, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[6.8194e-11, 3.5509e-09, 3.7815e-07, 9.7024e-02],\n", + " [7.4135e-04, 2.4334e-03, 7.2527e-03, 1.2607e-01],\n", + " [9.9926e-01, 9.9757e-01, 9.9275e-01, 7.7691e-01]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "21000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.9890, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[2.4957e-13, 7.0856e-10, 5.4380e-07, 4.6608e-01],\n", + " [3.6818e-04, 5.4993e-03, 1.4038e-02, 5.9072e-02],\n", + " [9.9963e-01, 9.9450e-01, 9.8596e-01, 4.7485e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6375, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.9071e-18, 2.9552e-15, 1.4249e-12, 5.2359e-04],\n", + " [1.1079e-06, 9.8759e-06, 3.3254e-05, 1.0676e-02],\n", + " [1.0000e+00, 9.9999e-01, 9.9997e-01, 9.8880e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6188, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.8160e-20, 1.5631e-17, 6.2342e-15, 4.3529e-05],\n", + " [6.7610e-08, 6.8124e-07, 2.1015e-06, 2.8402e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9712e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6150, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.1741e-22, 6.0180e-19, 1.9990e-16, 8.3961e-06],\n", + " [1.0992e-08, 1.1309e-07, 3.2102e-07, 1.1235e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9887e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6137, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.6349e-23, 4.3728e-20, 1.2745e-17, 2.2390e-06],\n", + " [2.6384e-09, 2.6724e-08, 7.2393e-08, 5.4415e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9945e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6131, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.8834e-24, 4.1747e-21, 1.0797e-18, 6.4847e-07],\n", + " [7.4794e-10, 7.3190e-09, 1.9164e-08, 2.8236e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9972e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6128, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.1702e-25, 4.5489e-22, 1.0513e-19, 1.9951e-07],\n", + " [2.2860e-10, 2.1289e-09, 5.3839e-09, 1.4996e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9985e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6127, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[9.6553e-26, 5.3853e-23, 1.1272e-20, 6.4691e-08],\n", + " [7.3224e-11, 6.4136e-10, 1.5694e-09, 8.1081e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9992e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6126, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4280e-26, 6.9684e-24, 1.3631e-21, 2.2850e-08],\n", + " [2.4239e-11, 1.9774e-10, 4.6941e-10, 4.4414e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9996e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6126, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.2357e-27, 9.5202e-25, 1.7646e-22, 8.4435e-09],\n", + " [8.2161e-12, 6.1965e-11, 1.4308e-10, 2.4566e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9998e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.6423e-28, 1.3466e-25, 2.3902e-23, 3.2023e-09],\n", + " [2.8345e-12, 1.9648e-11, 4.4254e-11, 1.3690e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.0123e-29, 1.6581e-26, 3.0050e-24, 1.1724e-09],\n", + " [8.5735e-13, 5.6297e-12, 1.3259e-11, 7.6426e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.5761e-30, 2.2692e-27, 4.0730e-25, 4.2561e-10],\n", + " [2.7162e-13, 1.6986e-12, 4.1303e-12, 4.2544e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.2227e-30, 3.3221e-28, 5.7755e-26, 1.5748e-10],\n", + " [8.9462e-14, 5.3186e-13, 1.3159e-12, 2.3862e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.0729e-31, 5.1493e-29, 8.5921e-27, 6.0657e-11],\n", + " [3.0096e-14, 1.7012e-13, 4.2481e-13, 1.3546e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.7310e-32, 8.3595e-30, 1.3158e-27, 2.3438e-11],\n", + " [1.0473e-14, 5.5746e-14, 1.3883e-13, 7.6901e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[6.6903e-33, 1.4119e-30, 2.0903e-28, 9.4402e-12],\n", + " [3.6922e-15, 1.8844e-14, 4.6065e-14, 4.4068e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.0833e-33, 4.2062e-31, 5.7528e-29, 4.7857e-12],\n", + " [1.5681e-15, 7.4584e-15, 1.7252e-14, 2.5816e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.3734e-33, 8.7529e-31, 1.1683e-28, 6.4321e-12],\n", + " [1.1013e-15, 4.9850e-15, 1.0875e-14, 1.5901e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "40000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.0015e-31, 5.9655e-29, 1.2531e-26, 4.7397e-10],\n", + " [7.4240e-16, 3.0552e-15, 6.6707e-15, 1.5914e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "41000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.9873e-30, 2.4235e-27, 9.0478e-25, 7.2979e-09],\n", + " [4.0457e-16, 1.6398e-15, 2.9693e-15, 9.7609e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6147, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[2.0055e-26, 8.1203e-24, 5.0581e-21, 1.4950e-04],\n", + " [8.8139e-14, 2.0936e-13, 7.1152e-13, 8.6945e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9976e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6146, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[9.4274e-26, 3.6564e-23, 1.8969e-20, 2.4114e-04],\n", + " [2.6514e-13, 6.4059e-13, 2.0255e-12, 1.4879e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9961e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6147, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.2787e-25, 4.5322e-23, 1.9264e-20, 1.5595e-04],\n", + " [2.9997e-13, 6.7166e-13, 1.9108e-12, 1.1545e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9973e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6147, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.6320e-25, 5.2615e-23, 1.8190e-20, 9.4858e-05],\n", + " [3.2291e-13, 6.6516e-13, 1.6934e-12, 8.5278e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9982e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.3016e-25, 3.6331e-23, 9.7064e-21, 3.5978e-05],\n", + " [2.3154e-13, 4.1376e-13, 9.0716e-13, 4.2732e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9992e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[2.2762e-25, 5.5365e-23, 1.0154e-20, 2.1103e-05],\n", + " [3.5141e-13, 5.8887e-13, 1.0934e-12, 4.1770e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9994e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.5066e-26, 1.8331e-23, 2.4647e-21, 5.8317e-06],\n", + " [1.5379e-13, 2.9672e-13, 5.1798e-13, 2.1936e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9997e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[6.4663e-26, 1.5262e-23, 1.9625e-21, 4.4625e-06],\n", + " [1.3677e-13, 2.5809e-13, 4.4273e-13, 1.8447e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9998e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[3.1816e-26, 6.9637e-24, 7.9317e-22, 1.9920e-06],\n", + " [7.9254e-14, 1.4695e-13, 2.4362e-13, 1.0745e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6148, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[2.0470e-26, 4.4672e-24, 5.5397e-22, 2.1002e-06],\n", + " [6.1377e-14, 1.1628e-13, 2.0750e-13, 1.1920e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.5966, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.7470e-22, 3.6839e-20, 9.7810e-18, 1.5452e-02],\n", + " [3.7168e-11, 1.2197e-10, 5.0884e-10, 2.2963e-02],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.6158e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6602, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.5258e-22, 4.0124e-20, 7.0588e-18, 1.1410e-02],\n", + " [4.9757e-11, 1.4744e-10, 5.2348e-10, 2.1620e-02],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.6697e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6408, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.8273e-22, 3.1113e-20, 3.5620e-18, 5.1045e-03],\n", + " [5.0078e-11, 1.3584e-10, 4.0033e-10, 1.4648e-02],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.8025e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6081, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[5.2250e-22, 3.2030e-20, 2.1185e-18, 2.5598e-03],\n", + " [8.1195e-11, 1.7004e-10, 3.6710e-10, 1.1610e-02],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.8583e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6112, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[5.4141e-22, 1.6291e-20, 4.7984e-19, 1.4872e-03],\n", + " [8.7602e-11, 1.3350e-10, 1.8220e-10, 9.1650e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.8935e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6137, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.6464e-22, 4.7960e-21, 8.0554e-20, 5.8641e-04],\n", + " [5.4853e-11, 7.2635e-11, 8.1047e-11, 5.7412e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9367e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.0738, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.8691e-27, 1.9781e-25, 1.2452e-21, 9.9400e-01],\n", + " [5.8825e-13, 2.1512e-12, 3.9599e-11, 5.6991e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 2.9822e-04]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "59000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.0733, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[4.8424e-30, 3.4585e-28, 4.0191e-23, 9.9976e-01],\n", + " [4.8354e-14, 1.5089e-13, 9.0972e-12, 2.3453e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.3764e-06]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.0737, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.8777e-30, 1.1759e-28, 3.3625e-24, 9.9992e-01],\n", + " [3.0546e-14, 8.9629e-14, 2.5763e-12, 8.1645e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.9947e-07]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "61000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.0737, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.2329e-30, 7.3419e-29, 2.6653e-24, 9.9995e-01],\n", + " [2.4882e-14, 7.1238e-14, 2.2975e-12, 4.7615e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 7.3821e-08]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6173, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.2428e-16, 5.4426e-19, 1.1395e-19, 6.0320e-05],\n", + " [6.4070e-07, 8.8627e-08, 1.3839e-08, 2.8990e-03],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9704e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6138, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.6640e-18, 5.6356e-21, 1.1191e-21, 8.4603e-06],\n", + " [4.2868e-08, 5.9147e-09, 8.4791e-10, 8.3519e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9916e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6131, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.1529e-19, 4.3584e-22, 8.9382e-23, 2.4855e-06],\n", + " [9.1362e-09, 1.3237e-09, 1.8871e-10, 3.8797e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9961e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6128, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.3482e-20, 4.5172e-23, 9.6586e-24, 8.4316e-07],\n", + " [2.3014e-09, 3.4660e-10, 4.9776e-11, 1.9638e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9980e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6127, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.0078e-21, 5.4506e-24, 1.2119e-24, 3.0772e-07],\n", + " [6.3221e-10, 9.7885e-11, 1.4202e-11, 1.0362e-04],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9990e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6126, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.1509e-22, 7.0941e-25, 1.6510e-25, 1.1655e-07],\n", + " [1.8361e-10, 2.8906e-11, 4.2489e-12, 5.6081e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9994e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[6.0079e-23, 9.7317e-26, 2.3145e-26, 4.5222e-08],\n", + " [5.5113e-11, 8.7740e-12, 1.2996e-12, 3.0823e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9997e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[9.0559e-24, 1.3978e-26, 3.5313e-27, 1.7882e-08],\n", + " [1.6891e-11, 2.7133e-12, 4.0858e-13, 1.7112e-05],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9998e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4082e-24, 2.0991e-27, 5.1479e-28, 7.1969e-09],\n", + " [5.2565e-12, 8.5205e-13, 1.2734e-13, 9.5711e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.2375e-25, 3.2064e-28, 1.5914e-28, 2.9086e-09],\n", + " [1.6534e-12, 2.6960e-13, 4.7012e-14, 5.3814e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.6233e-26, 4.9814e-29, 1.6749e-28, 1.1903e-09],\n", + " [5.2413e-13, 8.5377e-14, 2.1259e-14, 3.0378e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[6.0195e-27, 8.3778e-30, 7.0729e-30, 5.0994e-10],\n", + " [1.6803e-13, 2.7586e-14, 4.5082e-15, 1.7221e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.3908e-27, 1.9039e-30, 5.0544e-31, 2.0618e-10],\n", + " [6.6118e-14, 1.1053e-14, 1.3870e-15, 9.8805e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.4481e-28, 9.3874e-31, 1.2025e-31, 1.1008e-10],\n", + " [3.0795e-14, 5.5739e-15, 5.8589e-16, 5.7094e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5887e-28, 4.6031e-31, 2.8797e-32, 4.1960e-11],\n", + " [1.5845e-14, 3.1508e-15, 2.8278e-16, 3.2636e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.2130e-29, 2.1514e-31, 6.0983e-33, 1.5508e-11],\n", + " [7.8280e-15, 1.6891e-15, 1.3220e-16, 1.8806e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "78000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.4475e-29, 2.3883e-31, 4.9154e-33, 1.3756e-11],\n", + " [4.3354e-15, 1.0485e-15, 7.6219e-17, 1.1493e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[8.3994e-30, 1.1124e-31, 1.6827e-33, 5.5961e-12],\n", + " [2.1868e-15, 5.6889e-16, 3.8875e-17, 6.3054e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.3113e-29, 3.2348e-31, 5.7587e-33, 6.5808e-12],\n", + " [2.4269e-15, 1.0088e-15, 7.3743e-17, 5.9587e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "81000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.1732e-29, 1.2504e-31, 4.3971e-33, 3.9116e-12],\n", + " [2.2302e-15, 1.1576e-15, 1.3110e-16, 5.9551e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.8684e-30, 5.2519e-32, 4.6627e-34, 1.5016e-12],\n", + " [1.7309e-15, 1.6430e-15, 1.5096e-16, 6.0270e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.5110e-29, 1.2370e-32, 4.3814e-35, 2.2260e-13],\n", + " [2.2945e-15, 2.6768e-15, 2.2243e-16, 5.0896e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5531e-29, 7.3333e-34, 3.5366e-37, 4.8166e-14],\n", + " [1.4154e-15, 7.7630e-16, 3.7224e-17, 4.5317e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6127e-29, 7.5802e-34, 3.6583e-37, 4.8422e-14],\n", + " [1.4285e-15, 7.8366e-16, 3.7632e-17, 4.5261e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.3835e-29, 6.6002e-34, 3.1704e-37, 4.9812e-14],\n", + " [1.3705e-15, 7.5028e-16, 3.5768e-17, 4.6535e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.4956e-29, 7.0715e-34, 3.4007e-37, 4.9833e-14],\n", + " [1.3976e-15, 7.6530e-16, 3.6589e-17, 4.6251e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.4000e-29, 9.8438e-34, 4.5667e-37, 6.4257e-14],\n", + " [1.7625e-15, 8.9945e-16, 4.2141e-17, 5.2574e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.6820e-29, 1.1194e-33, 5.2367e-37, 5.9158e-14],\n", + " [1.8724e-15, 9.6147e-16, 4.5367e-17, 5.0668e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.4606e-29, 9.8015e-34, 4.4903e-37, 6.3654e-14],\n", + " [1.7711e-15, 8.9183e-16, 4.1523e-17, 5.2494e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.2360e-29, 1.4315e-33, 7.0003e-37, 5.9446e-14],\n", + " [2.0407e-15, 1.0812e-15, 5.2251e-17, 5.1341e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.9414e-29, 6.6677e-34, 2.8304e-37, 6.6143e-14],\n", + " [1.5134e-15, 7.1712e-16, 3.1978e-17, 5.3563e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6889e-29, 5.2409e-34, 2.1186e-37, 6.5500e-14],\n", + " [1.3715e-15, 6.2469e-16, 2.7112e-17, 5.3518e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.0275e-29, 2.4301e-34, 8.4747e-38, 6.5187e-14],\n", + " [1.0216e-15, 4.1354e-16, 1.6554e-17, 5.3194e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.1126e-29, 2.5734e-34, 9.1760e-38, 6.2970e-14],\n", + " [1.0396e-15, 4.2134e-16, 1.7064e-17, 5.3053e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[5.8224e-30, 9.5969e-35, 2.8464e-38, 6.2221e-14],\n", + " [7.2019e-16, 2.5070e-16, 9.1913e-18, 5.2319e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "97000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[3.2065e-30, 3.7761e-35, 9.5308e-39, 6.1571e-14],\n", + " [5.1122e-16, 1.5337e-16, 5.1546e-18, 5.1912e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.9563e-30, 3.1358e-35, 7.9720e-39, 5.9314e-14],\n", + " [4.8116e-16, 1.3913e-16, 4.6909e-18, 5.1675e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[8.0543e-31, 4.7623e-36, 8.6052e-40, 6.5490e-14],\n", + " [2.4658e-16, 5.3376e-17, 1.5001e-18, 5.2474e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[5.4635e-31, 2.6503e-36, 4.6041e-40, 6.5054e-14],\n", + " [2.0538e-16, 4.0440e-17, 1.1126e-18, 5.2442e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "101000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[3.0203e-31, 1.0959e-36, 1.6918e-40, 6.7644e-14],\n", + " [1.5440e-16, 2.6475e-17, 6.8287e-19, 5.3014e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.2709e-31, 3.0078e-37, 3.7045e-41, 7.5843e-14],\n", + " [1.0309e-16, 1.4519e-17, 3.3016e-19, 5.4757e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[8.1421e-32, 1.5067e-37, 1.6457e-41, 7.8565e-14],\n", + " [8.7862e-17, 1.1230e-17, 2.3726e-19, 5.4934e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.8873e-37, 4.7602e-42, 4.2039e-45, 1.9790e-12],\n", + " [2.7513e-16, 4.6195e-18, 1.9904e-19, 4.9710e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.9999e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.7906e-38, 2.1033e-42, 2.8026e-45, 6.4944e-13],\n", + " [7.8344e-17, 2.4211e-18, 1.1836e-19, 2.2332e-06],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6862e-38, 1.1028e-42, 1.4013e-45, 1.7954e-13],\n", + " [3.0328e-17, 1.4663e-18, 8.0054e-20, 9.6521e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.9353e-39, 6.8243e-43, 1.4013e-45, 4.3357e-14],\n", + " [1.5323e-17, 1.0117e-18, 6.0479e-20, 4.0732e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.7913e-39, 5.0026e-43, 1.4013e-45, 1.0318e-14],\n", + " [9.5287e-18, 7.7581e-19, 4.9788e-20, 1.7708e-07],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.1908e-39, 3.2931e-43, 0.0000e+00, 2.5508e-15],\n", + " [7.6201e-18, 6.7524e-19, 4.5302e-20, 8.2816e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.5676e-39, 2.4102e-43, 0.0000e+00, 5.9536e-16],\n", + " [7.3417e-18, 6.5218e-19, 4.5018e-20, 3.9248e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.8935e-39, 1.6115e-43, 0.0000e+00, 1.0157e-16],\n", + " [7.3779e-18, 7.1442e-19, 5.3493e-20, 1.5934e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6522e-39, 1.3452e-43, 0.0000e+00, 3.7066e-17],\n", + " [7.3918e-18, 7.3682e-19, 5.6928e-20, 9.6029e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6087e-39, 1.2892e-43, 0.0000e+00, 3.0270e-17],\n", + " [7.3930e-18, 7.3652e-19, 5.7016e-20, 8.6855e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6064e-39, 1.2892e-43, 0.0000e+00, 2.9921e-17],\n", + " [7.3932e-18, 7.3650e-19, 5.7021e-20, 8.6362e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6057e-39, 1.2752e-43, 0.0000e+00, 2.9937e-17],\n", + " [7.3937e-18, 7.3653e-19, 5.7024e-20, 8.6384e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "116000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6038e-39, 1.2752e-43, 0.0000e+00, 2.9754e-17],\n", + " [7.3938e-18, 7.3654e-19, 5.7030e-20, 8.6120e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6183e-39, 1.2892e-43, 0.0000e+00, 3.1109e-17],\n", + " [7.3925e-18, 7.3571e-19, 5.6897e-20, 8.8068e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.5864e-39, 1.2612e-43, 0.0000e+00, 2.9128e-17],\n", + " [7.3958e-18, 7.3630e-19, 5.7007e-20, 8.5183e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6573e-39, 1.3452e-43, 0.0000e+00, 3.2232e-17],\n", + " [7.3874e-18, 7.3513e-19, 5.6828e-20, 8.9761e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6511e-39, 1.3312e-43, 0.0000e+00, 3.0789e-17],\n", + " [7.3869e-18, 7.3514e-19, 5.6884e-20, 8.7795e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "121000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6290e-39, 1.3032e-43, 0.0000e+00, 3.0619e-17],\n", + " [7.3904e-18, 7.3522e-19, 5.6875e-20, 8.7478e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.4394e-39, 1.0790e-43, 0.0000e+00, 2.8643e-17],\n", + " [7.4241e-18, 7.3841e-19, 5.7075e-20, 8.3820e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.4349e-39, 1.0510e-43, 0.0000e+00, 2.8183e-17],\n", + " [7.4592e-18, 7.4011e-19, 5.7031e-20, 8.3129e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6571e-39, 1.3312e-43, 0.0000e+00, 3.1732e-17],\n", + " [7.4034e-18, 7.3119e-19, 5.6300e-20, 8.9222e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5408e-39, 1.1631e-43, 0.0000e+00, 3.1216e-17],\n", + " [7.4834e-18, 7.3825e-19, 5.6699e-20, 8.7826e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.5243e-39, 1.1070e-43, 0.0000e+00, 3.1139e-17],\n", + " [7.5767e-18, 7.4862e-19, 5.7495e-20, 8.7414e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6025e-39, 1.2051e-43, 0.0000e+00, 3.3686e-17],\n", + " [7.5059e-18, 7.3852e-19, 5.6759e-20, 9.1374e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.2208e-39, 2.5083e-43, 0.0000e+00, 5.4811e-17],\n", + " [1.0739e-17, 8.4081e-19, 6.2721e-20, 1.3324e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[5.8640e-39, 3.5313e-43, 0.0000e+00, 8.4189e-17],\n", + " [1.8742e-17, 1.0775e-18, 7.6623e-20, 1.8911e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[3.0615e-39, 2.0599e-43, 0.0000e+00, 6.5303e-17],\n", + " [1.0849e-17, 8.2122e-19, 6.1223e-20, 1.4536e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[9.8355e-39, 3.0969e-43, 0.0000e+00, 1.8091e-16],\n", + " [3.5533e-17, 1.2629e-18, 8.3663e-20, 3.2818e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.1029e-39, 6.4460e-44, 0.0000e+00, 2.3127e-17],\n", + " [4.5117e-18, 3.6069e-19, 2.2465e-20, 7.7436e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.0282e-39, 5.7453e-44, 0.0000e+00, 2.4178e-17],\n", + " [4.3360e-18, 3.4153e-19, 2.1213e-20, 7.9291e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.1359e-39, 8.6881e-44, 0.0000e+00, 5.1547e-17],\n", + " [8.7586e-18, 3.9836e-19, 2.1838e-20, 1.4774e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "135000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.0055e-39, 4.4842e-44, 0.0000e+00, 3.8171e-17],\n", + " [4.7736e-18, 2.9060e-19, 1.7042e-20, 1.0952e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.5148e-39, 4.2039e-44, 0.0000e+00, 6.1914e-17],\n", + " [7.9626e-18, 3.2346e-19, 1.7569e-20, 1.6192e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[7.5151e-40, 8.4078e-45, 0.0000e+00, 5.4501e-17],\n", + " [8.2618e-18, 1.8038e-19, 7.1660e-21, 1.7649e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.5659e-39, 1.1210e-44, 0.0000e+00, 1.0605e-16],\n", + " [1.9358e-17, 2.3194e-19, 8.1877e-21, 3.0974e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[6.0086e-41, 0.0000e+00, 0.0000e+00, 1.3005e-17],\n", + " [1.5720e-18, 4.4167e-20, 1.3951e-21, 6.6579e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[9.8429e-41, 1.4013e-45, 0.0000e+00, 1.8478e-17],\n", + " [2.6743e-18, 5.4302e-20, 1.6037e-21, 9.1709e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "141000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[8.4285e-41, 0.0000e+00, 0.0000e+00, 1.8488e-17],\n", + " [2.4418e-18, 5.0433e-20, 1.5008e-21, 8.9810e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.0390e-40, 0.0000e+00, 0.0000e+00, 2.6222e-17],\n", + " [3.4685e-18, 5.4218e-20, 1.5309e-21, 1.1809e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[2.1544e-40, 0.0000e+00, 0.0000e+00, 6.2788e-17],\n", + " [8.9921e-18, 6.9300e-20, 1.7026e-21, 2.3589e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[5.5245e-41, 0.0000e+00, 0.0000e+00, 3.6247e-17],\n", + " [5.8156e-18, 3.4379e-20, 6.5319e-22, 1.8018e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[8.9188e-41, 0.0000e+00, 0.0000e+00, 6.2231e-17],\n", + " [1.0676e-17, 4.0313e-20, 7.0394e-22, 2.7684e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4896e-41, 0.0000e+00, 0.0000e+00, 1.1819e-17],\n", + " [1.8565e-18, 1.5014e-20, 2.4675e-22, 8.5666e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.3951e-41, 0.0000e+00, 0.0000e+00, 1.2753e-17],\n", + " [1.8846e-18, 1.4452e-20, 2.3622e-22, 8.9691e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.6240e-41, 0.0000e+00, 0.0000e+00, 1.9420e-17],\n", + " [2.6818e-18, 1.5117e-20, 2.3329e-22, 1.2205e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6167, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[1.2640e-40, 0.0000e+00, 0.0000e+00, 9.3251e-17],\n", + " [2.4981e-17, 3.9981e-20, 4.5771e-22, 4.5085e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.7071, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4076e-31, 2.1052e-41, 6.3479e-43, 2.4593e-05],\n", + " [3.3831e-11, 1.6656e-16, 2.8445e-17, 6.4203e-02],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 9.3577e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.1055e-38, 2.3770e-40, 1.0650e-43, 1.5637e-13],\n", + " [2.7834e-15, 1.7154e-17, 2.9404e-19, 7.3951e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.0633e-38, 2.2259e-40, 9.9492e-44, 1.2535e-13],\n", + " [2.8592e-15, 1.8412e-17, 3.0808e-19, 5.9124e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.0560e-38, 2.1572e-40, 9.6690e-44, 1.1453e-13],\n", + " [3.0047e-15, 2.0552e-17, 3.3874e-19, 5.8804e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "154000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.1691e-39, 2.8880e-40, 2.0179e-43, 9.9402e-14],\n", + " [2.3882e-15, 4.5686e-17, 8.4324e-19, 5.8455e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.2951e-39, 2.8714e-40, 3.0408e-43, 7.4446e-14],\n", + " [2.5122e-15, 8.5294e-17, 1.7224e-18, 5.5241e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[6.3100e-41, 7.7409e-41, 4.5122e-43, 4.5472e-14],\n", + " [1.6626e-15, 1.2417e-16, 4.8170e-18, 5.5286e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[3.5775e-42, 2.0113e-41, 3.7835e-43, 1.9918e-14],\n", + " [1.7161e-15, 2.0246e-16, 1.1775e-17, 5.7496e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6535e-43, 6.5945e-42, 1.4854e-43, 4.5869e-15],\n", + " [2.4718e-15, 3.9677e-16, 2.2406e-17, 5.3915e-08],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 2.2421e-44, 1.4013e-45, 1.5701e-16],\n", + " [6.3377e-20, 1.8617e-18, 2.4358e-19, 3.9182e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 4.2039e-45, 0.0000e+00, 3.6972e-17],\n", + " [1.9796e-21, 3.1146e-19, 5.3898e-20, 1.3000e-09],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "161000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 1.4013e-45, 0.0000e+00, 1.2919e-17],\n", + " [2.0771e-22, 9.6441e-20, 2.0043e-20, 5.9030e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 5.7820e-18],\n", + " [4.6104e-23, 4.5958e-20, 1.0848e-20, 3.3229e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 3.3776e-18],\n", + " [2.2572e-23, 3.4786e-20, 8.8804e-21, 2.5130e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 2.2604e-18],\n", + " [2.1924e-23, 3.7911e-20, 9.9234e-21, 2.4621e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 1.1932e-18],\n", + " [2.0925e-23, 4.3163e-20, 1.1772e-20, 2.3830e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 4.4360e-19],\n", + " [2.0675e-23, 5.5935e-20, 1.6157e-20, 2.2702e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 1.4013e-45, 0.0000e+00, 8.8888e-20],\n", + " [2.2481e-23, 7.2445e-20, 2.2818e-20, 1.6437e-10],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 1.4013e-45, 0.0000e+00, 1.9164e-20],\n", + " [1.9074e-23, 5.7219e-20, 1.9817e-20, 9.1859e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 1.4013e-45, 0.0000e+00, 1.0385e-20],\n", + " [1.6896e-23, 4.6934e-20, 1.7603e-20, 6.0078e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 7.0065e-45, 1.4013e-45, 1.0274e-20],\n", + " [1.5576e-23, 3.9897e-20, 1.6105e-20, 4.3965e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 3.5032e-44, 4.2039e-45, 1.3996e-20],\n", + " [1.4897e-23, 3.4995e-20, 1.5158e-20, 3.4766e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 1.6395e-43, 1.5414e-44, 2.1318e-20],\n", + " [1.4806e-23, 3.1736e-20, 1.4722e-20, 2.8995e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "173000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 7.6651e-43, 6.5861e-44, 3.4579e-20],\n", + " [1.5319e-23, 2.9822e-20, 1.4789e-20, 2.4964e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 2.9806e-42, 2.4242e-43, 4.7838e-20],\n", + " [1.6505e-23, 2.9254e-20, 1.5453e-20, 2.1414e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[0.0000e+00, 7.8655e-42, 6.0396e-43, 4.0423e-20],\n", + " [1.7601e-23, 3.0685e-20, 1.6572e-20, 1.5193e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "176000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4013e-45, 1.3255e-41, 9.9072e-43, 2.6027e-20],\n", + " [1.8913e-23, 3.3285e-20, 1.8076e-20, 1.0709e-11],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "177000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4013e-45, 1.8857e-41, 1.4013e-42, 1.5866e-20],\n", + " [2.0763e-23, 3.6762e-20, 2.0099e-20, 7.7878e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "178000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4013e-45, 2.5389e-41, 1.8861e-42, 1.0062e-20],\n", + " [2.2654e-23, 4.0252e-20, 2.2160e-20, 5.8969e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "179000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.8026e-45, 3.2725e-41, 2.4397e-42, 6.5470e-21],\n", + " [2.4530e-23, 4.3663e-20, 2.4216e-20, 4.5872e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "180000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[2.8026e-45, 4.0719e-41, 3.0534e-42, 4.3624e-21],\n", + " [2.6370e-23, 4.6964e-20, 2.6243e-20, 3.6467e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "181000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.2039e-45, 4.9174e-41, 3.7148e-42, 2.9865e-21],\n", + " [2.8128e-23, 5.0084e-20, 2.8191e-20, 2.9584e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "182000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[4.2039e-45, 5.7925e-41, 4.4099e-42, 2.1079e-21],\n", + " [2.9794e-23, 5.3024e-20, 3.0051e-20, 2.4483e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "183000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.6052e-45, 6.6825e-41, 5.1259e-42, 1.5372e-21],\n", + " [3.1352e-23, 5.5759e-20, 3.1801e-20, 2.0656e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "184000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[5.6052e-45, 7.5721e-41, 5.8504e-42, 1.1571e-21],\n", + " [3.2797e-23, 5.8287e-20, 3.3441e-20, 1.7746e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "185000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[7.0065e-45, 8.4539e-41, 6.5763e-42, 8.9681e-22],\n", + " [3.4128e-23, 6.0609e-20, 3.4958e-20, 1.5494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "186000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[8.4078e-45, 9.3325e-41, 7.3050e-42, 7.1371e-22],\n", + " [3.5363e-23, 6.2758e-20, 3.6377e-20, 1.3723e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "187000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[8.4078e-45, 1.0199e-40, 8.0308e-42, 5.8067e-22],\n", + " [3.6509e-23, 6.4748e-20, 3.7698e-20, 1.2300e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "188000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[8.6881e-44, 7.6976e-41, 5.8869e-42, 8.6214e-21],\n", + " [2.5185e-22, 8.7766e-20, 4.8330e-20, 8.9408e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "189000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.2331e-43, 1.0684e-40, 8.2242e-42, 4.2162e-21],\n", + " [2.8037e-22, 9.8426e-20, 5.4710e-20, 6.1374e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "190000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.4994e-43, 1.2739e-40, 9.8581e-42, 2.9073e-21],\n", + " [2.9771e-22, 1.0480e-19, 5.8599e-20, 5.0460e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "191000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0370e-41, 2.6274e-21],\n", + " [3.0286e-22, 1.0667e-19, 5.9753e-20, 4.7838e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "192000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3478e-40, 1.0455e-41, 2.5861e-21],\n", + " [3.0370e-22, 1.0698e-19, 5.9947e-20, 4.7441e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "193000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3465e-40, 1.0445e-41, 2.5910e-21],\n", + " [3.0357e-22, 1.0693e-19, 5.9919e-20, 4.7488e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "194000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3494e-40, 1.0468e-41, 2.5798e-21],\n", + " [3.0385e-22, 1.0702e-19, 5.9974e-20, 4.7380e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "195000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3504e-40, 1.0476e-41, 2.5759e-21],\n", + " [3.0392e-22, 1.0705e-19, 5.9990e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "196000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3540e-40, 1.0506e-41, 2.5620e-21],\n", + " [3.0422e-22, 1.0716e-19, 6.0058e-20, 4.7208e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "197000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0483e-41, 2.5722e-21],\n", + " [3.0400e-22, 1.0708e-19, 6.0007e-20, 4.7306e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "198000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3453e-40, 1.0434e-41, 2.5951e-21],\n", + " [3.0349e-22, 1.0689e-19, 5.9894e-20, 4.7529e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "199000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0416e-41, 2.6041e-21],\n", + " [3.0329e-22, 1.0682e-19, 5.9853e-20, 4.7615e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "200000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5695e-43, 1.3343e-40, 1.0343e-41, 2.6382e-21],\n", + " [3.0256e-22, 1.0657e-19, 5.9686e-20, 4.7941e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "201000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0469e-41, 2.5791e-21],\n", + " [3.0385e-22, 1.0702e-19, 5.9974e-20, 4.7373e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "202000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3475e-40, 1.0452e-41, 2.5864e-21],\n", + " [3.0369e-22, 1.0696e-19, 5.9937e-20, 4.7444e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "203000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3492e-40, 1.0466e-41, 2.5801e-21],\n", + " [3.0382e-22, 1.0701e-19, 5.9969e-20, 4.7383e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "204000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0462e-41, 2.5821e-21],\n", + " [3.0379e-22, 1.0699e-19, 5.9959e-20, 4.7402e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "205000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3515e-40, 1.0485e-41, 2.5715e-21],\n", + " [3.0401e-22, 1.0708e-19, 6.0011e-20, 4.7302e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "206000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3451e-40, 1.0433e-41, 2.5959e-21],\n", + " [3.0348e-22, 1.0689e-19, 5.9888e-20, 4.7535e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "207000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0463e-41, 2.5813e-21],\n", + " [3.0382e-22, 1.0701e-19, 5.9963e-20, 4.7396e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "208000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3485e-40, 1.0459e-41, 2.5832e-21],\n", + " [3.0376e-22, 1.0698e-19, 5.9952e-20, 4.7412e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "209000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3587e-40, 1.0545e-41, 2.5439e-21],\n", + " [3.0463e-22, 1.0729e-19, 6.0144e-20, 4.7031e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "210000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3632e-40, 1.0581e-41, 2.5272e-21],\n", + " [3.0501e-22, 1.0743e-19, 6.0229e-20, 4.6868e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "211000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3495e-40, 1.0468e-41, 2.5791e-21],\n", + " [3.0384e-22, 1.0701e-19, 5.9963e-20, 4.7373e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "212000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0461e-41, 2.5822e-21],\n", + " [3.0378e-22, 1.0699e-19, 5.9954e-20, 4.7404e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "213000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3616e-40, 1.0569e-41, 2.5332e-21],\n", + " [3.0487e-22, 1.0738e-19, 6.0200e-20, 4.6928e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "214000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3547e-40, 1.0511e-41, 2.5592e-21],\n", + " [3.0429e-22, 1.0717e-19, 6.0069e-20, 4.7181e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "215000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3584e-40, 1.0542e-41, 2.5451e-21],\n", + " [3.0462e-22, 1.0728e-19, 6.0139e-20, 4.7043e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "216000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3517e-40, 1.0486e-41, 2.5703e-21],\n", + " [3.0403e-22, 1.0708e-19, 6.0009e-20, 4.7289e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "217000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3488e-40, 1.0462e-41, 2.5812e-21],\n", + " [3.0380e-22, 1.0699e-19, 5.9956e-20, 4.7393e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "218000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3442e-40, 1.0424e-41, 2.5984e-21],\n", + " [3.0339e-22, 1.0685e-19, 5.9868e-20, 4.7558e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "219000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3533e-40, 1.0500e-41, 2.5642e-21],\n", + " [3.0417e-22, 1.0713e-19, 6.0040e-20, 4.7230e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "220000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3439e-40, 1.0421e-41, 2.5997e-21],\n", + " [3.0338e-22, 1.0685e-19, 5.9864e-20, 4.7573e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "221000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0482e-41, 2.5720e-21],\n", + " [3.0400e-22, 1.0707e-19, 6.0000e-20, 4.7303e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "222000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3483e-40, 1.0458e-41, 2.5832e-21],\n", + " [3.0375e-22, 1.0698e-19, 5.9947e-20, 4.7413e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "223000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0417e-41, 2.6022e-21],\n", + " [3.0333e-22, 1.0683e-19, 5.9853e-20, 4.7594e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "224000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3585e-40, 1.0542e-41, 2.5446e-21],\n", + " [3.0460e-22, 1.0728e-19, 6.0135e-20, 4.7040e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "225000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3516e-40, 1.0485e-41, 2.5709e-21],\n", + " [3.0402e-22, 1.0708e-19, 6.0005e-20, 4.7293e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "226000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3560e-40, 1.0521e-41, 2.5541e-21],\n", + " [3.0438e-22, 1.0721e-19, 6.0089e-20, 4.7130e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "227000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3543e-40, 1.0507e-41, 2.5606e-21],\n", + " [3.0426e-22, 1.0716e-19, 6.0058e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "228000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3567e-40, 1.0527e-41, 2.5513e-21],\n", + " [3.0447e-22, 1.0723e-19, 6.0106e-20, 4.7103e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "229000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3576e-40, 1.0535e-41, 2.5479e-21],\n", + " [3.0454e-22, 1.0726e-19, 6.0122e-20, 4.7070e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "230000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3608e-40, 1.0562e-41, 2.5354e-21],\n", + " [3.0482e-22, 1.0736e-19, 6.0181e-20, 4.6949e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "231000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3501e-40, 1.0473e-41, 2.5760e-21],\n", + " [3.0390e-22, 1.0703e-19, 5.9981e-20, 4.7342e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "232000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3455e-40, 1.0435e-41, 2.5935e-21],\n", + " [3.0352e-22, 1.0690e-19, 5.9894e-20, 4.7513e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "233000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3533e-40, 1.0499e-41, 2.5641e-21],\n", + " [3.0418e-22, 1.0713e-19, 6.0042e-20, 4.7227e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "234000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3460e-40, 1.0438e-41, 2.5917e-21],\n", + " [3.0356e-22, 1.0691e-19, 5.9903e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "235000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3415e-40, 1.0400e-41, 2.6091e-21],\n", + " [3.0317e-22, 1.0677e-19, 5.9817e-20, 4.7663e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "236000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3421e-40, 1.0406e-41, 2.6072e-21],\n", + " [3.0323e-22, 1.0679e-19, 5.9828e-20, 4.7644e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "237000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3443e-40, 1.0424e-41, 2.5985e-21],\n", + " [3.0341e-22, 1.0686e-19, 5.9868e-20, 4.7559e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "238000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3438e-40, 1.0420e-41, 2.6003e-21],\n", + " [3.0336e-22, 1.0684e-19, 5.9859e-20, 4.7577e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "239000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0473e-41, 2.5757e-21],\n", + " [3.0390e-22, 1.0703e-19, 5.9978e-20, 4.7339e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "240000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3539e-40, 1.0503e-41, 2.5621e-21],\n", + " [3.0423e-22, 1.0715e-19, 6.0053e-20, 4.7208e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "241000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3586e-40, 1.0542e-41, 2.5444e-21],\n", + " [3.0462e-22, 1.0728e-19, 6.0135e-20, 4.7036e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "242000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3548e-40, 1.0511e-41, 2.5586e-21],\n", + " [3.0431e-22, 1.0717e-19, 6.0066e-20, 4.7175e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "243000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3459e-40, 1.0438e-41, 2.5922e-21],\n", + " [3.0354e-22, 1.0691e-19, 5.9901e-20, 4.7499e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "244000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3584e-40, 1.0541e-41, 2.5449e-21],\n", + " [3.0461e-22, 1.0728e-19, 6.0135e-20, 4.7043e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "245000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3521e-40, 1.0489e-41, 2.5687e-21],\n", + " [3.0407e-22, 1.0708e-19, 6.0012e-20, 4.7272e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "246000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3457e-40, 1.0435e-41, 2.5934e-21],\n", + " [3.0354e-22, 1.0690e-19, 5.9892e-20, 4.7512e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "247000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3600e-40, 1.0555e-41, 2.5389e-21],\n", + " [3.0474e-22, 1.0732e-19, 6.0161e-20, 4.6982e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "248000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3551e-40, 1.0513e-41, 2.5573e-21],\n", + " [3.0433e-22, 1.0718e-19, 6.0069e-20, 4.7161e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "249000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3522e-40, 1.0489e-41, 2.5684e-21],\n", + " [3.0408e-22, 1.0709e-19, 6.0016e-20, 4.7269e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "250000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3524e-40, 1.0490e-41, 2.5674e-21],\n", + " [3.0410e-22, 1.0709e-19, 6.0016e-20, 4.7260e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "251000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3448e-40, 1.0427e-41, 2.5965e-21],\n", + " [3.0344e-22, 1.0687e-19, 5.9873e-20, 4.7539e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "252000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3422e-40, 1.0406e-41, 2.6063e-21],\n", + " [3.0324e-22, 1.0679e-19, 5.9824e-20, 4.7636e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "253000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0462e-41, 2.5800e-21],\n", + " [3.0381e-22, 1.0699e-19, 5.9952e-20, 4.7381e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "254000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3447e-40, 1.0427e-41, 2.5968e-21],\n", + " [3.0343e-22, 1.0686e-19, 5.9873e-20, 4.7544e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "255000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3524e-40, 1.0490e-41, 2.5669e-21],\n", + " [3.0409e-22, 1.0710e-19, 6.0020e-20, 4.7253e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "256000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3606e-40, 1.0559e-41, 2.5353e-21],\n", + " [3.0480e-22, 1.0734e-19, 6.0172e-20, 4.6948e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "257000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0451e-41, 2.5850e-21],\n", + " [3.0369e-22, 1.0695e-19, 5.9925e-20, 4.7430e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "258000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3465e-40, 1.0440e-41, 2.5896e-21],\n", + " [3.0358e-22, 1.0692e-19, 5.9899e-20, 4.7474e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "259000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0462e-41, 2.5798e-21],\n", + " [3.0380e-22, 1.0699e-19, 5.9952e-20, 4.7380e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "260000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0472e-41, 2.5751e-21],\n", + " [3.0391e-22, 1.0703e-19, 5.9974e-20, 4.7335e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "261000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3509e-40, 1.0478e-41, 2.5724e-21],\n", + " [3.0397e-22, 1.0705e-19, 5.9989e-20, 4.7309e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "262000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3530e-40, 1.0494e-41, 2.5644e-21],\n", + " [3.0416e-22, 1.0711e-19, 6.0027e-20, 4.7231e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "263000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3416e-40, 1.0402e-41, 2.6081e-21],\n", + " [3.0318e-22, 1.0677e-19, 5.9813e-20, 4.7652e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "264000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3550e-40, 1.0511e-41, 2.5567e-21],\n", + " [3.0432e-22, 1.0717e-19, 6.0066e-20, 4.7155e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "265000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3556e-40, 1.0515e-41, 2.5545e-21],\n", + " [3.0435e-22, 1.0719e-19, 6.0073e-20, 4.7135e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "266000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3455e-40, 1.0434e-41, 2.5924e-21],\n", + " [3.0352e-22, 1.0689e-19, 5.9888e-20, 4.7501e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "267000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3460e-40, 1.0438e-41, 2.5910e-21],\n", + " [3.0356e-22, 1.0690e-19, 5.9901e-20, 4.7488e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "268000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0403e-41, 2.6068e-21],\n", + " [3.0320e-22, 1.0677e-19, 5.9817e-20, 4.7639e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "269000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3493e-40, 1.0463e-41, 2.5783e-21],\n", + " [3.0383e-22, 1.0700e-19, 5.9956e-20, 4.7365e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "270000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3539e-40, 1.0503e-41, 2.5608e-21],\n", + " [3.0423e-22, 1.0714e-19, 6.0047e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "271000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3458e-40, 1.0434e-41, 2.5919e-21],\n", + " [3.0354e-22, 1.0689e-19, 5.9890e-20, 4.7497e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "272000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0445e-41, 2.5876e-21],\n", + " [3.0363e-22, 1.0692e-19, 5.9908e-20, 4.7455e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "273000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3548e-40, 1.0510e-41, 2.5572e-21],\n", + " [3.0430e-22, 1.0716e-19, 6.0060e-20, 4.7161e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "274000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0475e-41, 2.5735e-21],\n", + " [3.0394e-22, 1.0704e-19, 5.9981e-20, 4.7316e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "275000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3541e-40, 1.0503e-41, 2.5599e-21],\n", + " [3.0424e-22, 1.0714e-19, 6.0044e-20, 4.7187e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "276000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3436e-40, 1.0417e-41, 2.5997e-21],\n", + " [3.0336e-22, 1.0683e-19, 5.9850e-20, 4.7571e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "277000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0448e-41, 2.5857e-21],\n", + " [3.0369e-22, 1.0694e-19, 5.9919e-20, 4.7436e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "278000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3465e-40, 1.0440e-41, 2.5887e-21],\n", + " [3.0360e-22, 1.0691e-19, 5.9901e-20, 4.7465e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "279000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0455e-41, 2.5823e-21],\n", + " [3.0375e-22, 1.0696e-19, 5.9936e-20, 4.7404e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "280000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0497e-41, 2.5622e-21],\n", + " [3.0420e-22, 1.0712e-19, 6.0036e-20, 4.7211e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "281000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3554e-40, 1.0513e-41, 2.5551e-21],\n", + " [3.0435e-22, 1.0718e-19, 6.0064e-20, 4.7140e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "282000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3483e-40, 1.0455e-41, 2.5817e-21],\n", + " [3.0375e-22, 1.0697e-19, 5.9937e-20, 4.7399e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "283000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3520e-40, 1.0486e-41, 2.5675e-21],\n", + " [3.0406e-22, 1.0708e-19, 6.0007e-20, 4.7261e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "284000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3478e-40, 1.0451e-41, 2.5833e-21],\n", + " [3.0371e-22, 1.0695e-19, 5.9926e-20, 4.7413e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "285000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3500e-40, 1.0469e-41, 2.5754e-21],\n", + " [3.0389e-22, 1.0702e-19, 5.9963e-20, 4.7337e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "286000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0471e-41, 2.5746e-21],\n", + " [3.0392e-22, 1.0702e-19, 5.9970e-20, 4.7329e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "287000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3514e-40, 1.0482e-41, 2.5695e-21],\n", + " [3.0402e-22, 1.0706e-19, 5.9994e-20, 4.7279e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "288000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3475e-40, 1.0448e-41, 2.5846e-21],\n", + " [3.0370e-22, 1.0694e-19, 5.9919e-20, 4.7425e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "289000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3546e-40, 1.0507e-41, 2.5574e-21],\n", + " [3.0429e-22, 1.0715e-19, 6.0049e-20, 4.7162e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "290000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3531e-40, 1.0494e-41, 2.5635e-21],\n", + " [3.0415e-22, 1.0711e-19, 6.0022e-20, 4.7221e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "291000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3462e-40, 1.0438e-41, 2.5892e-21],\n", + " [3.0358e-22, 1.0690e-19, 5.9894e-20, 4.7471e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "292000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3491e-40, 1.0462e-41, 2.5781e-21],\n", + " [3.0382e-22, 1.0699e-19, 5.9952e-20, 4.7364e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "293000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3498e-40, 1.0468e-41, 2.5753e-21],\n", + " [3.0388e-22, 1.0701e-19, 5.9959e-20, 4.7335e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "294000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3393e-40, 1.0382e-41, 2.6158e-21],\n", + " [3.0298e-22, 1.0669e-19, 5.9762e-20, 4.7725e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "295000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3463e-40, 1.0438e-41, 2.5891e-21],\n", + " [3.0359e-22, 1.0690e-19, 5.9897e-20, 4.7468e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "296000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0454e-41, 2.5816e-21],\n", + " [3.0376e-22, 1.0696e-19, 5.9934e-20, 4.7399e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "297000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3526e-40, 1.0490e-41, 2.5650e-21],\n", + " [3.0412e-22, 1.0709e-19, 6.0011e-20, 4.7235e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "298000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0473e-41, 2.5726e-21],\n", + " [3.0394e-22, 1.0703e-19, 5.9972e-20, 4.7311e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "299000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3541e-40, 1.0503e-41, 2.5589e-21],\n", + " [3.0424e-22, 1.0714e-19, 6.0042e-20, 4.7176e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "300000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3517e-40, 1.0482e-41, 2.5682e-21],\n", + " [3.0405e-22, 1.0706e-19, 5.9994e-20, 4.7266e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "301000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3463e-40, 1.0438e-41, 2.5885e-21],\n", + " [3.0358e-22, 1.0690e-19, 5.9894e-20, 4.7465e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "302000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0473e-41, 2.5720e-21],\n", + " [3.0394e-22, 1.0703e-19, 5.9974e-20, 4.7303e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "303000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3442e-40, 1.0420e-41, 2.5966e-21],\n", + " [3.0342e-22, 1.0684e-19, 5.9853e-20, 4.7542e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "304000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0480e-41, 2.5696e-21],\n", + " [3.0401e-22, 1.0705e-19, 5.9989e-20, 4.7280e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "305000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0454e-41, 2.5809e-21],\n", + " [3.0375e-22, 1.0696e-19, 5.9930e-20, 4.7389e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "306000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3543e-40, 1.0504e-41, 2.5579e-21],\n", + " [3.0426e-22, 1.0714e-19, 6.0044e-20, 4.7169e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "307000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0479e-41, 2.5698e-21],\n", + " [3.0400e-22, 1.0705e-19, 5.9985e-20, 4.7285e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "308000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3424e-40, 1.0406e-41, 2.6032e-21],\n", + " [3.0327e-22, 1.0678e-19, 5.9819e-20, 4.7606e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "309000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0471e-41, 2.5736e-21],\n", + " [3.0392e-22, 1.0701e-19, 5.9967e-20, 4.7322e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "310000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3491e-40, 1.0461e-41, 2.5775e-21],\n", + " [3.0382e-22, 1.0699e-19, 5.9945e-20, 4.7358e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "311000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0496e-41, 2.5613e-21],\n", + " [3.0419e-22, 1.0711e-19, 6.0023e-20, 4.7202e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "312000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5695e-43, 1.3339e-40, 1.0336e-41, 2.6361e-21],\n", + " [3.0253e-22, 1.0653e-19, 5.9656e-20, 4.7924e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "313000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0452e-41, 2.5809e-21],\n", + " [3.0374e-22, 1.0695e-19, 5.9923e-20, 4.7391e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "314000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3436e-40, 1.0416e-41, 2.5983e-21],\n", + " [3.0334e-22, 1.0681e-19, 5.9841e-20, 4.7558e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "315000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3457e-40, 1.0433e-41, 2.5903e-21],\n", + " [3.0353e-22, 1.0688e-19, 5.9879e-20, 4.7480e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "316000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3376e-40, 1.0365e-41, 2.6215e-21],\n", + " [3.0282e-22, 1.0663e-19, 5.9726e-20, 4.7781e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "317000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3562e-40, 1.0518e-41, 2.5502e-21],\n", + " [3.0442e-22, 1.0719e-19, 6.0077e-20, 4.7093e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "318000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0459e-41, 2.5773e-21],\n", + " [3.0380e-22, 1.0698e-19, 5.9939e-20, 4.7355e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "319000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3533e-40, 1.0494e-41, 2.5609e-21],\n", + " [3.0418e-22, 1.0711e-19, 6.0020e-20, 4.7198e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "320000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3528e-40, 1.0490e-41, 2.5626e-21],\n", + " [3.0414e-22, 1.0709e-19, 6.0011e-20, 4.7211e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "321000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3402e-40, 1.0386e-41, 2.6111e-21],\n", + " [3.0306e-22, 1.0671e-19, 5.9769e-20, 4.7682e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "322000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0448e-41, 2.5822e-21],\n", + " [3.0369e-22, 1.0693e-19, 5.9908e-20, 4.7403e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "323000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0471e-41, 2.5720e-21],\n", + " [3.0392e-22, 1.0702e-19, 5.9965e-20, 4.7303e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "324000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0445e-41, 2.5834e-21],\n", + " [3.0367e-22, 1.0692e-19, 5.9908e-20, 4.7415e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "325000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3539e-40, 1.0500e-41, 2.5584e-21],\n", + " [3.0423e-22, 1.0712e-19, 6.0033e-20, 4.7174e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "326000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3519e-40, 1.0483e-41, 2.5656e-21],\n", + " [3.0406e-22, 1.0706e-19, 5.9989e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "327000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3594e-40, 1.0546e-41, 2.5378e-21],\n", + " [3.0471e-22, 1.0729e-19, 6.0137e-20, 4.6971e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "328000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3508e-40, 1.0473e-41, 2.5698e-21],\n", + " [3.0397e-22, 1.0703e-19, 5.9970e-20, 4.7283e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "329000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3590e-40, 1.0542e-41, 2.5389e-21],\n", + " [3.0465e-22, 1.0727e-19, 6.0126e-20, 4.6984e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "330000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3555e-40, 1.0513e-41, 2.5515e-21],\n", + " [3.0437e-22, 1.0717e-19, 6.0056e-20, 4.7106e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "331000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3561e-40, 1.0518e-41, 2.5491e-21],\n", + " [3.0442e-22, 1.0718e-19, 6.0071e-20, 4.7083e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "332000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0479e-41, 2.5671e-21],\n", + " [3.0402e-22, 1.0705e-19, 5.9983e-20, 4.7257e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "333000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3501e-40, 1.0469e-41, 2.5719e-21],\n", + " [3.0392e-22, 1.0701e-19, 5.9961e-20, 4.7303e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "334000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3543e-40, 1.0503e-41, 2.5564e-21],\n", + " [3.0426e-22, 1.0713e-19, 6.0038e-20, 4.7155e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "335000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0441e-41, 2.5844e-21],\n", + " [3.0364e-22, 1.0691e-19, 5.9897e-20, 4.7425e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "336000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3522e-40, 1.0485e-41, 2.5644e-21],\n", + " [3.0407e-22, 1.0707e-19, 5.9996e-20, 4.7231e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "337000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3477e-40, 1.0448e-41, 2.5813e-21],\n", + " [3.0370e-22, 1.0694e-19, 5.9912e-20, 4.7396e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "338000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0413e-41, 2.5977e-21],\n", + " [3.0334e-22, 1.0681e-19, 5.9831e-20, 4.7552e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "339000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3621e-40, 1.0567e-41, 2.5270e-21],\n", + " [3.0492e-22, 1.0737e-19, 6.0185e-20, 4.6868e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "340000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3526e-40, 1.0489e-41, 2.5628e-21],\n", + " [3.0411e-22, 1.0708e-19, 6.0005e-20, 4.7218e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "341000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3598e-40, 1.0548e-41, 2.5357e-21],\n", + " [3.0472e-22, 1.0730e-19, 6.0137e-20, 4.6951e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "342000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3518e-40, 1.0482e-41, 2.5654e-21],\n", + " [3.0405e-22, 1.0706e-19, 5.9990e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "343000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0391e-41, 2.6078e-21],\n", + " [3.0312e-22, 1.0673e-19, 5.9778e-20, 4.7652e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "344000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0494e-41, 2.5598e-21],\n", + " [3.0418e-22, 1.0710e-19, 6.0018e-20, 4.7187e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "345000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0456e-41, 2.5770e-21],\n", + " [3.0380e-22, 1.0696e-19, 5.9928e-20, 4.7355e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "346000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3425e-40, 1.0405e-41, 2.6006e-21],\n", + " [3.0326e-22, 1.0678e-19, 5.9813e-20, 4.7581e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "347000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3456e-40, 1.0431e-41, 2.5887e-21],\n", + " [3.0352e-22, 1.0687e-19, 5.9866e-20, 4.7467e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "348000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3451e-40, 1.0426e-41, 2.5911e-21],\n", + " [3.0348e-22, 1.0685e-19, 5.9857e-20, 4.7491e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "349000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0364e-41, 2.6206e-21],\n", + " [3.0283e-22, 1.0663e-19, 5.9715e-20, 4.7775e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "350000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3357e-40, 1.0349e-41, 2.6271e-21],\n", + " [3.0269e-22, 1.0657e-19, 5.9680e-20, 4.7836e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "351000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3472e-40, 1.0444e-41, 2.5827e-21],\n", + " [3.0368e-22, 1.0692e-19, 5.9899e-20, 4.7409e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "352000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0389e-41, 2.6073e-21],\n", + " [3.0312e-22, 1.0673e-19, 5.9773e-20, 4.7647e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "353000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3479e-40, 1.0449e-41, 2.5797e-21],\n", + " [3.0373e-22, 1.0693e-19, 5.9912e-20, 4.7378e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "354000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3445e-40, 1.0420e-41, 2.5931e-21],\n", + " [3.0342e-22, 1.0683e-19, 5.9844e-20, 4.7507e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "355000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3561e-40, 1.0517e-41, 2.5489e-21],\n", + " [3.0441e-22, 1.0718e-19, 6.0062e-20, 4.7080e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "356000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3411e-40, 1.0393e-41, 2.6061e-21],\n", + " [3.0314e-22, 1.0673e-19, 5.9786e-20, 4.7635e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "357000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3458e-40, 1.0431e-41, 2.5879e-21],\n", + " [3.0354e-22, 1.0688e-19, 5.9868e-20, 4.7459e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "358000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0452e-41, 2.5784e-21],\n", + " [3.0376e-22, 1.0695e-19, 5.9917e-20, 4.7365e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "359000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3429e-40, 1.0407e-41, 2.5985e-21],\n", + " [3.0330e-22, 1.0678e-19, 5.9813e-20, 4.7561e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "360000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3472e-40, 1.0442e-41, 2.5825e-21],\n", + " [3.0366e-22, 1.0692e-19, 5.9894e-20, 4.7406e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "361000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3392e-40, 1.0377e-41, 2.6133e-21],\n", + " [3.0298e-22, 1.0667e-19, 5.9742e-20, 4.7703e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "362000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0440e-41, 2.5839e-21],\n", + " [3.0363e-22, 1.0690e-19, 5.9890e-20, 4.7422e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "363000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3468e-40, 1.0441e-41, 2.5835e-21],\n", + " [3.0364e-22, 1.0690e-19, 5.9890e-20, 4.7417e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "364000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3427e-40, 1.0405e-41, 2.5995e-21],\n", + " [3.0328e-22, 1.0678e-19, 5.9806e-20, 4.7570e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "365000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3438e-40, 1.0416e-41, 2.5949e-21],\n", + " [3.0335e-22, 1.0681e-19, 5.9831e-20, 4.7526e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "366000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0452e-41, 2.5781e-21],\n", + " [3.0374e-22, 1.0693e-19, 5.9914e-20, 4.7364e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "367000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0434e-41, 2.5860e-21],\n", + " [3.0355e-22, 1.0688e-19, 5.9873e-20, 4.7441e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "368000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3543e-40, 1.0501e-41, 2.5549e-21],\n", + " [3.0425e-22, 1.0712e-19, 6.0027e-20, 4.7138e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "369000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0447e-41, 2.5800e-21],\n", + " [3.0370e-22, 1.0693e-19, 5.9901e-20, 4.7383e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "370000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3521e-40, 1.0483e-41, 2.5632e-21],\n", + " [3.0407e-22, 1.0705e-19, 5.9985e-20, 4.7217e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "371000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0452e-41, 2.5780e-21],\n", + " [3.0374e-22, 1.0694e-19, 5.9912e-20, 4.7364e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "372000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0476e-41, 2.5663e-21],\n", + " [3.0399e-22, 1.0703e-19, 5.9967e-20, 4.7250e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "373000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0455e-41, 2.5759e-21],\n", + " [3.0380e-22, 1.0695e-19, 5.9923e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "374000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3444e-40, 1.0419e-41, 2.5922e-21],\n", + " [3.0343e-22, 1.0683e-19, 5.9839e-20, 4.7500e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "375000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3541e-40, 1.0499e-41, 2.5552e-21],\n", + " [3.0426e-22, 1.0712e-19, 6.0020e-20, 4.7143e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "376000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3555e-40, 1.0511e-41, 2.5498e-21],\n", + " [3.0438e-22, 1.0716e-19, 6.0047e-20, 4.7092e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "377000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3437e-40, 1.0413e-41, 2.5949e-21],\n", + " [3.0336e-22, 1.0680e-19, 5.9826e-20, 4.7528e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "378000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3447e-40, 1.0421e-41, 2.5907e-21],\n", + " [3.0345e-22, 1.0683e-19, 5.9842e-20, 4.7486e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "379000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3385e-40, 1.0371e-41, 2.6145e-21],\n", + " [3.0293e-22, 1.0664e-19, 5.9727e-20, 4.7715e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "380000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3515e-40, 1.0476e-41, 2.5651e-21],\n", + " [3.0403e-22, 1.0704e-19, 5.9970e-20, 4.7238e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "381000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3493e-40, 1.0459e-41, 2.5733e-21],\n", + " [3.0384e-22, 1.0697e-19, 5.9932e-20, 4.7319e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "382000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3525e-40, 1.0486e-41, 2.5612e-21],\n", + " [3.0411e-22, 1.0707e-19, 5.9989e-20, 4.7201e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "383000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3420e-40, 1.0399e-41, 2.6011e-21],\n", + " [3.0322e-22, 1.0675e-19, 5.9791e-20, 4.7587e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "384000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3550e-40, 1.0506e-41, 2.5517e-21],\n", + " [3.0432e-22, 1.0714e-19, 6.0033e-20, 4.7109e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "385000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3461e-40, 1.0433e-41, 2.5853e-21],\n", + " [3.0356e-22, 1.0687e-19, 5.9864e-20, 4.7433e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "386000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0458e-41, 2.5737e-21],\n", + " [3.0382e-22, 1.0696e-19, 5.9923e-20, 4.7324e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "387000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3444e-40, 1.0419e-41, 2.5916e-21],\n", + " [3.0343e-22, 1.0682e-19, 5.9833e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "388000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0465e-41, 2.5707e-21],\n", + " [3.0390e-22, 1.0699e-19, 5.9937e-20, 4.7293e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "389000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3531e-40, 1.0490e-41, 2.5581e-21],\n", + " [3.0417e-22, 1.0708e-19, 6.0001e-20, 4.7172e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "390000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3552e-40, 1.0508e-41, 2.5506e-21],\n", + " [3.0433e-22, 1.0714e-19, 6.0040e-20, 4.7097e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "391000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3406e-40, 1.0386e-41, 2.6067e-21],\n", + " [3.0308e-22, 1.0671e-19, 5.9758e-20, 4.7641e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "392000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3396e-40, 1.0379e-41, 2.6107e-21],\n", + " [3.0301e-22, 1.0667e-19, 5.9744e-20, 4.7679e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "393000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3445e-40, 1.0420e-41, 2.5916e-21],\n", + " [3.0343e-22, 1.0682e-19, 5.9841e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "394000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0466e-41, 2.5695e-21],\n", + " [3.0394e-22, 1.0700e-19, 5.9945e-20, 4.7280e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "395000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0473e-41, 2.5661e-21],\n", + " [3.0400e-22, 1.0703e-19, 5.9961e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "396000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0442e-41, 2.5812e-21],\n", + " [3.0366e-22, 1.0691e-19, 5.9888e-20, 4.7394e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "397000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3488e-40, 1.0454e-41, 2.5750e-21],\n", + " [3.0380e-22, 1.0695e-19, 5.9915e-20, 4.7334e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "398000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0388e-41, 2.6064e-21],\n", + " [3.0311e-22, 1.0671e-19, 5.9762e-20, 4.7636e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "399000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3529e-40, 1.0489e-41, 2.5595e-21],\n", + " [3.0416e-22, 1.0707e-19, 5.9994e-20, 4.7184e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "400000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0456e-41, 2.5741e-21],\n", + " [3.0381e-22, 1.0696e-19, 5.9925e-20, 4.7325e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "401000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3525e-40, 1.0485e-41, 2.5607e-21],\n", + " [3.0411e-22, 1.0706e-19, 5.9985e-20, 4.7198e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "402000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3551e-40, 1.0507e-41, 2.5507e-21],\n", + " [3.0433e-22, 1.0714e-19, 6.0036e-20, 4.7099e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "403000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3548e-40, 1.0504e-41, 2.5516e-21],\n", + " [3.0432e-22, 1.0713e-19, 6.0029e-20, 4.7107e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "404000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3491e-40, 1.0456e-41, 2.5734e-21],\n", + " [3.0381e-22, 1.0696e-19, 5.9917e-20, 4.7319e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "405000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0438e-41, 2.5817e-21],\n", + " [3.0363e-22, 1.0689e-19, 5.9877e-20, 4.7402e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "406000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0406e-41, 2.5966e-21],\n", + " [3.0331e-22, 1.0677e-19, 5.9806e-20, 4.7541e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "407000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0455e-41, 2.5736e-21],\n", + " [3.0382e-22, 1.0696e-19, 5.9919e-20, 4.7321e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "408000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3488e-40, 1.0454e-41, 2.5743e-21],\n", + " [3.0379e-22, 1.0695e-19, 5.9912e-20, 4.7328e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "409000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3454e-40, 1.0426e-41, 2.5871e-21],\n", + " [3.0350e-22, 1.0685e-19, 5.9846e-20, 4.7451e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "410000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3507e-40, 1.0471e-41, 2.5668e-21],\n", + " [3.0395e-22, 1.0700e-19, 5.9947e-20, 4.7254e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "411000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3509e-40, 1.0472e-41, 2.5658e-21],\n", + " [3.0398e-22, 1.0701e-19, 5.9952e-20, 4.7246e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "412000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0410e-41, 2.5945e-21],\n", + " [3.0336e-22, 1.0678e-19, 5.9813e-20, 4.7523e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "413000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3524e-40, 1.0485e-41, 2.5604e-21],\n", + " [3.0410e-22, 1.0705e-19, 5.9981e-20, 4.7191e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "414000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0409e-41, 2.5947e-21],\n", + " [3.0332e-22, 1.0678e-19, 5.9809e-20, 4.7523e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "415000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0386e-41, 2.6051e-21],\n", + " [3.0310e-22, 1.0671e-19, 5.9762e-20, 4.7623e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "416000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3439e-40, 1.0413e-41, 2.5925e-21],\n", + " [3.0339e-22, 1.0680e-19, 5.9820e-20, 4.7503e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "417000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3580e-40, 1.0529e-41, 2.5395e-21],\n", + " [3.0458e-22, 1.0722e-19, 6.0082e-20, 4.6990e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "418000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3563e-40, 1.0515e-41, 2.5457e-21],\n", + " [3.0443e-22, 1.0717e-19, 6.0055e-20, 4.7047e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "419000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0371e-41, 2.6120e-21],\n", + " [3.0295e-22, 1.0665e-19, 5.9726e-20, 4.7690e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "420000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0466e-41, 2.5678e-21],\n", + " [3.0394e-22, 1.0699e-19, 5.9941e-20, 4.7264e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "421000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3630e-40, 1.0571e-41, 2.5202e-21],\n", + " [3.0499e-22, 1.0737e-19, 6.0176e-20, 4.6802e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "422000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3599e-40, 1.0545e-41, 2.5318e-21],\n", + " [3.0475e-22, 1.0728e-19, 6.0121e-20, 4.6915e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "423000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3541e-40, 1.0497e-41, 2.5537e-21],\n", + " [3.0425e-22, 1.0711e-19, 6.0012e-20, 4.7128e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "424000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3441e-40, 1.0414e-41, 2.5916e-21],\n", + " [3.0341e-22, 1.0680e-19, 5.9822e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "425000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3436e-40, 1.0410e-41, 2.5940e-21],\n", + " [3.0335e-22, 1.0679e-19, 5.9813e-20, 4.7519e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "426000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3463e-40, 1.0433e-41, 2.5832e-21],\n", + " [3.0357e-22, 1.0687e-19, 5.9861e-20, 4.7416e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "427000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3517e-40, 1.0478e-41, 2.5627e-21],\n", + " [3.0406e-22, 1.0704e-19, 5.9965e-20, 4.7215e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "428000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0492e-41, 2.5565e-21],\n", + " [3.0420e-22, 1.0708e-19, 5.9994e-20, 4.7156e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "429000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3523e-40, 1.0482e-41, 2.5606e-21],\n", + " [3.0410e-22, 1.0705e-19, 5.9978e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "430000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3466e-40, 1.0434e-41, 2.5826e-21],\n", + " [3.0360e-22, 1.0688e-19, 5.9864e-20, 4.7406e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "431000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3464e-40, 1.0434e-41, 2.5829e-21],\n", + " [3.0359e-22, 1.0687e-19, 5.9866e-20, 4.7412e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "432000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3494e-40, 1.0458e-41, 2.5716e-21],\n", + " [3.0383e-22, 1.0696e-19, 5.9921e-20, 4.7299e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "433000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0441e-41, 2.5795e-21],\n", + " [3.0368e-22, 1.0690e-19, 5.9883e-20, 4.7378e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "434000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3428e-40, 1.0403e-41, 2.5968e-21],\n", + " [3.0330e-22, 1.0677e-19, 5.9799e-20, 4.7545e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "435000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3460e-40, 1.0430e-41, 2.5846e-21],\n", + " [3.0356e-22, 1.0686e-19, 5.9857e-20, 4.7428e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "436000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3483e-40, 1.0448e-41, 2.5754e-21],\n", + " [3.0377e-22, 1.0692e-19, 5.9899e-20, 4.7338e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "437000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0431e-41, 2.5836e-21],\n", + " [3.0357e-22, 1.0687e-19, 5.9861e-20, 4.7416e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "438000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3421e-40, 1.0398e-41, 2.5996e-21],\n", + " [3.0322e-22, 1.0675e-19, 5.9782e-20, 4.7571e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "439000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3466e-40, 1.0434e-41, 2.5821e-21],\n", + " [3.0362e-22, 1.0687e-19, 5.9866e-20, 4.7403e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "440000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3604e-40, 1.0548e-41, 2.5304e-21],\n", + " [3.0478e-22, 1.0729e-19, 6.0124e-20, 4.6904e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "441000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0452e-41, 2.5736e-21],\n", + " [3.0381e-22, 1.0694e-19, 5.9906e-20, 4.7321e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "442000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3550e-40, 1.0503e-41, 2.5503e-21],\n", + " [3.0433e-22, 1.0713e-19, 6.0025e-20, 4.7094e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "443000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3413e-40, 1.0389e-41, 2.6025e-21],\n", + " [3.0315e-22, 1.0671e-19, 5.9757e-20, 4.7600e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "444000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0472e-41, 2.5645e-21],\n", + " [3.0400e-22, 1.0701e-19, 5.9954e-20, 4.7234e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "445000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3565e-40, 1.0517e-41, 2.5444e-21],\n", + " [3.0446e-22, 1.0717e-19, 6.0053e-20, 4.7038e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "446000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3542e-40, 1.0497e-41, 2.5528e-21],\n", + " [3.0426e-22, 1.0710e-19, 6.0011e-20, 4.7120e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "447000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3573e-40, 1.0522e-41, 2.5412e-21],\n", + " [3.0453e-22, 1.0720e-19, 6.0066e-20, 4.7007e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "448000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3567e-40, 1.0518e-41, 2.5437e-21],\n", + " [3.0446e-22, 1.0717e-19, 6.0055e-20, 4.7033e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "449000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0463e-41, 2.5681e-21],\n", + " [3.0392e-22, 1.0698e-19, 5.9934e-20, 4.7269e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "450000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3439e-40, 1.0412e-41, 2.5925e-21],\n", + " [3.0339e-22, 1.0680e-19, 5.9819e-20, 4.7504e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "451000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3548e-40, 1.0501e-41, 2.5507e-21],\n", + " [3.0432e-22, 1.0712e-19, 6.0022e-20, 4.7099e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "452000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3553e-40, 1.0506e-41, 2.5489e-21],\n", + " [3.0436e-22, 1.0713e-19, 6.0029e-20, 4.7082e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "453000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3531e-40, 1.0487e-41, 2.5574e-21],\n", + " [3.0416e-22, 1.0707e-19, 5.9985e-20, 4.7165e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "454000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3421e-40, 1.0398e-41, 2.5989e-21],\n", + " [3.0324e-22, 1.0674e-19, 5.9780e-20, 4.7565e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "455000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3538e-40, 1.0493e-41, 2.5545e-21],\n", + " [3.0421e-22, 1.0708e-19, 6.0000e-20, 4.7136e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "456000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3409e-40, 1.0388e-41, 2.6037e-21],\n", + " [3.0314e-22, 1.0670e-19, 5.9755e-20, 4.7609e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "457000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0454e-41, 2.5726e-21],\n", + " [3.0381e-22, 1.0694e-19, 5.9906e-20, 4.7313e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "458000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0454e-41, 2.5730e-21],\n", + " [3.0381e-22, 1.0694e-19, 5.9906e-20, 4.7315e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "459000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3429e-40, 1.0403e-41, 2.5958e-21],\n", + " [3.0331e-22, 1.0676e-19, 5.9791e-20, 4.7536e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "460000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3486e-40, 1.0451e-41, 2.5739e-21],\n", + " [3.0380e-22, 1.0693e-19, 5.9901e-20, 4.7324e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "461000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3537e-40, 1.0493e-41, 2.5548e-21],\n", + " [3.0423e-22, 1.0708e-19, 5.9996e-20, 4.7140e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "462000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3441e-40, 1.0413e-41, 2.5913e-21],\n", + " [3.0340e-22, 1.0679e-19, 5.9815e-20, 4.7493e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "463000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3405e-40, 1.0382e-41, 2.6052e-21],\n", + " [3.0308e-22, 1.0669e-19, 5.9744e-20, 4.7628e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "464000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0462e-41, 2.5678e-21],\n", + " [3.0393e-22, 1.0697e-19, 5.9928e-20, 4.7264e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "465000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0395e-41, 2.5994e-21],\n", + " [3.0322e-22, 1.0673e-19, 5.9771e-20, 4.7570e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "466000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0395e-41, 2.5995e-21],\n", + " [3.0321e-22, 1.0673e-19, 5.9769e-20, 4.7571e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "467000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3411e-40, 1.0388e-41, 2.6026e-21],\n", + " [3.0313e-22, 1.0671e-19, 5.9755e-20, 4.7602e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "468000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3544e-40, 1.0497e-41, 2.5517e-21],\n", + " [3.0428e-22, 1.0710e-19, 6.0007e-20, 4.7109e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "469000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3575e-40, 1.0522e-41, 2.5399e-21],\n", + " [3.0455e-22, 1.0720e-19, 6.0066e-20, 4.6994e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "470000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0441e-41, 2.5778e-21],\n", + " [3.0370e-22, 1.0690e-19, 5.9879e-20, 4.7361e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "471000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0463e-41, 2.5674e-21],\n", + " [3.0392e-22, 1.0698e-19, 5.9930e-20, 4.7260e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "472000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0444e-41, 2.5761e-21],\n", + " [3.0373e-22, 1.0691e-19, 5.9883e-20, 4.7345e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "473000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3438e-40, 1.0410e-41, 2.5925e-21],\n", + " [3.0338e-22, 1.0678e-19, 5.9808e-20, 4.7503e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "474000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0438e-41, 2.5788e-21],\n", + " [3.0368e-22, 1.0689e-19, 5.9872e-20, 4.7371e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "475000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3558e-40, 1.0510e-41, 2.5464e-21],\n", + " [3.0440e-22, 1.0714e-19, 6.0033e-20, 4.7056e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "476000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0472e-41, 2.5639e-21],\n", + " [3.0401e-22, 1.0701e-19, 5.9947e-20, 4.7227e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "477000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3613e-40, 1.0553e-41, 2.5266e-21],\n", + " [3.0486e-22, 1.0731e-19, 6.0133e-20, 4.6865e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "478000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0441e-41, 2.5777e-21],\n", + " [3.0370e-22, 1.0690e-19, 5.9877e-20, 4.7361e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "479000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3498e-40, 1.0459e-41, 2.5693e-21],\n", + " [3.0390e-22, 1.0696e-19, 5.9915e-20, 4.7280e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "480000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3594e-40, 1.0539e-41, 2.5332e-21],\n", + " [3.0470e-22, 1.0725e-19, 6.0099e-20, 4.6929e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "481000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3567e-40, 1.0515e-41, 2.5432e-21],\n", + " [3.0447e-22, 1.0717e-19, 6.0047e-20, 4.7028e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "482000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0472e-41, 2.5638e-21],\n", + " [3.0400e-22, 1.0701e-19, 5.9948e-20, 4.7225e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "483000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0452e-41, 2.5724e-21],\n", + " [3.0382e-22, 1.0694e-19, 5.9904e-20, 4.7311e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "484000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3423e-40, 1.0396e-41, 2.5980e-21],\n", + " [3.0325e-22, 1.0674e-19, 5.9775e-20, 4.7558e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "485000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3447e-40, 1.0417e-41, 2.5887e-21],\n", + " [3.0345e-22, 1.0681e-19, 5.9817e-20, 4.7467e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "486000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0458e-41, 2.5699e-21],\n", + " [3.0386e-22, 1.0696e-19, 5.9915e-20, 4.7286e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "487000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3415e-40, 1.0391e-41, 2.6014e-21],\n", + " [3.0318e-22, 1.0671e-19, 5.9758e-20, 4.7590e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "488000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3416e-40, 1.0391e-41, 2.6008e-21],\n", + " [3.0318e-22, 1.0671e-19, 5.9762e-20, 4.7584e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "489000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3573e-40, 1.0520e-41, 2.5406e-21],\n", + " [3.0454e-22, 1.0719e-19, 6.0056e-20, 4.7003e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "490000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3572e-40, 1.0520e-41, 2.5410e-21],\n", + " [3.0452e-22, 1.0718e-19, 6.0055e-20, 4.7005e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "491000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3574e-40, 1.0522e-41, 2.5400e-21],\n", + " [3.0453e-22, 1.0719e-19, 6.0062e-20, 4.6995e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "492000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0471e-41, 2.5634e-21],\n", + " [3.0403e-22, 1.0700e-19, 5.9943e-20, 4.7223e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "493000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0440e-41, 2.5774e-21],\n", + " [3.0370e-22, 1.0689e-19, 5.9875e-20, 4.7360e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "494000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3427e-40, 1.0402e-41, 2.5959e-21],\n", + " [3.0330e-22, 1.0675e-19, 5.9786e-20, 4.7536e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "495000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3397e-40, 1.0377e-41, 2.6079e-21],\n", + " [3.0303e-22, 1.0666e-19, 5.9729e-20, 4.7652e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "496000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3454e-40, 1.0423e-41, 2.5857e-21],\n", + " [3.0350e-22, 1.0683e-19, 5.9831e-20, 4.7438e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "497000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3446e-40, 1.0416e-41, 2.5889e-21],\n", + " [3.0345e-22, 1.0681e-19, 5.9820e-20, 4.7471e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "498000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3516e-40, 1.0473e-41, 2.5622e-21],\n", + " [3.0405e-22, 1.0701e-19, 5.9947e-20, 4.7212e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "499000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0368e-41, 2.6111e-21],\n", + " [3.0295e-22, 1.0663e-19, 5.9709e-20, 4.7683e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "500000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3523e-40, 1.0479e-41, 2.5595e-21],\n", + " [3.0408e-22, 1.0704e-19, 5.9963e-20, 4.7185e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "501000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3423e-40, 1.0396e-41, 2.5972e-21],\n", + " [3.0324e-22, 1.0673e-19, 5.9773e-20, 4.7551e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "502000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3373e-40, 1.0356e-41, 2.6169e-21],\n", + " [3.0283e-22, 1.0658e-19, 5.9682e-20, 4.7738e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "503000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5695e-43, 1.3298e-40, 1.0294e-41, 2.6463e-21],\n", + " [3.0219e-22, 1.0636e-19, 5.9533e-20, 4.8020e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "504000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3485e-40, 1.0448e-41, 2.5734e-21],\n", + " [3.0379e-22, 1.0692e-19, 5.9892e-20, 4.7319e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "505000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3494e-40, 1.0455e-41, 2.5700e-21],\n", + " [3.0385e-22, 1.0694e-19, 5.9906e-20, 4.7287e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "506000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0452e-41, 2.5715e-21],\n", + " [3.0382e-22, 1.0693e-19, 5.9897e-20, 4.7302e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "507000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3544e-40, 1.0497e-41, 2.5509e-21],\n", + " [3.0430e-22, 1.0710e-19, 6.0003e-20, 4.7103e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "508000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3550e-40, 1.0501e-41, 2.5490e-21],\n", + " [3.0433e-22, 1.0712e-19, 6.0011e-20, 4.7084e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "509000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0402e-41, 2.5946e-21],\n", + " [3.0331e-22, 1.0675e-19, 5.9784e-20, 4.7525e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "510000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3573e-40, 1.0520e-41, 2.5400e-21],\n", + " [3.0453e-22, 1.0718e-19, 6.0055e-20, 4.6995e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "511000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3458e-40, 1.0426e-41, 2.5833e-21],\n", + " [3.0356e-22, 1.0684e-19, 5.9841e-20, 4.7416e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "512000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3464e-40, 1.0430e-41, 2.5810e-21],\n", + " [3.0359e-22, 1.0686e-19, 5.9850e-20, 4.7391e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "513000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3437e-40, 1.0409e-41, 2.5917e-21],\n", + " [3.0339e-22, 1.0678e-19, 5.9802e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "514000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3429e-40, 1.0400e-41, 2.5950e-21],\n", + " [3.0331e-22, 1.0675e-19, 5.9780e-20, 4.7529e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "515000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3483e-40, 1.0445e-41, 2.5741e-21],\n", + " [3.0377e-22, 1.0691e-19, 5.9886e-20, 4.7326e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "516000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3531e-40, 1.0485e-41, 2.5556e-21],\n", + " [3.0417e-22, 1.0705e-19, 5.9972e-20, 4.7146e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "517000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0471e-41, 2.5623e-21],\n", + " [3.0404e-22, 1.0700e-19, 5.9945e-20, 4.7214e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "518000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0463e-41, 2.5656e-21],\n", + " [3.0395e-22, 1.0698e-19, 5.9923e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "519000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0452e-41, 2.5710e-21],\n", + " [3.0382e-22, 1.0693e-19, 5.9897e-20, 4.7298e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "520000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3342e-40, 1.0329e-41, 2.6283e-21],\n", + " [3.0256e-22, 1.0649e-19, 5.9615e-20, 4.7848e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "521000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3416e-40, 1.0391e-41, 2.5992e-21],\n", + " [3.0320e-22, 1.0671e-19, 5.9755e-20, 4.7568e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "522000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3437e-40, 1.0407e-41, 2.5913e-21],\n", + " [3.0338e-22, 1.0677e-19, 5.9795e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "523000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3474e-40, 1.0438e-41, 2.5773e-21],\n", + " [3.0369e-22, 1.0688e-19, 5.9868e-20, 4.7358e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "524000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3516e-40, 1.0473e-41, 2.5610e-21],\n", + " [3.0405e-22, 1.0701e-19, 5.9947e-20, 4.7199e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "525000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3498e-40, 1.0458e-41, 2.5677e-21],\n", + " [3.0389e-22, 1.0695e-19, 5.9910e-20, 4.7263e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "526000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3508e-40, 1.0465e-41, 2.5642e-21],\n", + " [3.0396e-22, 1.0698e-19, 5.9926e-20, 4.7231e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "527000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3394e-40, 1.0372e-41, 2.6080e-21],\n", + " [3.0301e-22, 1.0664e-19, 5.9711e-20, 4.7652e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "528000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0368e-41, 2.6096e-21],\n", + " [3.0296e-22, 1.0663e-19, 5.9700e-20, 4.7670e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "529000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3411e-40, 1.0385e-41, 2.6015e-21],\n", + " [3.0315e-22, 1.0669e-19, 5.9742e-20, 4.7591e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "530000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3437e-40, 1.0407e-41, 2.5911e-21],\n", + " [3.0338e-22, 1.0677e-19, 5.9791e-20, 4.7491e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "531000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0437e-41, 2.5774e-21],\n", + " [3.0367e-22, 1.0688e-19, 5.9857e-20, 4.7360e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "532000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3429e-40, 1.0400e-41, 2.5943e-21],\n", + " [3.0330e-22, 1.0674e-19, 5.9773e-20, 4.7522e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "533000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0440e-41, 2.5763e-21],\n", + " [3.0371e-22, 1.0689e-19, 5.9862e-20, 4.7348e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "534000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3495e-40, 1.0455e-41, 2.5694e-21],\n", + " [3.0386e-22, 1.0694e-19, 5.9901e-20, 4.7280e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "535000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3527e-40, 1.0480e-41, 2.5569e-21],\n", + " [3.0415e-22, 1.0704e-19, 5.9963e-20, 4.7161e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "536000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0405e-41, 2.5926e-21],\n", + " [3.0333e-22, 1.0676e-19, 5.9784e-20, 4.7506e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "537000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3457e-40, 1.0424e-41, 2.5834e-21],\n", + " [3.0356e-22, 1.0683e-19, 5.9830e-20, 4.7417e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "538000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3412e-40, 1.0385e-41, 2.6013e-21],\n", + " [3.0316e-22, 1.0669e-19, 5.9744e-20, 4.7589e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "539000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0384e-41, 2.6022e-21],\n", + " [3.0313e-22, 1.0668e-19, 5.9737e-20, 4.7597e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "540000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3517e-40, 1.0472e-41, 2.5610e-21],\n", + " [3.0405e-22, 1.0700e-19, 5.9941e-20, 4.7199e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "541000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3418e-40, 1.0391e-41, 2.5990e-21],\n", + " [3.0320e-22, 1.0671e-19, 5.9753e-20, 4.7567e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "542000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3445e-40, 1.0414e-41, 2.5880e-21],\n", + " [3.0344e-22, 1.0679e-19, 5.9808e-20, 4.7459e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "543000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3414e-40, 1.0386e-41, 2.6005e-21],\n", + " [3.0316e-22, 1.0670e-19, 5.9744e-20, 4.7581e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "544000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3347e-40, 1.0332e-41, 2.6266e-21],\n", + " [3.0261e-22, 1.0650e-19, 5.9618e-20, 4.7832e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "545000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3398e-40, 1.0374e-41, 2.6064e-21],\n", + " [3.0305e-22, 1.0665e-19, 5.9715e-20, 4.7638e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "546000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0462e-41, 2.5653e-21],\n", + " [3.0395e-22, 1.0697e-19, 5.9917e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "547000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0449e-41, 2.5712e-21],\n", + " [3.0382e-22, 1.0692e-19, 5.9888e-20, 4.7299e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "548000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0458e-41, 2.5676e-21],\n", + " [3.0391e-22, 1.0695e-19, 5.9904e-20, 4.7266e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "549000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3422e-40, 1.0395e-41, 2.5969e-21],\n", + " [3.0325e-22, 1.0672e-19, 5.9762e-20, 4.7548e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "550000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3405e-40, 1.0379e-41, 2.6040e-21],\n", + " [3.0309e-22, 1.0667e-19, 5.9726e-20, 4.7616e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "551000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3538e-40, 1.0489e-41, 2.5528e-21],\n", + " [3.0425e-22, 1.0707e-19, 5.9979e-20, 4.7122e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "552000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3453e-40, 1.0420e-41, 2.5844e-21],\n", + " [3.0351e-22, 1.0681e-19, 5.9820e-20, 4.7425e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "553000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3440e-40, 1.0409e-41, 2.5899e-21],\n", + " [3.0340e-22, 1.0677e-19, 5.9799e-20, 4.7481e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "554000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0461e-41, 2.5660e-21],\n", + " [3.0394e-22, 1.0696e-19, 5.9912e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "555000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0438e-41, 2.5759e-21],\n", + " [3.0371e-22, 1.0688e-19, 5.9862e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "556000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3444e-40, 1.0413e-41, 2.5882e-21],\n", + " [3.0344e-22, 1.0678e-19, 5.9800e-20, 4.7462e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "557000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3385e-40, 1.0364e-41, 2.6113e-21],\n", + " [3.0293e-22, 1.0661e-19, 5.9691e-20, 4.7686e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "558000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0442e-41, 2.5743e-21],\n", + " [3.0374e-22, 1.0690e-19, 5.9872e-20, 4.7329e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "559000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0441e-41, 2.5743e-21],\n", + " [3.0374e-22, 1.0689e-19, 5.9868e-20, 4.7328e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "560000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3401e-40, 1.0375e-41, 2.6047e-21],\n", + " [3.0307e-22, 1.0666e-19, 5.9716e-20, 4.7622e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "561000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3530e-40, 1.0482e-41, 2.5552e-21],\n", + " [3.0416e-22, 1.0704e-19, 5.9965e-20, 4.7143e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "562000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0456e-41, 2.5667e-21],\n", + " [3.0389e-22, 1.0695e-19, 5.9899e-20, 4.7254e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "563000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3415e-40, 1.0388e-41, 2.5995e-21],\n", + " [3.0319e-22, 1.0669e-19, 5.9742e-20, 4.7573e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "564000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3447e-40, 1.0413e-41, 2.5870e-21],\n", + " [3.0346e-22, 1.0679e-19, 5.9804e-20, 4.7452e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "565000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3401e-40, 1.0375e-41, 2.6047e-21],\n", + " [3.0306e-22, 1.0665e-19, 5.9718e-20, 4.7622e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "566000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3492e-40, 1.0451e-41, 2.5697e-21],\n", + " [3.0383e-22, 1.0692e-19, 5.9886e-20, 4.7285e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "567000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0448e-41, 2.5708e-21],\n", + " [3.0381e-22, 1.0692e-19, 5.9883e-20, 4.7296e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "568000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3490e-40, 1.0448e-41, 2.5703e-21],\n", + " [3.0382e-22, 1.0692e-19, 5.9884e-20, 4.7290e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "569000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3440e-40, 1.0407e-41, 2.5893e-21],\n", + " [3.0339e-22, 1.0677e-19, 5.9786e-20, 4.7475e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "570000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0427e-41, 2.5809e-21],\n", + " [3.0357e-22, 1.0683e-19, 5.9830e-20, 4.7393e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "571000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3529e-40, 1.0480e-41, 2.5556e-21],\n", + " [3.0415e-22, 1.0704e-19, 5.9956e-20, 4.7148e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "572000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3452e-40, 1.0417e-41, 2.5847e-21],\n", + " [3.0348e-22, 1.0680e-19, 5.9811e-20, 4.7429e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "573000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0438e-41, 2.5758e-21],\n", + " [3.0370e-22, 1.0688e-19, 5.9855e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "574000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3494e-40, 1.0452e-41, 2.5688e-21],\n", + " [3.0384e-22, 1.0692e-19, 5.9890e-20, 4.7273e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "575000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3428e-40, 1.0398e-41, 2.5941e-21],\n", + " [3.0330e-22, 1.0673e-19, 5.9764e-20, 4.7520e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "576000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3347e-40, 1.0330e-41, 2.6259e-21],\n", + " [3.0259e-22, 1.0648e-19, 5.9609e-20, 4.7826e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "577000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3444e-40, 1.0412e-41, 2.5879e-21],\n", + " [3.0344e-22, 1.0678e-19, 5.9797e-20, 4.7459e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "578000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3520e-40, 1.0473e-41, 2.5586e-21],\n", + " [3.0407e-22, 1.0700e-19, 5.9936e-20, 4.7176e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "579000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3521e-40, 1.0475e-41, 2.5583e-21],\n", + " [3.0409e-22, 1.0701e-19, 5.9939e-20, 4.7175e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "580000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3432e-40, 1.0400e-41, 2.5921e-21],\n", + " [3.0332e-22, 1.0674e-19, 5.9769e-20, 4.7501e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "581000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3451e-40, 1.0416e-41, 2.5851e-21],\n", + " [3.0349e-22, 1.0680e-19, 5.9806e-20, 4.7432e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "582000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3551e-40, 1.0499e-41, 2.5470e-21],\n", + " [3.0433e-22, 1.0710e-19, 5.9996e-20, 4.7064e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "583000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3500e-40, 1.0458e-41, 2.5660e-21],\n", + " [3.0392e-22, 1.0694e-19, 5.9901e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "584000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0365e-41, 2.6091e-21],\n", + " [3.0295e-22, 1.0661e-19, 5.9687e-20, 4.7666e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "585000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3478e-40, 1.0438e-41, 2.5744e-21],\n", + " [3.0373e-22, 1.0688e-19, 5.9857e-20, 4.7331e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "586000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0454e-41, 2.5674e-21],\n", + " [3.0387e-22, 1.0693e-19, 5.9894e-20, 4.7263e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "587000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3432e-40, 1.0400e-41, 2.5922e-21],\n", + " [3.0332e-22, 1.0674e-19, 5.9766e-20, 4.7501e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "588000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3411e-40, 1.0382e-41, 2.6003e-21],\n", + " [3.0314e-22, 1.0668e-19, 5.9729e-20, 4.7581e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "589000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3458e-40, 1.0423e-41, 2.5822e-21],\n", + " [3.0354e-22, 1.0682e-19, 5.9820e-20, 4.7407e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "590000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0403e-41, 2.5915e-21],\n", + " [3.0334e-22, 1.0675e-19, 5.9773e-20, 4.7496e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "591000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3412e-40, 1.0384e-41, 2.6000e-21],\n", + " [3.0315e-22, 1.0668e-19, 5.9729e-20, 4.7577e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "592000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0353e-41, 2.6145e-21],\n", + " [3.0284e-22, 1.0657e-19, 5.9664e-20, 4.7718e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "593000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3477e-40, 1.0437e-41, 2.5751e-21],\n", + " [3.0372e-22, 1.0688e-19, 5.9855e-20, 4.7337e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "594000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3418e-40, 1.0389e-41, 2.5975e-21],\n", + " [3.0319e-22, 1.0669e-19, 5.9740e-20, 4.7554e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "595000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3420e-40, 1.0391e-41, 2.5970e-21],\n", + " [3.0322e-22, 1.0670e-19, 5.9746e-20, 4.7548e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "596000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3460e-40, 1.0423e-41, 2.5816e-21],\n", + " [3.0356e-22, 1.0682e-19, 5.9820e-20, 4.7399e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "597000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0447e-41, 2.5703e-21],\n", + " [3.0381e-22, 1.0691e-19, 5.9877e-20, 4.7292e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "598000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0461e-41, 2.5642e-21],\n", + " [3.0394e-22, 1.0696e-19, 5.9910e-20, 4.7233e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "599000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3497e-40, 1.0454e-41, 2.5673e-21],\n", + " [3.0388e-22, 1.0693e-19, 5.9890e-20, 4.7261e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "600000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3529e-40, 1.0480e-41, 2.5552e-21],\n", + " [3.0415e-22, 1.0703e-19, 5.9950e-20, 4.7145e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "601000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3448e-40, 1.0413e-41, 2.5860e-21],\n", + " [3.0346e-22, 1.0678e-19, 5.9797e-20, 4.7442e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "602000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0455e-41, 2.5660e-21],\n", + " [3.0390e-22, 1.0694e-19, 5.9894e-20, 4.7250e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "603000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0485e-41, 2.5529e-21],\n", + " [3.0420e-22, 1.0705e-19, 5.9961e-20, 4.7122e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "604000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3535e-40, 1.0485e-41, 2.5531e-21],\n", + " [3.0420e-22, 1.0704e-19, 5.9959e-20, 4.7122e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "605000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3459e-40, 1.0421e-41, 2.5816e-21],\n", + " [3.0354e-22, 1.0681e-19, 5.9815e-20, 4.7400e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "606000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0456e-41, 2.5653e-21],\n", + " [3.0392e-22, 1.0694e-19, 5.9899e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "607000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3356e-40, 1.0337e-41, 2.6214e-21],\n", + " [3.0269e-22, 1.0650e-19, 5.9624e-20, 4.7784e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "608000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3445e-40, 1.0410e-41, 2.5867e-21],\n", + " [3.0343e-22, 1.0677e-19, 5.9788e-20, 4.7449e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "609000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3454e-40, 1.0417e-41, 2.5831e-21],\n", + " [3.0352e-22, 1.0680e-19, 5.9806e-20, 4.7415e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "610000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3533e-40, 1.0483e-41, 2.5528e-21],\n", + " [3.0417e-22, 1.0703e-19, 5.9956e-20, 4.7122e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "611000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3461e-40, 1.0423e-41, 2.5803e-21],\n", + " [3.0358e-22, 1.0682e-19, 5.9819e-20, 4.7387e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "612000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3484e-40, 1.0441e-41, 2.5716e-21],\n", + " [3.0375e-22, 1.0689e-19, 5.9862e-20, 4.7305e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "613000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3541e-40, 1.0489e-41, 2.5500e-21],\n", + " [3.0426e-22, 1.0706e-19, 5.9967e-20, 4.7092e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "614000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3553e-40, 1.0500e-41, 2.5451e-21],\n", + " [3.0435e-22, 1.0709e-19, 5.9994e-20, 4.7046e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "615000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3546e-40, 1.0494e-41, 2.5475e-21],\n", + " [3.0430e-22, 1.0707e-19, 5.9979e-20, 4.7067e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "616000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3472e-40, 1.0433e-41, 2.5757e-21],\n", + " [3.0367e-22, 1.0685e-19, 5.9839e-20, 4.7342e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "617000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3440e-40, 1.0405e-41, 2.5883e-21],\n", + " [3.0340e-22, 1.0676e-19, 5.9777e-20, 4.7464e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "618000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3495e-40, 1.0452e-41, 2.5667e-21],\n", + " [3.0387e-22, 1.0692e-19, 5.9883e-20, 4.7256e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "619000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3436e-40, 1.0402e-41, 2.5894e-21],\n", + " [3.0336e-22, 1.0674e-19, 5.9769e-20, 4.7475e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "620000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0431e-41, 2.5759e-21],\n", + " [3.0366e-22, 1.0684e-19, 5.9831e-20, 4.7347e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "621000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3429e-40, 1.0396e-41, 2.5921e-21],\n", + " [3.0331e-22, 1.0672e-19, 5.9753e-20, 4.7501e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "622000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3447e-40, 1.0410e-41, 2.5847e-21],\n", + " [3.0346e-22, 1.0677e-19, 5.9784e-20, 4.7429e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "623000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3461e-40, 1.0423e-41, 2.5793e-21],\n", + " [3.0356e-22, 1.0682e-19, 5.9815e-20, 4.7378e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "624000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3510e-40, 1.0463e-41, 2.5604e-21],\n", + " [3.0400e-22, 1.0696e-19, 5.9908e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "625000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0445e-41, 2.5685e-21],\n", + " [3.0382e-22, 1.0690e-19, 5.9868e-20, 4.7274e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "626000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3433e-40, 1.0399e-41, 2.5903e-21],\n", + " [3.0333e-22, 1.0673e-19, 5.9758e-20, 4.7484e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "627000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3431e-40, 1.0398e-41, 2.5907e-21],\n", + " [3.0332e-22, 1.0673e-19, 5.9758e-20, 4.7488e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "628000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0375e-41, 2.6021e-21],\n", + " [3.0308e-22, 1.0664e-19, 5.9706e-20, 4.7597e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "629000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3437e-40, 1.0403e-41, 2.5884e-21],\n", + " [3.0338e-22, 1.0675e-19, 5.9771e-20, 4.7467e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "630000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0434e-41, 2.5738e-21],\n", + " [3.0370e-22, 1.0686e-19, 5.9842e-20, 4.7325e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "631000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0433e-41, 2.5747e-21],\n", + " [3.0369e-22, 1.0685e-19, 5.9841e-20, 4.7332e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "632000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3425e-40, 1.0392e-41, 2.5931e-21],\n", + " [3.0328e-22, 1.0671e-19, 5.9744e-20, 4.7512e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "633000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3506e-40, 1.0459e-41, 2.5620e-21],\n", + " [3.0397e-22, 1.0695e-19, 5.9901e-20, 4.7211e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "634000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3500e-40, 1.0454e-41, 2.5645e-21],\n", + " [3.0392e-22, 1.0693e-19, 5.9886e-20, 4.7234e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "635000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0451e-41, 2.5662e-21],\n", + " [3.0388e-22, 1.0692e-19, 5.9879e-20, 4.7251e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "636000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3475e-40, 1.0434e-41, 2.5739e-21],\n", + " [3.0369e-22, 1.0686e-19, 5.9841e-20, 4.7326e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "637000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3531e-40, 1.0480e-41, 2.5528e-21],\n", + " [3.0418e-22, 1.0703e-19, 5.9945e-20, 4.7119e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "638000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3422e-40, 1.0389e-41, 2.5942e-21],\n", + " [3.0325e-22, 1.0670e-19, 5.9742e-20, 4.7523e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "639000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0431e-41, 2.5755e-21],\n", + " [3.0366e-22, 1.0684e-19, 5.9831e-20, 4.7341e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "640000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3436e-40, 1.0402e-41, 2.5887e-21],\n", + " [3.0336e-22, 1.0674e-19, 5.9766e-20, 4.7468e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "641000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3568e-40, 1.0511e-41, 2.5385e-21],\n", + " [3.0449e-22, 1.0714e-19, 6.0016e-20, 4.6981e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "642000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3517e-40, 1.0468e-41, 2.5578e-21],\n", + " [3.0406e-22, 1.0698e-19, 5.9917e-20, 4.7171e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "643000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0388e-41, 2.5949e-21],\n", + " [3.0323e-22, 1.0669e-19, 5.9733e-20, 4.7529e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "644000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3418e-40, 1.0385e-41, 2.5957e-21],\n", + " [3.0319e-22, 1.0668e-19, 5.9726e-20, 4.7536e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "645000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3451e-40, 1.0413e-41, 2.5829e-21],\n", + " [3.0349e-22, 1.0678e-19, 5.9793e-20, 4.7413e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "646000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3519e-40, 1.0471e-41, 2.5563e-21],\n", + " [3.0408e-22, 1.0699e-19, 5.9923e-20, 4.7155e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "647000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3399e-40, 1.0370e-41, 2.6027e-21],\n", + " [3.0304e-22, 1.0663e-19, 5.9695e-20, 4.7606e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "648000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3518e-40, 1.0469e-41, 2.5571e-21],\n", + " [3.0407e-22, 1.0698e-19, 5.9921e-20, 4.7165e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "649000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3477e-40, 1.0435e-41, 2.5728e-21],\n", + " [3.0371e-22, 1.0686e-19, 5.9842e-20, 4.7315e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "650000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0396e-41, 2.5909e-21],\n", + " [3.0331e-22, 1.0672e-19, 5.9753e-20, 4.7491e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "651000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3457e-40, 1.0417e-41, 2.5808e-21],\n", + " [3.0353e-22, 1.0680e-19, 5.9802e-20, 4.7393e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "652000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3451e-40, 1.0413e-41, 2.5832e-21],\n", + " [3.0348e-22, 1.0678e-19, 5.9791e-20, 4.7415e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "653000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0350e-41, 2.6124e-21],\n", + " [3.0282e-22, 1.0655e-19, 5.9649e-20, 4.7698e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "654000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3466e-40, 1.0426e-41, 2.5770e-21],\n", + " [3.0363e-22, 1.0683e-19, 5.9817e-20, 4.7357e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "655000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0350e-41, 2.6121e-21],\n", + " [3.0284e-22, 1.0655e-19, 5.9647e-20, 4.7693e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "656000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3447e-40, 1.0410e-41, 2.5838e-21],\n", + " [3.0345e-22, 1.0677e-19, 5.9782e-20, 4.7422e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "657000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3443e-40, 1.0406e-41, 2.5858e-21],\n", + " [3.0342e-22, 1.0675e-19, 5.9775e-20, 4.7442e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "658000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3346e-40, 1.0326e-41, 2.6231e-21],\n", + " [3.0260e-22, 1.0647e-19, 5.9591e-20, 4.7801e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "659000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5695e-43, 1.3326e-40, 1.0309e-41, 2.6312e-21],\n", + " [3.0243e-22, 1.0640e-19, 5.9551e-20, 4.7877e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "660000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3406e-40, 1.0377e-41, 2.5996e-21],\n", + " [3.0310e-22, 1.0664e-19, 5.9707e-20, 4.7574e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "661000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0405e-41, 2.5864e-21],\n", + " [3.0342e-22, 1.0675e-19, 5.9771e-20, 4.7446e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "662000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3485e-40, 1.0441e-41, 2.5693e-21],\n", + " [3.0378e-22, 1.0688e-19, 5.9853e-20, 4.7283e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "663000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3400e-40, 1.0371e-41, 2.6023e-21],\n", + " [3.0306e-22, 1.0662e-19, 5.9693e-20, 4.7599e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "664000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3563e-40, 1.0506e-41, 2.5399e-21],\n", + " [3.0444e-22, 1.0711e-19, 6.0001e-20, 4.6995e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "665000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3501e-40, 1.0454e-41, 2.5632e-21],\n", + " [3.0392e-22, 1.0693e-19, 5.9881e-20, 4.7223e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "666000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3404e-40, 1.0374e-41, 2.6010e-21],\n", + " [3.0308e-22, 1.0663e-19, 5.9700e-20, 4.7586e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "667000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0406e-41, 2.5859e-21],\n", + " [3.0341e-22, 1.0675e-19, 5.9771e-20, 4.7441e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "668000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3387e-40, 1.0360e-41, 2.6074e-21],\n", + " [3.0294e-22, 1.0658e-19, 5.9667e-20, 4.7650e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "669000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3392e-40, 1.0364e-41, 2.6050e-21],\n", + " [3.0299e-22, 1.0661e-19, 5.9676e-20, 4.7625e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "670000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3367e-40, 1.0343e-41, 2.6150e-21],\n", + " [3.0279e-22, 1.0653e-19, 5.9633e-20, 4.7724e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "671000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3492e-40, 1.0447e-41, 2.5665e-21],\n", + " [3.0383e-22, 1.0690e-19, 5.9864e-20, 4.7254e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "672000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0396e-41, 2.5899e-21],\n", + " [3.0332e-22, 1.0672e-19, 5.9749e-20, 4.7481e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "673000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3332e-40, 1.0314e-41, 2.6288e-21],\n", + " [3.0245e-22, 1.0641e-19, 5.9558e-20, 4.7855e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "674000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3468e-40, 1.0427e-41, 2.5760e-21],\n", + " [3.0364e-22, 1.0683e-19, 5.9820e-20, 4.7347e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "675000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3465e-40, 1.0424e-41, 2.5767e-21],\n", + " [3.0362e-22, 1.0682e-19, 5.9815e-20, 4.7354e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "676000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3491e-40, 1.0445e-41, 2.5671e-21],\n", + " [3.0383e-22, 1.0690e-19, 5.9862e-20, 4.7261e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "677000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3457e-40, 1.0416e-41, 2.5802e-21],\n", + " [3.0353e-22, 1.0679e-19, 5.9797e-20, 4.7387e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "678000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3520e-40, 1.0469e-41, 2.5560e-21],\n", + " [3.0408e-22, 1.0698e-19, 5.9917e-20, 4.7153e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "679000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0444e-41, 2.5677e-21],\n", + " [3.0381e-22, 1.0689e-19, 5.9861e-20, 4.7267e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "680000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3509e-40, 1.0459e-41, 2.5599e-21],\n", + " [3.0398e-22, 1.0695e-19, 5.9897e-20, 4.7189e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "681000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3385e-40, 1.0357e-41, 2.6076e-21],\n", + " [3.0292e-22, 1.0657e-19, 5.9655e-20, 4.7651e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "682000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0435e-41, 2.5707e-21],\n", + " [3.0375e-22, 1.0686e-19, 5.9839e-20, 4.7298e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "683000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0449e-41, 2.5642e-21],\n", + " [3.0387e-22, 1.0691e-19, 5.9868e-20, 4.7234e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "684000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3409e-40, 1.0378e-41, 2.5976e-21],\n", + " [3.0313e-22, 1.0665e-19, 5.9707e-20, 4.7555e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "685000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0433e-41, 2.5720e-21],\n", + " [3.0369e-22, 1.0685e-19, 5.9831e-20, 4.7306e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "686000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3495e-40, 1.0449e-41, 2.5649e-21],\n", + " [3.0387e-22, 1.0690e-19, 5.9870e-20, 4.7238e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "687000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3445e-40, 1.0407e-41, 2.5836e-21],\n", + " [3.0343e-22, 1.0676e-19, 5.9773e-20, 4.7422e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "688000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3427e-40, 1.0392e-41, 2.5911e-21],\n", + " [3.0329e-22, 1.0669e-19, 5.9737e-20, 4.7493e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "689000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3406e-40, 1.0375e-41, 2.5987e-21],\n", + " [3.0311e-22, 1.0664e-19, 5.9700e-20, 4.7567e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "690000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3491e-40, 1.0445e-41, 2.5663e-21],\n", + " [3.0382e-22, 1.0689e-19, 5.9857e-20, 4.7251e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "691000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3355e-40, 1.0332e-41, 2.6190e-21],\n", + " [3.0265e-22, 1.0648e-19, 5.9598e-20, 4.7763e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "692000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3367e-40, 1.0343e-41, 2.6137e-21],\n", + " [3.0276e-22, 1.0652e-19, 5.9620e-20, 4.7712e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "693000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3415e-40, 1.0382e-41, 2.5952e-21],\n", + " [3.0319e-22, 1.0666e-19, 5.9715e-20, 4.7532e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "694000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0372e-41, 2.5997e-21],\n", + " [3.0308e-22, 1.0663e-19, 5.9693e-20, 4.7575e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "695000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3392e-40, 1.0364e-41, 2.6041e-21],\n", + " [3.0298e-22, 1.0659e-19, 5.9667e-20, 4.7619e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "696000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3592e-40, 1.0528e-41, 2.5283e-21],\n", + " [3.0469e-22, 1.0719e-19, 6.0047e-20, 4.6884e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "697000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3524e-40, 1.0472e-41, 2.5535e-21],\n", + " [3.0411e-22, 1.0699e-19, 5.9921e-20, 4.7129e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "698000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3447e-40, 1.0409e-41, 2.5830e-21],\n", + " [3.0345e-22, 1.0676e-19, 5.9777e-20, 4.7416e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "699000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3409e-40, 1.0377e-41, 2.5975e-21],\n", + " [3.0313e-22, 1.0664e-19, 5.9700e-20, 4.7555e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "700000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3447e-40, 1.0407e-41, 2.5828e-21],\n", + " [3.0344e-22, 1.0676e-19, 5.9771e-20, 4.7415e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "701000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3453e-40, 1.0413e-41, 2.5800e-21],\n", + " [3.0352e-22, 1.0677e-19, 5.9788e-20, 4.7386e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "702000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0427e-41, 2.5734e-21],\n", + " [3.0367e-22, 1.0683e-19, 5.9820e-20, 4.7322e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "703000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3446e-40, 1.0407e-41, 2.5826e-21],\n", + " [3.0346e-22, 1.0676e-19, 5.9771e-20, 4.7412e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "704000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0461e-41, 2.5577e-21],\n", + " [3.0400e-22, 1.0695e-19, 5.9897e-20, 4.7171e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "705000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3433e-40, 1.0396e-41, 2.5879e-21],\n", + " [3.0334e-22, 1.0671e-19, 5.9744e-20, 4.7462e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "706000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3434e-40, 1.0396e-41, 2.5874e-21],\n", + " [3.0334e-22, 1.0672e-19, 5.9747e-20, 4.7459e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "707000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3497e-40, 1.0449e-41, 2.5630e-21],\n", + " [3.0389e-22, 1.0691e-19, 5.9868e-20, 4.7220e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "708000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3443e-40, 1.0405e-41, 2.5839e-21],\n", + " [3.0343e-22, 1.0675e-19, 5.9762e-20, 4.7423e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "709000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0371e-41, 2.5995e-21],\n", + " [3.0306e-22, 1.0663e-19, 5.9686e-20, 4.7574e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "710000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0375e-41, 2.5973e-21],\n", + " [3.0312e-22, 1.0664e-19, 5.9695e-20, 4.7554e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "711000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3514e-40, 1.0462e-41, 2.5567e-21],\n", + " [3.0403e-22, 1.0695e-19, 5.9899e-20, 4.7159e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "712000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0374e-41, 2.5979e-21],\n", + " [3.0311e-22, 1.0663e-19, 5.9689e-20, 4.7558e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "713000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0431e-41, 2.5713e-21],\n", + " [3.0371e-22, 1.0684e-19, 5.9820e-20, 4.7300e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "714000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3458e-40, 1.0416e-41, 2.5780e-21],\n", + " [3.0356e-22, 1.0679e-19, 5.9789e-20, 4.7367e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "715000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0403e-41, 2.5845e-21],\n", + " [3.0340e-22, 1.0674e-19, 5.9758e-20, 4.7430e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "716000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3373e-40, 1.0346e-41, 2.6107e-21],\n", + " [3.0282e-22, 1.0653e-19, 5.9627e-20, 4.7682e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "717000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0461e-41, 2.5573e-21],\n", + " [3.0401e-22, 1.0695e-19, 5.9892e-20, 4.7165e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "718000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3459e-40, 1.0417e-41, 2.5780e-21],\n", + " [3.0355e-22, 1.0679e-19, 5.9788e-20, 4.7368e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "719000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3467e-40, 1.0424e-41, 2.5747e-21],\n", + " [3.0363e-22, 1.0682e-19, 5.9806e-20, 4.7337e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "720000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0455e-41, 2.5604e-21],\n", + " [3.0395e-22, 1.0692e-19, 5.9873e-20, 4.7197e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "721000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3542e-40, 1.0485e-41, 2.5464e-21],\n", + " [3.0427e-22, 1.0704e-19, 5.9948e-20, 4.7061e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "722000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3604e-40, 1.0536e-41, 2.5232e-21],\n", + " [3.0480e-22, 1.0722e-19, 6.0064e-20, 4.6834e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "723000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3570e-40, 1.0508e-41, 2.5357e-21],\n", + " [3.0451e-22, 1.0712e-19, 6.0000e-20, 4.6957e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "724000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3455e-40, 1.0412e-41, 2.5795e-21],\n", + " [3.0352e-22, 1.0677e-19, 5.9780e-20, 4.7383e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "725000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3421e-40, 1.0385e-41, 2.5922e-21],\n", + " [3.0324e-22, 1.0667e-19, 5.9716e-20, 4.7506e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "726000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3443e-40, 1.0405e-41, 2.5836e-21],\n", + " [3.0344e-22, 1.0675e-19, 5.9760e-20, 4.7422e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "727000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0392e-41, 2.5887e-21],\n", + " [3.0331e-22, 1.0670e-19, 5.9731e-20, 4.7471e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "728000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0431e-41, 2.5709e-21],\n", + " [3.0371e-22, 1.0684e-19, 5.9820e-20, 4.7300e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "729000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3498e-40, 1.0448e-41, 2.5626e-21],\n", + " [3.0389e-22, 1.0690e-19, 5.9859e-20, 4.7220e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "730000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3399e-40, 1.0367e-41, 2.6005e-21],\n", + " [3.0306e-22, 1.0661e-19, 5.9675e-20, 4.7583e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "731000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3386e-40, 1.0356e-41, 2.6056e-21],\n", + " [3.0293e-22, 1.0657e-19, 5.9647e-20, 4.7635e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "732000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0419e-41, 2.5762e-21],\n", + " [3.0360e-22, 1.0680e-19, 5.9795e-20, 4.7350e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "733000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0370e-41, 2.5988e-21],\n", + " [3.0307e-22, 1.0662e-19, 5.9682e-20, 4.7568e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "734000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3455e-40, 1.0412e-41, 2.5791e-21],\n", + " [3.0353e-22, 1.0677e-19, 5.9778e-20, 4.7377e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "735000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3437e-40, 1.0398e-41, 2.5858e-21],\n", + " [3.0338e-22, 1.0672e-19, 5.9746e-20, 4.7444e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "736000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0424e-41, 2.5733e-21],\n", + " [3.0365e-22, 1.0681e-19, 5.9804e-20, 4.7324e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "737000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0374e-41, 2.5971e-21],\n", + " [3.0314e-22, 1.0663e-19, 5.9689e-20, 4.7552e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "738000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3423e-40, 1.0385e-41, 2.5915e-21],\n", + " [3.0325e-22, 1.0668e-19, 5.9715e-20, 4.7497e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "739000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3538e-40, 1.0482e-41, 2.5472e-21],\n", + " [3.0423e-22, 1.0702e-19, 5.9937e-20, 4.7069e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "740000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3510e-40, 1.0458e-41, 2.5577e-21],\n", + " [3.0400e-22, 1.0694e-19, 5.9883e-20, 4.7172e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "741000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3432e-40, 1.0393e-41, 2.5873e-21],\n", + " [3.0332e-22, 1.0670e-19, 5.9737e-20, 4.7459e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "742000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3459e-40, 1.0416e-41, 2.5772e-21],\n", + " [3.0357e-22, 1.0678e-19, 5.9788e-20, 4.7360e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "743000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3413e-40, 1.0378e-41, 2.5948e-21],\n", + " [3.0318e-22, 1.0664e-19, 5.9698e-20, 4.7530e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "744000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3446e-40, 1.0405e-41, 2.5824e-21],\n", + " [3.0345e-22, 1.0675e-19, 5.9762e-20, 4.7412e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "745000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3393e-40, 1.0361e-41, 2.6024e-21],\n", + " [3.0301e-22, 1.0659e-19, 5.9660e-20, 4.7603e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "746000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3378e-40, 1.0349e-41, 2.6082e-21],\n", + " [3.0287e-22, 1.0654e-19, 5.9633e-20, 4.7660e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "747000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3398e-40, 1.0365e-41, 2.6002e-21],\n", + " [3.0305e-22, 1.0660e-19, 5.9675e-20, 4.7584e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "748000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3360e-40, 1.0333e-41, 2.6150e-21],\n", + " [3.0272e-22, 1.0649e-19, 5.9595e-20, 4.7725e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "749000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0451e-41, 2.5600e-21],\n", + " [3.0394e-22, 1.0691e-19, 5.9866e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "750000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0458e-41, 2.5567e-21],\n", + " [3.0401e-22, 1.0693e-19, 5.9879e-20, 4.7162e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "751000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3544e-40, 1.0486e-41, 2.5444e-21],\n", + " [3.0430e-22, 1.0703e-19, 5.9945e-20, 4.7043e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "752000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0374e-41, 2.5963e-21],\n", + " [3.0313e-22, 1.0663e-19, 5.9686e-20, 4.7545e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "753000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3444e-40, 1.0403e-41, 2.5822e-21],\n", + " [3.0344e-22, 1.0674e-19, 5.9757e-20, 4.7407e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "754000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3391e-40, 1.0360e-41, 2.6024e-21],\n", + " [3.0299e-22, 1.0658e-19, 5.9656e-20, 4.7603e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "755000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3384e-40, 1.0353e-41, 2.6055e-21],\n", + " [3.0293e-22, 1.0656e-19, 5.9642e-20, 4.7634e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "756000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0374e-41, 2.5960e-21],\n", + " [3.0314e-22, 1.0663e-19, 5.9686e-20, 4.7541e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "757000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3383e-40, 1.0353e-41, 2.6057e-21],\n", + " [3.0292e-22, 1.0655e-19, 5.9640e-20, 4.7635e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "758000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3534e-40, 1.0476e-41, 2.5479e-21],\n", + " [3.0420e-22, 1.0700e-19, 5.9921e-20, 4.7076e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "759000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3384e-40, 1.0354e-41, 2.6052e-21],\n", + " [3.0293e-22, 1.0655e-19, 5.9638e-20, 4.7631e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "760000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3428e-40, 1.0389e-41, 2.5884e-21],\n", + " [3.0330e-22, 1.0668e-19, 5.9724e-20, 4.7470e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "761000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3452e-40, 1.0410e-41, 2.5791e-21],\n", + " [3.0351e-22, 1.0676e-19, 5.9769e-20, 4.7378e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "762000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3427e-40, 1.0388e-41, 2.5889e-21],\n", + " [3.0328e-22, 1.0668e-19, 5.9722e-20, 4.7472e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "763000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3430e-40, 1.0391e-41, 2.5876e-21],\n", + " [3.0331e-22, 1.0669e-19, 5.9722e-20, 4.7461e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "764000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0423e-41, 2.5725e-21],\n", + " [3.0367e-22, 1.0681e-19, 5.9795e-20, 4.7315e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "765000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3486e-40, 1.0437e-41, 2.5659e-21],\n", + " [3.0380e-22, 1.0686e-19, 5.9833e-20, 4.7251e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "766000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3391e-40, 1.0358e-41, 2.6025e-21],\n", + " [3.0299e-22, 1.0657e-19, 5.9653e-20, 4.7605e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "767000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3420e-40, 1.0382e-41, 2.5912e-21],\n", + " [3.0325e-22, 1.0666e-19, 5.9706e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "768000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3414e-40, 1.0378e-41, 2.5936e-21],\n", + " [3.0319e-22, 1.0664e-19, 5.9693e-20, 4.7519e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "769000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0399e-41, 2.5832e-21],\n", + " [3.0342e-22, 1.0673e-19, 5.9744e-20, 4.7419e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "770000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0382e-41, 2.5914e-21],\n", + " [3.0323e-22, 1.0666e-19, 5.9706e-20, 4.7499e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "771000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0393e-41, 2.5862e-21],\n", + " [3.0336e-22, 1.0670e-19, 5.9731e-20, 4.7448e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "772000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3382e-40, 1.0351e-41, 2.6060e-21],\n", + " [3.0290e-22, 1.0655e-19, 5.9638e-20, 4.7638e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "773000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0437e-41, 2.5656e-21],\n", + " [3.0381e-22, 1.0686e-19, 5.9831e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "774000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0447e-41, 2.5609e-21],\n", + " [3.0392e-22, 1.0690e-19, 5.9857e-20, 4.7202e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "775000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3439e-40, 1.0398e-41, 2.5835e-21],\n", + " [3.0340e-22, 1.0671e-19, 5.9742e-20, 4.7422e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "776000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0438e-41, 2.5642e-21],\n", + " [3.0384e-22, 1.0687e-19, 5.9833e-20, 4.7235e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "777000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0372e-41, 2.5951e-21],\n", + " [3.0314e-22, 1.0662e-19, 5.9682e-20, 4.7533e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "778000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3408e-40, 1.0372e-41, 2.5951e-21],\n", + " [3.0314e-22, 1.0663e-19, 5.9682e-20, 4.7532e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "779000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3421e-40, 1.0384e-41, 2.5904e-21],\n", + " [3.0325e-22, 1.0667e-19, 5.9707e-20, 4.7488e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "780000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3425e-40, 1.0386e-41, 2.5886e-21],\n", + " [3.0331e-22, 1.0668e-19, 5.9713e-20, 4.7470e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "781000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3445e-40, 1.0402e-41, 2.5811e-21],\n", + " [3.0346e-22, 1.0673e-19, 5.9751e-20, 4.7399e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "782000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3439e-40, 1.0396e-41, 2.5835e-21],\n", + " [3.0341e-22, 1.0671e-19, 5.9737e-20, 4.7419e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "783000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3502e-40, 1.0448e-41, 2.5589e-21],\n", + " [3.0394e-22, 1.0690e-19, 5.9855e-20, 4.7181e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "784000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3373e-40, 1.0343e-41, 2.6084e-21],\n", + " [3.0283e-22, 1.0651e-19, 5.9613e-20, 4.7661e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "785000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0368e-41, 2.5968e-21],\n", + " [3.0309e-22, 1.0660e-19, 5.9667e-20, 4.7549e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "786000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3373e-40, 1.0343e-41, 2.6088e-21],\n", + " [3.0284e-22, 1.0651e-19, 5.9609e-20, 4.7666e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "787000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3414e-40, 1.0377e-41, 2.5925e-21],\n", + " [3.0319e-22, 1.0664e-19, 5.9689e-20, 4.7509e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "788000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3476e-40, 1.0427e-41, 2.5688e-21],\n", + " [3.0373e-22, 1.0683e-19, 5.9806e-20, 4.7280e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "789000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3467e-40, 1.0420e-41, 2.5721e-21],\n", + " [3.0364e-22, 1.0680e-19, 5.9788e-20, 4.7312e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "790000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3449e-40, 1.0405e-41, 2.5789e-21],\n", + " [3.0348e-22, 1.0674e-19, 5.9755e-20, 4.7376e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "791000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3478e-40, 1.0430e-41, 2.5676e-21],\n", + " [3.0374e-22, 1.0683e-19, 5.9811e-20, 4.7267e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "792000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3367e-40, 1.0339e-41, 2.6104e-21],\n", + " [3.0281e-22, 1.0650e-19, 5.9604e-20, 4.7680e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "793000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0458e-41, 2.5545e-21],\n", + " [3.0405e-22, 1.0693e-19, 5.9875e-20, 4.7139e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "794000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3375e-40, 1.0343e-41, 2.6074e-21],\n", + " [3.0284e-22, 1.0652e-19, 5.9613e-20, 4.7652e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "795000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3428e-40, 1.0388e-41, 2.5870e-21],\n", + " [3.0331e-22, 1.0668e-19, 5.9716e-20, 4.7455e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "796000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3409e-40, 1.0372e-41, 2.5942e-21],\n", + " [3.0315e-22, 1.0663e-19, 5.9676e-20, 4.7525e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "797000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3426e-40, 1.0386e-41, 2.5874e-21],\n", + " [3.0331e-22, 1.0667e-19, 5.9713e-20, 4.7458e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "798000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3507e-40, 1.0454e-41, 2.5563e-21],\n", + " [3.0399e-22, 1.0692e-19, 5.9868e-20, 4.7159e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "799000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3509e-40, 1.0455e-41, 2.5559e-21],\n", + " [3.0401e-22, 1.0692e-19, 5.9870e-20, 4.7155e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "800000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3393e-40, 1.0358e-41, 2.6002e-21],\n", + " [3.0303e-22, 1.0658e-19, 5.9649e-20, 4.7583e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "801000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3425e-40, 1.0385e-41, 2.5880e-21],\n", + " [3.0329e-22, 1.0667e-19, 5.9711e-20, 4.7465e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "802000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3400e-40, 1.0364e-41, 2.5976e-21],\n", + " [3.0308e-22, 1.0660e-19, 5.9660e-20, 4.7557e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "803000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3364e-40, 1.0335e-41, 2.6117e-21],\n", + " [3.0277e-22, 1.0649e-19, 5.9591e-20, 4.7693e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "804000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3357e-40, 1.0329e-41, 2.6144e-21],\n", + " [3.0271e-22, 1.0646e-19, 5.9578e-20, 4.7719e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "805000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3452e-40, 1.0407e-41, 2.5774e-21],\n", + " [3.0353e-22, 1.0675e-19, 5.9758e-20, 4.7363e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "806000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3410e-40, 1.0374e-41, 2.5935e-21],\n", + " [3.0317e-22, 1.0663e-19, 5.9678e-20, 4.7517e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "807000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3446e-40, 1.0402e-41, 2.5796e-21],\n", + " [3.0347e-22, 1.0673e-19, 5.9749e-20, 4.7384e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "808000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3508e-40, 1.0452e-41, 2.5565e-21],\n", + " [3.0400e-22, 1.0692e-19, 5.9864e-20, 4.7159e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "809000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3458e-40, 1.0412e-41, 2.5749e-21],\n", + " [3.0357e-22, 1.0677e-19, 5.9769e-20, 4.7338e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "810000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3548e-40, 1.0486e-41, 2.5409e-21],\n", + " [3.0433e-22, 1.0704e-19, 5.9939e-20, 4.7007e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "811000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3409e-40, 1.0372e-41, 2.5937e-21],\n", + " [3.0316e-22, 1.0662e-19, 5.9676e-20, 4.7520e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "812000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3440e-40, 1.0398e-41, 2.5816e-21],\n", + " [3.0343e-22, 1.0671e-19, 5.9737e-20, 4.7402e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "813000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3456e-40, 1.0410e-41, 2.5754e-21],\n", + " [3.0356e-22, 1.0676e-19, 5.9766e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "814000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0431e-41, 2.5652e-21],\n", + " [3.0378e-22, 1.0683e-19, 5.9809e-20, 4.7243e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "815000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3460e-40, 1.0413e-41, 2.5743e-21],\n", + " [3.0358e-22, 1.0677e-19, 5.9769e-20, 4.7332e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "816000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3461e-40, 1.0413e-41, 2.5736e-21],\n", + " [3.0360e-22, 1.0677e-19, 5.9771e-20, 4.7326e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "817000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3394e-40, 1.0357e-41, 2.5995e-21],\n", + " [3.0302e-22, 1.0657e-19, 5.9644e-20, 4.7574e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "818000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0414e-41, 2.5735e-21],\n", + " [3.0361e-22, 1.0678e-19, 5.9777e-20, 4.7325e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "819000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3412e-40, 1.0374e-41, 2.5922e-21],\n", + " [3.0319e-22, 1.0663e-19, 5.9678e-20, 4.7504e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "820000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3512e-40, 1.0456e-41, 2.5541e-21],\n", + " [3.0404e-22, 1.0692e-19, 5.9868e-20, 4.7135e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "821000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3508e-40, 1.0452e-41, 2.5556e-21],\n", + " [3.0401e-22, 1.0692e-19, 5.9861e-20, 4.7151e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "822000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3454e-40, 1.0409e-41, 2.5760e-21],\n", + " [3.0356e-22, 1.0676e-19, 5.9758e-20, 4.7350e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "823000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3481e-40, 1.0430e-41, 2.5655e-21],\n", + " [3.0378e-22, 1.0683e-19, 5.9806e-20, 4.7247e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "824000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3354e-40, 1.0326e-41, 2.6144e-21],\n", + " [3.0268e-22, 1.0645e-19, 5.9569e-20, 4.7718e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "825000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3451e-40, 1.0406e-41, 2.5767e-21],\n", + " [3.0353e-22, 1.0674e-19, 5.9755e-20, 4.7355e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "826000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3493e-40, 1.0440e-41, 2.5609e-21],\n", + " [3.0387e-22, 1.0687e-19, 5.9831e-20, 4.7202e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "827000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3430e-40, 1.0389e-41, 2.5847e-21],\n", + " [3.0335e-22, 1.0668e-19, 5.9715e-20, 4.7432e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "828000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0445e-41, 2.5582e-21],\n", + " [3.0393e-22, 1.0688e-19, 5.9846e-20, 4.7175e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "829000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3493e-40, 1.0440e-41, 2.5607e-21],\n", + " [3.0387e-22, 1.0687e-19, 5.9831e-20, 4.7199e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "830000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0392e-41, 2.5828e-21],\n", + " [3.0338e-22, 1.0669e-19, 5.9722e-20, 4.7413e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "831000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3380e-40, 1.0347e-41, 2.6037e-21],\n", + " [3.0292e-22, 1.0653e-19, 5.9616e-20, 4.7616e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "832000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3393e-40, 1.0358e-41, 2.5987e-21],\n", + " [3.0304e-22, 1.0657e-19, 5.9645e-20, 4.7570e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "833000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3425e-40, 1.0384e-41, 2.5868e-21],\n", + " [3.0329e-22, 1.0666e-19, 5.9700e-20, 4.7452e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "834000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3364e-40, 1.0333e-41, 2.6106e-21],\n", + " [3.0277e-22, 1.0648e-19, 5.9584e-20, 4.7682e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "835000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3403e-40, 1.0365e-41, 2.5952e-21],\n", + " [3.0311e-22, 1.0660e-19, 5.9660e-20, 4.7535e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "836000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3429e-40, 1.0388e-41, 2.5850e-21],\n", + " [3.0332e-22, 1.0667e-19, 5.9711e-20, 4.7435e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "837000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.6115e-43, 1.3543e-40, 1.0480e-41, 2.5423e-21],\n", + " [3.0430e-22, 1.0702e-19, 5.9923e-20, 4.7023e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "838000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3368e-40, 1.0336e-41, 2.6091e-21],\n", + " [3.0279e-22, 1.0649e-19, 5.9591e-20, 4.7668e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "839000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3414e-40, 1.0374e-41, 2.5913e-21],\n", + " [3.0321e-22, 1.0663e-19, 5.9680e-20, 4.7496e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "840000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3411e-40, 1.0372e-41, 2.5921e-21],\n", + " [3.0318e-22, 1.0662e-19, 5.9673e-20, 4.7504e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "841000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0431e-41, 2.5646e-21],\n", + " [3.0379e-22, 1.0683e-19, 5.9809e-20, 4.7237e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "842000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3481e-40, 1.0430e-41, 2.5650e-21],\n", + " [3.0377e-22, 1.0683e-19, 5.9808e-20, 4.7241e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "843000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3478e-40, 1.0427e-41, 2.5657e-21],\n", + " [3.0375e-22, 1.0682e-19, 5.9800e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "844000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3437e-40, 1.0395e-41, 2.5816e-21],\n", + " [3.0340e-22, 1.0670e-19, 5.9726e-20, 4.7402e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "845000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3382e-40, 1.0349e-41, 2.6033e-21],\n", + " [3.0293e-22, 1.0653e-19, 5.9620e-20, 4.7612e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "846000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3500e-40, 1.0445e-41, 2.5582e-21],\n", + " [3.0395e-22, 1.0688e-19, 5.9841e-20, 4.7176e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "847000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3452e-40, 1.0406e-41, 2.5762e-21],\n", + " [3.0353e-22, 1.0674e-19, 5.9751e-20, 4.7350e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "848000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3383e-40, 1.0349e-41, 2.6026e-21],\n", + " [3.0294e-22, 1.0653e-19, 5.9620e-20, 4.7606e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "849000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3497e-40, 1.0444e-41, 2.5587e-21],\n", + " [3.0392e-22, 1.0688e-19, 5.9837e-20, 4.7182e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "850000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3457e-40, 1.0409e-41, 2.5744e-21],\n", + " [3.0357e-22, 1.0676e-19, 5.9755e-20, 4.7334e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "851000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3486e-40, 1.0434e-41, 2.5631e-21],\n", + " [3.0382e-22, 1.0684e-19, 5.9815e-20, 4.7224e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "852000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3398e-40, 1.0361e-41, 2.5971e-21],\n", + " [3.0306e-22, 1.0658e-19, 5.9645e-20, 4.7552e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "853000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3472e-40, 1.0423e-41, 2.5682e-21],\n", + " [3.0370e-22, 1.0680e-19, 5.9788e-20, 4.7273e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "854000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3423e-40, 1.0382e-41, 2.5869e-21],\n", + " [3.0328e-22, 1.0665e-19, 5.9693e-20, 4.7454e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "855000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3405e-40, 1.0367e-41, 2.5939e-21],\n", + " [3.0312e-22, 1.0660e-19, 5.9660e-20, 4.7520e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "856000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3401e-40, 1.0364e-41, 2.5952e-21],\n", + " [3.0309e-22, 1.0658e-19, 5.9653e-20, 4.7532e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "857000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3391e-40, 1.0356e-41, 2.5991e-21],\n", + " [3.0301e-22, 1.0655e-19, 5.9635e-20, 4.7571e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "858000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3448e-40, 1.0403e-41, 2.5769e-21],\n", + " [3.0349e-22, 1.0673e-19, 5.9742e-20, 4.7357e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "859000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3428e-40, 1.0385e-41, 2.5846e-21],\n", + " [3.0332e-22, 1.0667e-19, 5.9704e-20, 4.7433e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "860000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0389e-41, 2.5825e-21],\n", + " [3.0335e-22, 1.0668e-19, 5.9707e-20, 4.7412e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "861000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3371e-40, 1.0339e-41, 2.6068e-21],\n", + " [3.0284e-22, 1.0650e-19, 5.9595e-20, 4.7645e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "862000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3396e-40, 1.0358e-41, 2.5975e-21],\n", + " [3.0305e-22, 1.0657e-19, 5.9640e-20, 4.7557e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "863000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3371e-40, 1.0339e-41, 2.6068e-21],\n", + " [3.0284e-22, 1.0649e-19, 5.9593e-20, 4.7645e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "864000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3462e-40, 1.0413e-41, 2.5720e-21],\n", + " [3.0360e-22, 1.0677e-19, 5.9762e-20, 4.7309e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "865000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3382e-40, 1.0347e-41, 2.6026e-21],\n", + " [3.0294e-22, 1.0653e-19, 5.9609e-20, 4.7605e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "866000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3427e-40, 1.0384e-41, 2.5851e-21],\n", + " [3.0333e-22, 1.0666e-19, 5.9700e-20, 4.7433e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "867000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3426e-40, 1.0384e-41, 2.5853e-21],\n", + " [3.0331e-22, 1.0666e-19, 5.9700e-20, 4.7438e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "868000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3436e-40, 1.0391e-41, 2.5813e-21],\n", + " [3.0341e-22, 1.0668e-19, 5.9716e-20, 4.7400e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "869000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3477e-40, 1.0426e-41, 2.5660e-21],\n", + " [3.0375e-22, 1.0681e-19, 5.9797e-20, 4.7251e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "870000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0434e-41, 2.5617e-21],\n", + " [3.0384e-22, 1.0685e-19, 5.9811e-20, 4.7211e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "871000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0421e-41, 2.5681e-21],\n", + " [3.0371e-22, 1.0680e-19, 5.9786e-20, 4.7272e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "872000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0441e-41, 2.5587e-21],\n", + " [3.0392e-22, 1.0686e-19, 5.9828e-20, 4.7181e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "873000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0368e-41, 2.5926e-21],\n", + " [3.0315e-22, 1.0660e-19, 5.9658e-20, 4.7507e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "874000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3504e-40, 1.0448e-41, 2.5549e-21],\n", + " [3.0400e-22, 1.0689e-19, 5.9846e-20, 4.7145e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "875000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3419e-40, 1.0377e-41, 2.5878e-21],\n", + " [3.0325e-22, 1.0663e-19, 5.9682e-20, 4.7461e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "876000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3340e-40, 1.0311e-41, 2.6185e-21],\n", + " [3.0257e-22, 1.0639e-19, 5.9529e-20, 4.7757e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "877000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3489e-40, 1.0435e-41, 2.5608e-21],\n", + " [3.0385e-22, 1.0685e-19, 5.9811e-20, 4.7202e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "878000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0455e-41, 2.5516e-21],\n", + " [3.0405e-22, 1.0691e-19, 5.9861e-20, 4.7112e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "879000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3520e-40, 1.0461e-41, 2.5490e-21],\n", + " [3.0411e-22, 1.0694e-19, 5.9872e-20, 4.7089e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "880000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3475e-40, 1.0423e-41, 2.5658e-21],\n", + " [3.0374e-22, 1.0681e-19, 5.9786e-20, 4.7250e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "881000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3465e-40, 1.0414e-41, 2.5696e-21],\n", + " [3.0365e-22, 1.0677e-19, 5.9764e-20, 4.7287e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "882000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0427e-41, 2.5638e-21],\n", + " [3.0378e-22, 1.0681e-19, 5.9795e-20, 4.7230e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "883000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3518e-40, 1.0459e-41, 2.5491e-21],\n", + " [3.0410e-22, 1.0693e-19, 5.9870e-20, 4.7087e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "884000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3433e-40, 1.0388e-41, 2.5817e-21],\n", + " [3.0336e-22, 1.0667e-19, 5.9700e-20, 4.7404e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "885000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3356e-40, 1.0325e-41, 2.6112e-21],\n", + " [3.0272e-22, 1.0644e-19, 5.9560e-20, 4.7690e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "886000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3374e-40, 1.0339e-41, 2.6040e-21],\n", + " [3.0288e-22, 1.0650e-19, 5.9595e-20, 4.7619e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "887000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3402e-40, 1.0363e-41, 2.5931e-21],\n", + " [3.0311e-22, 1.0658e-19, 5.9644e-20, 4.7516e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "888000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3453e-40, 1.0405e-41, 2.5737e-21],\n", + " [3.0354e-22, 1.0673e-19, 5.9742e-20, 4.7326e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "889000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3391e-40, 1.0353e-41, 2.5978e-21],\n", + " [3.0300e-22, 1.0655e-19, 5.9624e-20, 4.7558e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "890000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3460e-40, 1.0410e-41, 2.5711e-21],\n", + " [3.0360e-22, 1.0676e-19, 5.9753e-20, 4.7302e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "891000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3410e-40, 1.0368e-41, 2.5901e-21],\n", + " [3.0317e-22, 1.0660e-19, 5.9658e-20, 4.7486e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "892000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3376e-40, 1.0342e-41, 2.6027e-21],\n", + " [3.0289e-22, 1.0650e-19, 5.9600e-20, 4.7607e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "893000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0433e-41, 2.5599e-21],\n", + " [3.0383e-22, 1.0683e-19, 5.9804e-20, 4.7192e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "894000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0351e-41, 2.5980e-21],\n", + " [3.0299e-22, 1.0654e-19, 5.9620e-20, 4.7564e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "895000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3322e-40, 1.0297e-41, 2.6241e-21],\n", + " [3.0242e-22, 1.0634e-19, 5.9493e-20, 4.7813e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "896000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3436e-40, 1.0391e-41, 2.5795e-21],\n", + " [3.0341e-22, 1.0668e-19, 5.9709e-20, 4.7383e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "897000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3487e-40, 1.0433e-41, 2.5600e-21],\n", + " [3.0383e-22, 1.0683e-19, 5.9804e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "898000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3412e-40, 1.0370e-41, 2.5892e-21],\n", + " [3.0319e-22, 1.0661e-19, 5.9660e-20, 4.7475e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "899000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3354e-40, 1.0322e-41, 2.6111e-21],\n", + " [3.0269e-22, 1.0644e-19, 5.9553e-20, 4.7686e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "900000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3349e-40, 1.0318e-41, 2.6128e-21],\n", + " [3.0265e-22, 1.0642e-19, 5.9538e-20, 4.7703e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "901000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3443e-40, 1.0396e-41, 2.5762e-21],\n", + " [3.0346e-22, 1.0670e-19, 5.9722e-20, 4.7352e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "902000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3445e-40, 1.0396e-41, 2.5758e-21],\n", + " [3.0346e-22, 1.0670e-19, 5.9718e-20, 4.7347e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "903000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3382e-40, 1.0344e-41, 2.6001e-21],\n", + " [3.0292e-22, 1.0651e-19, 5.9602e-20, 4.7580e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "904000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3418e-40, 1.0375e-41, 2.5862e-21],\n", + " [3.0325e-22, 1.0662e-19, 5.9671e-20, 4.7448e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "905000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3448e-40, 1.0399e-41, 2.5747e-21],\n", + " [3.0350e-22, 1.0672e-19, 5.9729e-20, 4.7337e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "906000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3391e-40, 1.0351e-41, 2.5968e-21],\n", + " [3.0300e-22, 1.0654e-19, 5.9618e-20, 4.7548e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "907000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3449e-40, 1.0400e-41, 2.5740e-21],\n", + " [3.0352e-22, 1.0672e-19, 5.9731e-20, 4.7331e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "908000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5695e-43, 1.3292e-40, 1.0270e-41, 2.6356e-21],\n", + " [3.0216e-22, 1.0624e-19, 5.9429e-20, 4.7922e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "909000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3363e-40, 1.0330e-41, 2.6071e-21],\n", + " [3.0279e-22, 1.0646e-19, 5.9567e-20, 4.7648e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "910000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3388e-40, 1.0350e-41, 2.5978e-21],\n", + " [3.0300e-22, 1.0653e-19, 5.9616e-20, 4.7559e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "911000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3331e-40, 1.0302e-41, 2.6203e-21],\n", + " [3.0251e-22, 1.0636e-19, 5.9507e-20, 4.7776e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "912000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5695e-43, 1.3291e-40, 1.0270e-41, 2.6353e-21],\n", + " [3.0215e-22, 1.0624e-19, 5.9426e-20, 4.7919e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "913000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3314e-40, 1.0288e-41, 2.6266e-21],\n", + " [3.0235e-22, 1.0631e-19, 5.9471e-20, 4.7836e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "914000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3473e-40, 1.0420e-41, 2.5650e-21],\n", + " [3.0371e-22, 1.0679e-19, 5.9777e-20, 4.7244e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "915000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3494e-40, 1.0435e-41, 2.5570e-21],\n", + " [3.0389e-22, 1.0685e-19, 5.9811e-20, 4.7162e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "916000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0388e-41, 2.5792e-21],\n", + " [3.0337e-22, 1.0667e-19, 5.9702e-20, 4.7381e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "917000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3438e-40, 1.0391e-41, 2.5783e-21],\n", + " [3.0341e-22, 1.0668e-19, 5.9704e-20, 4.7370e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "918000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3505e-40, 1.0445e-41, 2.5526e-21],\n", + " [3.0398e-22, 1.0688e-19, 5.9830e-20, 4.7122e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "919000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3454e-40, 1.0403e-41, 2.5717e-21],\n", + " [3.0354e-22, 1.0673e-19, 5.9737e-20, 4.7306e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "920000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3524e-40, 1.0461e-41, 2.5447e-21],\n", + " [3.0414e-22, 1.0694e-19, 5.9868e-20, 4.7046e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "921000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3378e-40, 1.0342e-41, 2.6009e-21],\n", + " [3.0290e-22, 1.0650e-19, 5.9589e-20, 4.7590e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "922000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3454e-40, 1.0403e-41, 2.5712e-21],\n", + " [3.0355e-22, 1.0673e-19, 5.9737e-20, 4.7302e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "923000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3432e-40, 1.0386e-41, 2.5796e-21],\n", + " [3.0337e-22, 1.0666e-19, 5.9695e-20, 4.7383e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "924000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3470e-40, 1.0417e-41, 2.5656e-21],\n", + " [3.0367e-22, 1.0677e-19, 5.9762e-20, 4.7247e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "925000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3410e-40, 1.0367e-41, 2.5885e-21],\n", + " [3.0318e-22, 1.0660e-19, 5.9653e-20, 4.7470e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "926000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0440e-41, 2.5552e-21],\n", + " [3.0390e-22, 1.0686e-19, 5.9817e-20, 4.7146e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "927000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3482e-40, 1.0427e-41, 2.5606e-21],\n", + " [3.0380e-22, 1.0681e-19, 5.9788e-20, 4.7199e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "928000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3464e-40, 1.0412e-41, 2.5672e-21],\n", + " [3.0364e-22, 1.0676e-19, 5.9753e-20, 4.7263e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "929000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3374e-40, 1.0339e-41, 2.6018e-21],\n", + " [3.0288e-22, 1.0649e-19, 5.9585e-20, 4.7597e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "930000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3410e-40, 1.0367e-41, 2.5883e-21],\n", + " [3.0318e-22, 1.0659e-19, 5.9649e-20, 4.7467e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "931000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3351e-40, 1.0319e-41, 2.6116e-21],\n", + " [3.0266e-22, 1.0641e-19, 5.9535e-20, 4.7690e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "932000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3410e-40, 1.0367e-41, 2.5884e-21],\n", + " [3.0317e-22, 1.0660e-19, 5.9651e-20, 4.7468e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "933000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3417e-40, 1.0374e-41, 2.5856e-21],\n", + " [3.0323e-22, 1.0661e-19, 5.9664e-20, 4.7441e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "934000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3415e-40, 1.0371e-41, 2.5864e-21],\n", + " [3.0321e-22, 1.0661e-19, 5.9660e-20, 4.7449e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "935000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3498e-40, 1.0440e-41, 2.5544e-21],\n", + " [3.0392e-22, 1.0686e-19, 5.9817e-20, 4.7138e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "936000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3496e-40, 1.0438e-41, 2.5557e-21],\n", + " [3.0391e-22, 1.0685e-19, 5.9809e-20, 4.7151e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "937000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0417e-41, 2.5652e-21],\n", + " [3.0369e-22, 1.0677e-19, 5.9762e-20, 4.7244e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "938000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3495e-40, 1.0437e-41, 2.5558e-21],\n", + " [3.0390e-22, 1.0685e-19, 5.9809e-20, 4.7152e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "939000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3442e-40, 1.0393e-41, 2.5762e-21],\n", + " [3.0344e-22, 1.0669e-19, 5.9709e-20, 4.7351e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "940000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3421e-40, 1.0377e-41, 2.5843e-21],\n", + " [3.0329e-22, 1.0663e-19, 5.9673e-20, 4.7426e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "941000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5835e-43, 1.3400e-40, 1.0358e-41, 2.5926e-21],\n", + " [3.0307e-22, 1.0656e-19, 5.9627e-20, 4.7509e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "942000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3358e-40, 1.0322e-41, 2.6091e-21],\n", + " [3.0270e-22, 1.0643e-19, 5.9544e-20, 4.7670e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "943000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0392e-41, 2.5762e-21],\n", + " [3.0344e-22, 1.0668e-19, 5.9706e-20, 4.7350e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "944000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3468e-40, 1.0414e-41, 2.5662e-21],\n", + " [3.0368e-22, 1.0677e-19, 5.9760e-20, 4.7254e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "945000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3427e-40, 1.0381e-41, 2.5817e-21],\n", + " [3.0331e-22, 1.0664e-19, 5.9680e-20, 4.7404e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "946000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.6115e-43, 1.3546e-40, 1.0479e-41, 2.5368e-21],\n", + " [3.0432e-22, 1.0700e-19, 5.9904e-20, 4.6967e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "947000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3471e-40, 1.0417e-41, 2.5649e-21],\n", + " [3.0370e-22, 1.0678e-19, 5.9764e-20, 4.7241e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "948000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3357e-40, 1.0323e-41, 2.6091e-21],\n", + " [3.0272e-22, 1.0643e-19, 5.9547e-20, 4.7668e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "949000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3422e-40, 1.0378e-41, 2.5834e-21],\n", + " [3.0329e-22, 1.0663e-19, 5.9675e-20, 4.7420e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "950000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3402e-40, 1.0361e-41, 2.5910e-21],\n", + " [3.0312e-22, 1.0657e-19, 5.9631e-20, 4.7493e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "951000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3432e-40, 1.0385e-41, 2.5800e-21],\n", + " [3.0335e-22, 1.0665e-19, 5.9689e-20, 4.7386e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "952000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3407e-40, 1.0365e-41, 2.5892e-21],\n", + " [3.0316e-22, 1.0658e-19, 5.9644e-20, 4.7475e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "953000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3426e-40, 1.0379e-41, 2.5818e-21],\n", + " [3.0331e-22, 1.0663e-19, 5.9678e-20, 4.7403e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "954000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3405e-40, 1.0363e-41, 2.5899e-21],\n", + " [3.0315e-22, 1.0658e-19, 5.9638e-20, 4.7481e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "955000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3455e-40, 1.0403e-41, 2.5709e-21],\n", + " [3.0355e-22, 1.0672e-19, 5.9729e-20, 4.7300e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "956000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3430e-40, 1.0384e-41, 2.5806e-21],\n", + " [3.0334e-22, 1.0665e-19, 5.9686e-20, 4.7393e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "957000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3469e-40, 1.0416e-41, 2.5656e-21],\n", + " [3.0368e-22, 1.0677e-19, 5.9758e-20, 4.7248e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "958000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3456e-40, 1.0405e-41, 2.5704e-21],\n", + " [3.0356e-22, 1.0673e-19, 5.9735e-20, 4.7295e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "959000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3465e-40, 1.0412e-41, 2.5671e-21],\n", + " [3.0365e-22, 1.0675e-19, 5.9751e-20, 4.7263e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "960000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3377e-40, 1.0339e-41, 2.6009e-21],\n", + " [3.0289e-22, 1.0649e-19, 5.9585e-20, 4.7587e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "961000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3360e-40, 1.0326e-41, 2.6072e-21],\n", + " [3.0275e-22, 1.0644e-19, 5.9553e-20, 4.7650e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "962000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0349e-41, 2.5966e-21],\n", + " [3.0298e-22, 1.0652e-19, 5.9605e-20, 4.7546e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "963000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3430e-40, 1.0382e-41, 2.5806e-21],\n", + " [3.0333e-22, 1.0665e-19, 5.9684e-20, 4.7391e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "964000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3394e-40, 1.0353e-41, 2.5939e-21],\n", + " [3.0306e-22, 1.0654e-19, 5.9615e-20, 4.7520e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "965000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3412e-40, 1.0367e-41, 2.5877e-21],\n", + " [3.0317e-22, 1.0659e-19, 5.9647e-20, 4.7461e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "966000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3358e-40, 1.0323e-41, 2.6082e-21],\n", + " [3.0273e-22, 1.0643e-19, 5.9545e-20, 4.7660e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "967000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3437e-40, 1.0389e-41, 2.5772e-21],\n", + " [3.0342e-22, 1.0667e-19, 5.9696e-20, 4.7360e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "968000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3376e-40, 1.0337e-41, 2.6014e-21],\n", + " [3.0288e-22, 1.0649e-19, 5.9580e-20, 4.7593e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "969000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3422e-40, 1.0377e-41, 2.5832e-21],\n", + " [3.0329e-22, 1.0662e-19, 5.9667e-20, 4.7419e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "970000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3396e-40, 1.0356e-41, 2.5933e-21],\n", + " [3.0306e-22, 1.0654e-19, 5.9620e-20, 4.7516e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "971000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3440e-40, 1.0391e-41, 2.5764e-21],\n", + " [3.0343e-22, 1.0668e-19, 5.9702e-20, 4.7352e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "972000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3402e-40, 1.0360e-41, 2.5911e-21],\n", + " [3.0310e-22, 1.0657e-19, 5.9631e-20, 4.7494e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "973000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0385e-41, 2.5786e-21],\n", + " [3.0339e-22, 1.0666e-19, 5.9689e-20, 4.7374e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "974000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0392e-41, 2.5757e-21],\n", + " [3.0343e-22, 1.0668e-19, 5.9702e-20, 4.7344e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "975000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3452e-40, 1.0400e-41, 2.5724e-21],\n", + " [3.0353e-22, 1.0671e-19, 5.9720e-20, 4.7315e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "976000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3417e-40, 1.0371e-41, 2.5854e-21],\n", + " [3.0322e-22, 1.0661e-19, 5.9655e-20, 4.7439e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "977000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3357e-40, 1.0322e-41, 2.6085e-21],\n", + " [3.0273e-22, 1.0643e-19, 5.9547e-20, 4.7664e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "978000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3457e-40, 1.0405e-41, 2.5696e-21],\n", + " [3.0358e-22, 1.0673e-19, 5.9735e-20, 4.7287e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "979000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3421e-40, 1.0375e-41, 2.5834e-21],\n", + " [3.0329e-22, 1.0662e-19, 5.9665e-20, 4.7419e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "980000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3472e-40, 1.0417e-41, 2.5639e-21],\n", + " [3.0369e-22, 1.0677e-19, 5.9762e-20, 4.7233e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "981000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3523e-40, 1.0459e-41, 2.5447e-21],\n", + " [3.0413e-22, 1.0692e-19, 5.9853e-20, 4.7044e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "982000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3434e-40, 1.0386e-41, 2.5782e-21],\n", + " [3.0337e-22, 1.0665e-19, 5.9687e-20, 4.7370e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "983000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3464e-40, 1.0410e-41, 2.5668e-21],\n", + " [3.0363e-22, 1.0674e-19, 5.9742e-20, 4.7260e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "984000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3396e-40, 1.0354e-41, 2.5929e-21],\n", + " [3.0306e-22, 1.0654e-19, 5.9616e-20, 4.7512e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "985000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3433e-40, 1.0385e-41, 2.5784e-21],\n", + " [3.0336e-22, 1.0665e-19, 5.9687e-20, 4.7371e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "986000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3404e-40, 1.0361e-41, 2.5894e-21],\n", + " [3.0312e-22, 1.0657e-19, 5.9629e-20, 4.7478e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "987000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3442e-40, 1.0392e-41, 2.5750e-21],\n", + " [3.0344e-22, 1.0668e-19, 5.9698e-20, 4.7338e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "988000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3374e-40, 1.0336e-41, 2.6008e-21],\n", + " [3.0287e-22, 1.0647e-19, 5.9573e-20, 4.7589e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "989000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3430e-40, 1.0382e-41, 2.5795e-21],\n", + " [3.0334e-22, 1.0664e-19, 5.9678e-20, 4.7384e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "990000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3523e-40, 1.0459e-41, 2.5443e-21],\n", + " [3.0414e-22, 1.0692e-19, 5.9853e-20, 4.7040e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "991000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3480e-40, 1.0423e-41, 2.5602e-21],\n", + " [3.0376e-22, 1.0679e-19, 5.9773e-20, 4.7194e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "992000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3513e-40, 1.0449e-41, 2.5479e-21],\n", + " [3.0405e-22, 1.0689e-19, 5.9833e-20, 4.7076e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "993000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3441e-40, 1.0391e-41, 2.5751e-21],\n", + " [3.0343e-22, 1.0667e-19, 5.9698e-20, 4.7341e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "994000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3389e-40, 1.0347e-41, 2.5949e-21],\n", + " [3.0299e-22, 1.0651e-19, 5.9595e-20, 4.7532e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "995000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3503e-40, 1.0442e-41, 2.5510e-21],\n", + " [3.0396e-22, 1.0686e-19, 5.9811e-20, 4.7104e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "996000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5975e-43, 1.3499e-40, 1.0438e-41, 2.5528e-21],\n", + " [3.0394e-22, 1.0685e-19, 5.9806e-20, 4.7126e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "997000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3418e-40, 1.0371e-41, 2.5839e-21],\n", + " [3.0324e-22, 1.0660e-19, 5.9653e-20, 4.7426e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "998000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6162, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[1.5835e-43, 1.3351e-40, 1.0316e-41, 2.6104e-21],\n", + " [3.0267e-22, 1.0640e-19, 5.9525e-20, 4.7682e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "999000 actions: tensor([3, 3, 3])\n", + "loss= tensor(2.6125, grad_fn=) , return= 16223.8125\n", + "discReturns/1000= tensor([6.4228, 6.5977, 5.6536])\n", + "actionProbs tensor([[1.5975e-43, 1.3424e-40, 1.0377e-41, 2.5817e-21],\n", + " [3.0331e-22, 1.0663e-19, 5.9667e-20, 4.7404e-12],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.0200.0
1205.0195.0
2207.5192.5
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.0 200.0\n", + "1 205.0 195.0\n", + "2 207.5 192.5" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16223.8125\n", + "1 11694.8125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05103.25004160.2500
15467.00003844.0000
25653.56253690.5625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5103.2500 4160.2500\n", + "1 5467.0000 3844.0000\n", + "2 5653.5625 3690.5625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0125.50135.50
1128.00133.00
2129.25131.75
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 125.50 135.50\n", + "1 128.00 133.00\n", + "2 129.25 131.75" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmUUlEQVR4nO3deXSc9X3v8fdXu6WRbVm7LcubZNmyDITIBAh4YbVY7PYmOYXbE0JJL+U2nCS9TZPStCG3uTlNmnS595CeU26gKU0C7U3b4AA2OBAg7DGLsbwv2Ea2ZW1etFjr/O4fv5FmJGRrsUYzGn1e5zzHmmeeGX01fvzxo9/ze76POecQEZHEkhTrAkREZOIp3EVEEpDCXUQkASncRUQSkMJdRCQBKdxFRBLQiOFuZo+aWYOZ1Uas+5aZvW9m75nZc2Y2N+K5S8zsdTPbaWY7zCwjWsWLiMjwbKR57ma2GmgDHnPOVYXWzXTOnQ19/UWg0jl3n5mlAO8An3XObTezXOC0c64vqj+FiIgMMuKRu3PuZaBlyLqzEQ+zgP7/IW4C3nfObQ9t16xgFxGZfCnjfaGZfRu4CzgDrAutXgo4M3sWyAeecM799Xlefy9wL0BWVtbHly1bNt5SRESmpbfffrvJOZc/3HMjDssAmNlC4Kn+YZkhzz0AZDjnHjSzrwBfAFYBHcDzwJ87556/0PtXV1e7bdu2jViHiIiEmdnbzrnq4Z6biNkyPwU+Ffq6DnjJOdfknOsAngEun4DvISIiYzCucDez8oiHG4A9oa+fBS4xs8zQydU1wK6LK1FERMZqxDF3M3scWAvkmVkd8CBwi5lVAEHgCHAfgHPulJn9LfAb/EnWZ5xzT0epdhEROY8Rw905d+cwqx+5wPY/Bn58MUWJiEyWnp4e6urq6OzsjHUp55WRkUFJSQmpqamjfs24Z8uIiCSCuro6srOzWbhwIWYW63I+wjlHc3MzdXV1LFq0aNSvU/sBEZnWOjs7yc3NjctgBzAzcnNzx/ybhcJdRKa9eA32fuOpb2qHe1cbbHkAjrwGQV0IKyLSb2qHe/0O+M0j8E818DfL4Kk/goO/gr7eWFcmIjJqW7ZsoaKigrKyMr7zne9MyHtO7ROqC66Crx6Efc/C7k2w/QnY9ijMyIGKW6FyIyxeAynpsa5URGRYfX19fOELX2Dr1q2UlJSwatUqNmzYQGVl5UW979QOd4D0bFj5ab90d8CBX/qg3/UkvPdjSJ8JS9dD5QZYcj2kZca6YhGRAW+99RZlZWUsXrwYgDvuuIMnn3xS4T5IWqYP8coN0NsFh16EXZtg79Ow498gNRPKb4TlG2Dpzf4/BhGRkP/5i53sOn525A3HoHLuTB68fcV5nz927Bjz588feFxSUsKbb7550d83scI9Ukq6D/ClN0Pf38PhV/wR/e5f+KP65HQou94HfcV6P5QjIjLJhmveOBGzdxI33CMlp8KSdX655ftw9I1w0O99BpJSYNEaf8S/7DbIyot1xSISAxc6wo6WkpISPvzww4HHdXV1zJ079wKvGJ2pPVtmPJKSYeEnoea78OVa+P3n4co/hJaD8IsvwffL4Ue3wVv/F86eiHW1IpLgVq1axf79+/nggw/o7u7miSeeYMOGDRf9vtPjyP18kpKgpNovN/4l1L/vx+h3b4JnvuKX+Z/wQzeVG2B2aawrFpEEk5KSwkMPPcTNN99MX18f99xzDytWXPxvEKO6WUe0xeXNOhr2hGbdbIKTO/y64st8yC/fCHllMS1PRCbG7t27Wb58eazLGNFwdV7oZh3T+8j9QgqW+WXNV6H5YPhE7PN/6ZeCFaGg3wAFyyHOL18WkelF4T4auUvgmi/75fSHPuh3b4IXvwMv/hXkloWHboovU9CLSMwp3Mdq9ny46g/90loPe57yQzev/m945W/9uPzyDf7q2HnVflxfRGSSKdwvRnYRrPp9v7Q3+4uldm2CN/8RXn8Isoth+e0+7Bdc7WfqiIhMAoX7RMnKhcvv8su50+F+N+88Bm89DJl5sCzU72bRaj/3XkQkShTu0TBjNlz6O37paoMDW/3J2B0/g3f+GTJmQ8Utfox+8TpIzYh1xSKSYBTu0ZYegBW/7Zeec3DwBT90s+dp2P5TSAv4FgnLN/i+N2lZsa5YRCbZPffcw1NPPUVBQQG1tbUT8p4K98mUOsMPzSy7FXq74YOXYfeTPuhr/x1SZkD5DX4e/dKbIWNmrCsWkUlw9913c//993PXXXdN2Hsq3GMlJc0HefkNcOvfwZFXQ/1unvJTLZPT/JBN5QY/hJM5J9YVi0iUrF69msOHD0/oeyrc40Fyir+pyOI1UPM9qHsr3AZh/7NgybDoWj90s/x2CBTEumKRxLT5T/0d3iZS0UqomZi7K42Fwj3eJCVB6ZV+ufnbcPzd8M1Hnv4f8PQf+2mV/UE/a16sKxaROKRwj2dmMO9yv1z/IJzcGe53s+VrfplXHW6DMGdRrCsWmdpicIQdLQr3qcIMiqr8su7PoGm/P5rfvQm2fsMvRSv9PPrlGyF/aawrFpEY0rXxU1VeOaz+CvzBy/Cl7XDjtyAlA174X/CDVfCDT8AL3/bjh3HQ+VNEzu/OO+/kqquuYu/evZSUlPDII49c9Huq5W+iOXMs3O/m6GvggjBncagNwkY/xKPGZiID1PJXpoZZ8+ATf+CXtgY/h37Xk/D6D3xzs1nzw/1u5n9Cjc1EEpTCPZEFCqD69/zS0QJ7N/sx+t/8EN74BwgU+nvGVm6ABdf4KZkikhD0r3m6yJwDH/tdv3Sehf3P+SP6934K2x6BGXMiGput8RdZiUwTzjksjocrxzN8PmK4m9mjwG1Ag3OuKrTuW8BGIAg0AHc7545HvKYU2AV80zn3/TFXJdGVMRNWftov3R1w4Jc+6Hf+HN79F0ifBRXr/dBN2fW+bYJIgsrIyKC5uZnc3Ny4DHjnHM3NzWRkjK3B4IgnVM1sNdAGPBYR7jOdc2dDX38RqHTO3Rfxmn/HB/+bowl3nVCNEz2dcOhFP3Sz52noPA2pWb6hWeVGKL/JN0ITSSA9PT3U1dXR2dkZ61LOKyMjg5KSElJTB7cKv6gTqs65l81s4ZB1ZyMeZgED/0OY2W8Bh4D2UVcu8SE1wx+xV6yHvh44/OtQB8unYNfP/VTLJdf7Mfql631rY5EpLjU1lUWLEu8CwHGPuZvZt4G7gDPAutC6LOBrwI3AV0Z4/b3AvQClpaXjLUOiJTkVllznl1v/Bo6+Hup38wt/x6mkVN8LZ/kGf1I2KzfWFYtIhFHNcw8duT/VPywz5LkHgAzn3INm9n3gLefcv5nZN4E2DcskmGAQjr3tWxXv2gSnj4AlwcJrwv1usotiXaXItHChYZmJCPcFwNPOuSoz+zUwP/TUbPy4+zeccw9d6P0V7lOUc3Bie7jfTfN+wPz8+cpQ0M/Wb2Ui0TLhFzGZWblzbn/o4QZgD4Bz7tqIbb6JP3K/YLDLFGYGcy/zy3V/AY17wq2Kn/0zv8z9WKjfzQbIXRLrikWmjdFMhXwcWAvkmVkd8CBwi5lV4I/MjwD3nf8dZFowg4Llfln7NWg+GG5V/Mtv+qWwyod85QbIX6Y2CCJRpN4yEn2nj/oTsbs2wYdvAg5yy8OtiosvVdCLjMNFj7lHm8J9Gmmt90G/exMcfsU3Npu9IBT0G2Hex9XvRmSUFO4Sn9qb/MVSuzfBoZcg2APZc/2J2MoNUHoVJCXHukqRuKVwl/h37jTs2+KHbg78Evq6ICs/3Nhs4bV+7r2IDFC4y9TS1RZubLZ/K/S0Q8Zs39hs+QZYsg5S0mNdpUjMqZ+7TC3pAaj6L37pOQcHnvdDN7ufgvd+AmnZsPRmP8Wy7AZIy4x1xSJxR+Eu8S11Biy/zS+93fDBS/6Ifs/TUPszSM30Ad/f2CxjZqwrFokLGpaRqamvF468Em5s1nYSktN8L5zlG6CixvewF0lgGnOXxBbsgw/fCrdBOFsHSSmwaHW4sVkgP9ZVikw4hbtMH87B8Xd8yO96Ek594BublV4d7nczc26sqxSZEAp3mZ6cg5O14X43jXv8+pJV4TYIOQtjWqLIxVC4iwA07gu3Kq5/368rvjQU9Bshrzy29YmMkcJdZKiWD8Jj9MdC+17+8nC/m8IV6ncjcU/hLnIhZ+r8HPrdm+DIa4CDOYvDQzfFl6kNgsQlhbvIaLU1hO4Zuwk+eBlcn793bG455C/1rYrzQn/OWQwpabGuWKYxhbvIeHS0+DYI9TugaZ8/IXv6aPj5pBQf8PkVkFfhAz9/qf+PQFfNyiRQ+wGR8cicA5fe4Zd+3e3QtB8a90LTXv9nwx7Y84w/ygfAIGdBKPD7l9ARv66glUmicBcZi7Ss8K0FI/V2+btP9Qd+/3LoV9DXHd4ue25E4Ecc8WflTuZPIdOAwl1kIqSkQ2GlXyL19cLpI35Ipz/wm/bCO//iu132y8wdPJ7fH/7ZxZq1I+OicBeJpuQUf2Pw3CW+ZXG/YBDOHgsF/p7wEf/O/4DOM+Ht0mdGBH5E8M8q1R2r5IIU7iKxkJQEs+f7pfyG8Hrn/IydQcM7e/yJ3fd+HN4uZYa/6Gro8M6cRbqpiQAKd5H4YgbZhX5ZtHrwcx0toVk7EcM7R9+AHf8vvE1Sqv8tYSDwQ0tuOaRmTO7PIjGlcBeZKjLnQOmVfonU1RYO/f4j/vpafyNyF/TbWJK/EXnkeH5+hR/ySc+e/J9Fok7hLjLVpQdg3uV+idTTCS0HB5/Mbdzr71Eb7AlvN7NkmBk8FeqHP8Up3EUSVWqG75FTuGLw+r5e3wq5fzy//4h/22vQey68XVb+8DN4AoWawTMFKNxFppvkFH8yNq/c376wXzAIZz6MGN4JBf+On0FXxAyejFkfvUArv8L/BqAZPHFD4S4iXlKSv7I2ZwEsvSm83jlorf/oBVr7tsC7/xLeLjUzdJQ/ZAZPzkL/H4pMKn3iInJhZjCz2C+L1w5+rr15cOg37YXDr8D7/xreJjkNcsuGmcFT5i/+kqhQuIvI+GXlQtbVsODqwes7z/oePJHDO8ffg50/B0LNCi3Zz8sfNMQTmsGTljXJP0jiUbiLyMTLmAklH/dLpJ5z0Hxg8AVajXth/7MQ7A1vN6t08BW5eRX+8Yycyf05pjCFu4hMntQZULTSL5H6eqDl0ODhncY9fointzO8XaBwyPBOKPyz8jWDZ4gRw93MHgVuAxqcc1Whdd8CNgJBoAG42zl33MxuBL4DpAHdwJ84516IVvEikiCSU8PDMpGCfb6HfuQFWo17YfsT0N0a3m5GzkeHd/KXwcx50zb0R7xZh5mtBtqAxyLCfaZz7mzo6y8Clc65+8zsY8DJUNBXAc865+aNVIRu1iEiY+IctJ746AVajXvgXEt4u7TAMDN4KvwMngS4deJF3azDOfeymS0csu5sxMMsQmdInHPvRqzfCWSYWbpzrmvMVYuInI8ZzJzrlyXXDX6uvSmi22boDlqHXoTtj4e3SU4PN16LPOKfsyRhbp047jF3M/s2cBdwBlg3zCafAt49X7Cb2b3AvQClpaXjLUNEZLCsPL8s/OTg9Z1noHHf4Bk8ddug9j8YNIMnd8lHr8qdgrdOHNU9VENH7k/1D8sMee4BIMM592DEuhXAJuAm59zBkd5fwzIiEjPdHdC8f/DQTtM+f2etyFsnzi4dctvE0AyejFkxKz3a91D9KfA08GDom5UA/wncNZpgFxGJqbRMKL7UL5F6u0ON1/YOPqF76CXoixiQyC4+zwyevMn9OYYYV7ibWblzbn/o4QZgT2j9bHzQP+Cce3VCKhQRiYWUNChY7pdIwT44dTg8nt8f/u/9BLrbwttl5g5zgVaFP08wCTN4RjMV8nFgLZBnZnX4I/RbzKwCPxXyCHBfaPP7gTLgL8zsL0LrbnLONUx04SIiMZGUHL51YkVNeL1zoVsn7vFj+/3Bv/M/ofN0eLu07MGBX3IFLLhqwssc1Zh7tGnMXUQSlnPQ3vjRGTyNe6HtJKz8DHzqh+N662iPuYuIyPmYQaDAL4uuHfzcuVO+JUMUKNxFRGJlRk7U+uWos76ISAJSuIuIJCCFu4hIAlK4i4gkIIW7iEgCUriLiCQghbuISAJSuIuIJCCFu4hIAlK4i4gkIIW7iEgCUriLiCQghbuISAJSuIuIJCCFu4hIAlK4i4gkIIW7iEgCUriLiCQghbuISAJSuIuIJCCFu4hIAlK4i4gkIIW7iEgCUriLiCQghbuISAJSuIuIJCCFu4hIAlK4i4gkIIW7iEgCGjHczexRM2sws9qIdd8ys/fN7D0ze87M5kY894CZHTCzvWZ2c7QKFxGR8xvNkfuPgPVD1n3POXeJc+4y4CngGwBmVgncAawIveYfzCx5wqoVEZFRGTHcnXMvAy1D1p2NeJgFuNDXG4EnnHNdzrkPgAPAFRNUq4iIjFLKeF9oZt8G7gLOAOtCq+cBb0RsVhdaN9zr7wXuBSgtLR1vGSIiMoxxn1B1zn3dOTcf+Alwf2i1DbfpeV7/sHOu2jlXnZ+fP94yRERkGBMxW+anwKdCX9cB8yOeKwGOT8D3EBGRMRhXuJtZecTDDcCe0NebgDvMLN3MFgHlwFsXV6KIiIzViGPuZvY4sBbIM7M64EHgFjOrAILAEeA+AOfcTjP7N2AX0At8wTnXF6XaRUTkPMy5YYfEJ1V1dbXbtm1brMsQEZlSzOxt51z1cM/pClURkQSkcBcRSUAKdxGRBKRwFxFJQAp3EZEEpHAXEUlACncRkQSkcBcRiaHevmBU3nfcXSFFRGR0nHM0tnVx4GQbBxrb2H+yjQMNbexvaGNdRT7f+8ylE/49Fe4iIhMkGHQcP3OOAw2h8B4I81bOdvYObJedkUJZQYDrluXzybK8qNSicBcRGaPeviBHWzoGjr4P9v/Z2EZHd7idVm5WGmUFAW6/dC7lBQHKCrIpLwxQkJ2O2XAd0ieOwl1E5Dy6evs43NTB/obWQUF+qLGd7oix8uJZGZQVBPidVfMpL8imrCBAWUGAOVlpMatd4S4i015Hdy8HG9o50Ng6MB5+oKGNIy0d9AV9c0UzmJ+TSXlBgDUV+ZTlBygvzGZJfhbZGakx/gk+SuEuItPGmXM9oeAOH4nvP9nGsdPnBrZJSTIW5mVRUZTNrZcUDxyFL8kPkJGaHMPqx0bhLiIJxTlHc3t36Ag8HOIHGtpoaO0a2C49JYkl+QE+viCHO1bNp6wgQHlhgAW5WaQmT/1Z4gp3EZmSnHOcONM5ENyRQX66o2dgu0B6CksKAqxemu8DvCBAeUE283JmkJwU3ZOasaRwF5G41hd0fBgxMyUyyNsjZqbkZKZSXpBNTVVxaGaKPxIvmpkR9Zkp8UjhLiJxobs3yJHm9oEA9+PhrRxqaqe7NzwzpXBmOmUFAT5TPX9gPLy8IEBuID2G1ccfhbuITKpz3X0cbPRzwvefbBuYZnikuYPeYPi2nyU5MyjvH07JD1BW6E9qzpoRfzNT4pHCXUSiorWzZ8hQig/yulPn6L91c3KSsSDXTy9cX1U0MEd8cX4WmWmKp4uhT09ELkpzW9dHQvxAQxv1ZzsHtklLSWJxXhaXlszm05eHZ6YszM0iLWXqz0yJRwp3ERmRc46TZ7sGXanZH+It7d0D22WmJVNWEODqstzQWHg25QUB5s/JTOiZKfFI4S4iA4JBR92pcwNXavaH+MGGNlq7wo2vZs1IpbwgwE2VhaGjcD+cUjwzgySFeFxQuItMQz19QY40d3CgoTWic2Ebh5ra6OwJz0zJz06nvCDAb18+j/KCAEtCR+N5gbRpOb1wKlG4iySwzp4+DjW2s7+hdaBz4YGGNj5oah80M2Xe7Bl+OGVJ7sB4eFl+NrMyNTNlqlK4iySAtq7eQTNS+oP8w5YO+jM8yWBBbhZlBQFuqCwcuNBnSX6ArHRFQaLR36jIFHKqvXvInXz8Cc4TZ8IzU1KTjcV5AarmzuK3Lps3aGbKVGp8JRdH4S4SZ5xzNLZ2DVyh2R/mBxvbaGoLz0yZkZrMkoIsrlycO+hKzdI5maQkQOMruTgKd5EYCQYdx06f40BjGwcirtTc39BG65BbspUXBLhuWYG/yKcwQFl+gHmzZ2hmipyXwl0kynr7ghwJNb4aPC7ezrmecOOrvIC/JdvGy+YOXKlZXhAgfxJuySaJZ8RwN7NHgduABudcVWjd94DbgW7gIPB7zrnTZpYK/BC4PPTejznn/ipaxYvEk67ePj5oah90J5/+mSmRt2SbOyuDJQUB7rwicmZKgJwY3pJNEs9ojtx/BDwEPBaxbivwgHOu18y+CzwAfA34DJDunFtpZpnALjN73Dl3eGLLFomd9q5eDjZGdi704+FHmtsHZqaYQekc3zNl7bL8gSPxeL0lmySeEcPdOfeymS0csu65iIdvAJ/ufwrIMrMUYAb+yP7sxJQqMrmCQUft8TPsOn520OX2Q2/Jtigvi2VF2dx+SfHART6L8zUzRWJrIsbc7wH+NfT1z4CNwAkgE/gj51zLcC8ys3uBewFKS0snoAyRi9cXdPzmcAtbauvZUls/0Pyq/5Zs1QtzuCN/vh9KKchmQW5mQtySTRLPRYW7mX0d6AV+Elp1BdAHzAVygF+b2S+dc4eGvtY59zDwMEB1dbUb+rzIZOnpC/L6wWY219azdVc9TW3dpKcksWZpPl+tqqB6wZyEvyWbJJ5xh7uZfQ5/ovV65/q7M/NfgS3OuR6gwcxeBaqBj4S7SCx19vTxyv4mNtfW88vdJzlzrofMtGTWLSugpqqIdRUFumpTprRx7b1mth5/AnWNc64j4qmjwHVm9mP8sMyVwN9fbJEiE6Gju5eX9jayubaeF/Y00NbVS3ZGCjcuL2R9VRGrl+ZrnFwSxmimQj4OrAXyzKwOeBA/OyYd2Bqaf/uGc+4+4AfAPwG1gAH/5Jx7Pzqli4ystbOHF/Y0sHlHPS/ua6CzJ0hOZiq3riymZmURVy/J080iJCGNZrbMncOsfuQ827bhp0OKxMzpjm627jrJ5tp6XtnfRHdfkPzsdD7z8fnUVBVxxaI5ujxfEp4GFSUhNLZ28dwuP8Pl9YPN9AYd82bP4LNXLaCmqojLS3N0qb5MKwp3mbJOnDnHltp6NtfWs+1wC0EHC3Mz+f1rF1NTVcQlJbN02b5MWwp3mVI+bOlgc+0JNtfW8+7R0wAsLQxw/3Xl1FQVsawoW4EugsJdpoADDW1sCQX6zuP+gucVc2fylZuWsr6qmLKCQIwrFIk/CneJO8459tS3snmHD/T9DW0AfKx0Nn92yzLWryimNDczxlWKxDeFu8QF5xzv151hc209W2pPcLi5AzNYtXAO37y9kpuriiieNSPWZYpMGQp3iZlg0PH20VNs3lHPszvrOXb6HMlJxtVLcvlvqxdzU2UR+dnpsS5TZEpSuMuk6u0L8tYHLf4IfWc9ja1dpCUncW15Hl++oZwbKwuZnam+5iIXS+EuUdfdG+TVg01s2VHP1t0naWnvJiM1ibVLC6hZWcR1ywrU41xkgincJSo6e/p4eV/jQGOu1s5eAukpXBdqzLWmIp/MNO1+ItGif10yYdq7evnV3gY219bzqz0NdHT3MWtGKjevKKKmqohPluWpMZfIJFG4y0U5c66H53f7Pi4v72ukqzdIblYaGy+bR01VEVctydXNLERiQOEuY9bS3s3WXf6y/1cPNNHT5yiamcGdV5SyvqqIVQvn6MYWIjGmcJdRaTjbybM7faC/+UELfUFHSc4M7r56ITUri7msZLYac4nEEYW7nNex0+fYvOMEW2rrefvoKZyDxflZ3LdmMTVVxayYO1N9XETilMJdBjnc1D5wlej2ujMALCvK5kvXl3PLymLKCwIKdJEpQOEu7D/ZyjM76tlce4I99a0AXFIyi6+ur6CmqphFeVkxrlBExkrhPg0559h5/GyoF/oJDja2A1C9IIc/v3U566uKKMlRYy6RqUzhPk0Eg4736k4PBPqHLedIMvjEolw+d/VCbl5RROHMjFiXKSITROGewPqCjm2HQ31cauupP9tJarJx9ZI8vrC2jBsrC8kNqDGXSCJSuCeYnr4gbxxqZnNtPc/trKeprZu0lCRWl+fz1fUVXL+8kFkz1MdFJNEp3BNAV28fr+xvGujjcrqjh8y0ZNZVFLC+qoh1ywoIpOuvWmQ60b/4Kepcdx8v7fN9XF7Y3UBrVy/Z6SncUFnI+qoi1izNVx8XkWlM4T6FtHb28MKeBrbU1vPi3kbO9fSRk5lKzcoiaqqKubosl/QUBbqIKNzj3pmOHrbuPsnmHSf49f4muvuC5Gen86mPz6OmqphPLJpDihpzicgQCvc41NTWxXM7T7K59gSvH2ymN+iYOyuD372ylFtWFnN5aY4ac4nIBSnc40T9mU621J5gc209vzncQtDBgtxMPn/tImqqirm0ZJYu+xeRUVO4x9CHLR0DFxW9c/Q0AOUFAe5fV8b6qmKWF2cr0EVkXBTuk+xgY9tAoNceOwtAZfFM/vjGpdSsLKKsIDvGFYpIIlC4R5lzjr2hxlxbak+w72QbAJfNn80DNctYX1XEglw15hKRiaVwjwLnHDuOnRm47P+DpnbMYNWCOXzjtkrWVxUxd/aMWJcpIglsxHA3s0eB24AG51xVaN33gNuBbuAg8HvOudOh5y4B/hGYCQSBVc65zqhUH0eCQcc7R08NBPqx0+dITjKuWpzL569ZxE0rCinIVmMuEZkcozly/xHwEPBYxLqtwAPOuV4z+y7wAPA1M0sBfgx81jm33cxygZ4Jrjlu9PYFeetwC1tCgd7Q2kVqsnFNWR5fuqGcG5cXkpOVFusyRWQaGjHcnXMvm9nCIeuei3j4BvDp0Nc3Ae8757aHtmueoDrjRndvkNcONrGltp7ndp2kpb2bjNQk1izNp6aqmOuWFzAzQ425RCS2JmLM/R7gX0NfLwWcmT0L5ANPOOf+ergXmdm9wL0ApaWlE1BG9HT29PHyvka2hBpzne3sJSstmeuWF1JTVcTainwy03T6QkTix0Ulkpl9HegFfhLxftcAq4AO4Hkze9s59/zQ1zrnHgYeBqiurnYXU0c0tHf18uLeRjbXnuBXexpo7+5jZoZvzFVTVcy15XlqzCUicWvc4W5mn8OfaL3eOdcfznXAS865ptA2zwCXAx8J93h0trOH53efZPOOel7a10hXb5DcrDQ2XDaX9VXFXLU4l7QU9XERkfg3rnA3s/XA14A1zrmOiKeeBb5qZpn4mTRrgL+76Cqj6FR7N1t3+T4urxxooqfPUZCdzh2r5rO+qphVC3PUmEtEppzRTIV8HFgL5JlZHfAgfnZMOrA1dHn8G865+5xzp8zsb4HfAA54xjn3dLSKH6+G1k6e3XmSLbUneONQC31Bx7zZM/jcVQupWVnEx+bnkKTGXCIyhVl4RCV2qqur3bZt26L6PY6dPheasniCbUdO4RwszstifZXvhV41b6b6uIjIlBI6p1k93HMJPcXjSHM7m2vr2Vxbz/YPTwNQUZjNF68r55aVxSwtDCjQRSQhJVy47z/ZOhDou0/4xlwr583iT26uoKaqiMX5gRhXKCISfVM+3J1z7DpxNtRpsZ4DDb4x1+Wls/n6LctZX1XE/DmZMa5SRGRyTelwf7/uNPf/9F2OtnSQZHDFojl89soV3LyiiKJZ6uMiItPXlA73+TmZLMrL4r+vXcKNlYXkBdJjXZKISFyY0uGek5XGP99zRazLEBGJO7o6R0QkASncRUQSkMJdRCQBKdxFRBKQwl1EJAEp3EVEEpDCXUQkASncRUQSUFy0/DWzRuDIRbxFHtA0QeVMJNU1NqprbFTX2CRiXQucc/nDPREX4X6xzGzb+Xoax5LqGhvVNTaqa2ymW10alhERSUAKdxGRBJQo4f5wrAs4D9U1NqprbFTX2EyruhJizF1ERAZLlCN3ERGJoHAXEUlAcR3uZrbezPaa2QEz+9Nhnjcz+z+h5983s8tH+9oo1/W7oXreN7PXzOzSiOcOm9kOM3vPzLZNcl1rzexM6Hu/Z2bfGO1ro1zXn0TUVGtmfWY2J/RcND+vR82swcxqz/N8rPavkeqK1f41Ul2x2r9GqmvS9y8zm29mvzKz3Wa208y+NMw20d2/nHNxuQDJwEFgMZAGbAcqh2xzC7AZMOBK4M3RvjbKdV0N5IS+rumvK/T4MJAXo89rLfDUeF4bzbqGbH878EK0P6/Qe68GLgdqz/P8pO9fo6xr0vevUdY16fvXaOqKxf4FFAOXh77OBvZNdn7F85H7FcAB59wh51w38ASwccg2G4HHnPcGMNvMikf52qjV5Zx7zTl3KvTwDaBkgr73RdUVpddO9HvfCTw+Qd/7gpxzLwMtF9gkFvvXiHXFaP8azed1PjH9vIaYlP3LOXfCOfdO6OtWYDcwb8hmUd2/4jnc5wEfRjyu46Mfzvm2Gc1ro1lXpM/j/3fu54DnzOxtM7t3gmoaS11Xmdl2M9tsZivG+Npo1oWZZQLrgX+PWB2tz2s0YrF/jdVk7V+jNdn716jFav8ys4XAx4A3hzwV1f0rnm+QbcOsGzpv83zbjOa14zXq9zazdfh/fNdErP6kc+64mRUAW81sT+jIYzLqegffi6LNzG4Bfg6Uj/K10ayr3+3Aq865yKOwaH1eoxGL/WvUJnn/Go1Y7F9jMen7l5kF8P+ZfNk5d3bo08O8ZML2r3g+cq8D5kc8LgGOj3Kb0bw2mnVhZpcAPwQ2Ouea+9c7546H/mwA/hP/K9ik1OWcO+ucawt9/QyQamZ5o3ltNOuKcAdDfmWO4uc1GrHYv0YlBvvXiGK0f43FpO5fZpaKD/afOOf+Y5hNort/TfSJhIla8L9VHAIWET6psGLINrcy+ITEW6N9bZTrKgUOAFcPWZ8FZEd8/RqwfhLrKiJ84doVwNHQZxfTzyu03Sz8uGnWZHxeEd9jIec/QTjp+9co65r0/WuUdU36/jWaumKxf4V+7seAv7/ANlHdvybsw43Ggj+bvA9/5vjroXX3AfdFfIA/CD2/A6i+0Gsnsa4fAqeA90LLttD6xaG/qO3AzhjUdX/o+27Hn4i7+kKvnay6Qo/vBp4Y8rpof16PAyeAHvzR0ufjZP8aqa5Y7V8j1RWr/euCdcVi/8IPlTng/Yi/p1smc/9S+wERkQQUz2PuIiIyTgp3EZEEpHAXEUlACncRkQSkcBcRSUAKdxGRBKRwFxFJQP8fGjhvH+aZh8oAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning['entry'],loss['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/test3.ipynb b/learningAgents/naive_policy_gradient/test/test3.ipynb new file mode 100644 index 0000000..2793399 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/test3.ipynb @@ -0,0 +1,8863 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=1_000_000, discountFactor =0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "0 actions: tensor([2, 3, 0])\n", + "loss= tensor(14.3700, grad_fn=) , return= 16182.078125\n", + "discReturns/1000= tensor([14.5668, 10.5095, 5.6438])\n", + "actionProbs tensor([[0.3411, 0.3447, 0.3265, 0.3323],\n", + " [0.3336, 0.3344, 0.3327, 0.3331],\n", + " [0.3253, 0.3209, 0.3408, 0.3346]], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 0, 2])\n", + "loss= tensor(15.2851, grad_fn=) , return= 16125.5\n", + "discReturns/1000= tensor([14.5241, 10.4676, 5.5462])\n", + "actionProbs tensor([[0.2986, 0.3239, 0.4163, 0.2936],\n", + " [0.3276, 0.3396, 0.3302, 0.3310],\n", + " [0.3739, 0.3365, 0.2535, 0.3755]], grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([0, 2, 0])\n", + "loss= tensor(14.2920, grad_fn=) , return= 16042.703125\n", + "discReturns/1000= tensor([14.4485, 10.3736, 5.5689])\n", + "actionProbs tensor([[0.3501, 0.5101, 0.3013, 0.3593],\n", + " [0.3330, 0.3122, 0.3273, 0.3369],\n", + " [0.3169, 0.1777, 0.3714, 0.3038]], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([2, 2, 1])\n", + "loss= tensor(14.0527, grad_fn=) , return= 16148.578125\n", + "discReturns/1000= tensor([14.5401, 10.4798, 5.6053])\n", + "actionProbs tensor([[0.3331, 0.3801, 0.3867, 0.3945],\n", + " [0.3326, 0.3338, 0.3312, 0.3359],\n", + " [0.3343, 0.2861, 0.2821, 0.2695]], grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([1, 1, 2])\n", + "loss= tensor(13.8139, grad_fn=) , return= 16058.75\n", + "discReturns/1000= tensor([14.4648, 10.3929, 5.5462])\n", + "actionProbs tensor([[0.3823, 0.3647, 0.3374, 0.3419],\n", + " [0.3318, 0.3347, 0.3321, 0.3386],\n", + " [0.2860, 0.3006, 0.3304, 0.3195]], grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([2, 3, 2])\n", + "loss= tensor(14.1625, grad_fn=) , return= 16178.078125\n", + "discReturns/1000= tensor([14.5635, 10.5059, 5.6398])\n", + "actionProbs tensor([[0.3565, 0.3334, 0.3533, 0.3651],\n", + " [0.3361, 0.3335, 0.3344, 0.3365],\n", + " [0.3074, 0.3331, 0.3123, 0.2985]], grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([0, 0, 3])\n", + "loss= tensor(14.9211, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[0.2825, 0.2942, 0.3373, 0.3813],\n", + " [0.3325, 0.3331, 0.3331, 0.3309],\n", + " [0.3850, 0.3727, 0.3296, 0.2878]], grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([1, 1, 3])\n", + "loss= tensor(13.2686, grad_fn=) , return= 16053.75\n", + "discReturns/1000= tensor([14.4608, 10.3884, 5.5413])\n", + "actionProbs tensor([[0.4034, 0.3388, 0.3222, 0.2392],\n", + " [0.3422, 0.3375, 0.3311, 0.3078],\n", + " [0.2543, 0.3237, 0.3467, 0.4530]], grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([1, 0, 0])\n", + "loss= tensor(14.1636, grad_fn=) , return= 16026.5625\n", + "discReturns/1000= tensor([14.4389, 10.3640, 5.5131])\n", + "actionProbs tensor([[0.3481, 0.3311, 0.3639, 0.3795],\n", + " [0.3882, 0.3500, 0.3242, 0.3022],\n", + " [0.2637, 0.3189, 0.3118, 0.3183]], grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([2, 1, 0])\n", + "loss= tensor(12.4751, grad_fn=) , return= 16115.203125\n", + "discReturns/1000= tensor([14.5133, 10.4501, 5.5689])\n", + "actionProbs tensor([[0.0242, 0.1251, 0.2959, 0.7412],\n", + " [0.2700, 0.3417, 0.3357, 0.1711],\n", + " [0.7058, 0.5332, 0.3683, 0.0877]], grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([0, 1, 1])\n", + "loss= tensor(13.1282, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([14.4202, 10.3421, 5.5306])\n", + "actionProbs tensor([[0.3997, 0.3434, 0.3187, 0.2670],\n", + " [0.3856, 0.3535, 0.3327, 0.2959],\n", + " [0.2147, 0.3031, 0.3486, 0.4371]], grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([0, 3, 1])\n", + "loss= tensor(24.0207, grad_fn=) , return= 16074.078125\n", + "discReturns/1000= tensor([14.4734, 10.4013, 5.6053])\n", + "actionProbs tensor([[0.0305, 0.1932, 0.4481, 0.5365],\n", + " [0.1028, 0.2804, 0.3412, 0.3283],\n", + " [0.8667, 0.5264, 0.2107, 0.1352]], grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 1, 2])\n", + "loss= tensor(9.3850, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([14.5534, 10.5002, 5.5836])\n", + "actionProbs tensor([[0.0074, 0.0636, 0.5593, 0.4518],\n", + " [0.9549, 0.7904, 0.1120, 0.1805],\n", + " [0.0377, 0.1461, 0.3287, 0.3677]], grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.7048, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1943e-03, 7.1138e-07, 2.0163e-07, 1.5027e-07],\n", + " [6.3728e-02, 8.1566e-04, 2.5514e-04, 2.3243e-04],\n", + " [9.3408e-01, 9.9918e-01, 9.9974e-01, 9.9977e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5935, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4860e-04, 1.4307e-08, 1.3893e-09, 1.0059e-09],\n", + " [1.6544e-02, 1.1095e-04, 2.0016e-05, 1.8005e-05],\n", + " [9.8331e-01, 9.9989e-01, 9.9998e-01, 9.9998e-01]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5380, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.2894e-04, 6.7207e-10, 3.9580e-11, 2.9530e-11],\n", + " [1.5163e-02, 2.2266e-05, 3.0564e-06, 2.8011e-06],\n", + " [9.8471e-01, 9.9998e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.4510, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[2.0240e-02, 1.4748e-08, 6.5000e-11, 6.7803e-11],\n", + " [1.7072e-01, 8.7669e-05, 3.1515e-06, 3.2808e-06],\n", + " [8.0904e-01, 9.9991e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5313, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.2494e-04, 1.2137e-12, 7.0943e-13, 5.7800e-13],\n", + " [1.6364e-02, 8.9921e-07, 3.7899e-07, 3.5636e-07],\n", + " [9.8351e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5972, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5080e-05, 2.4054e-09, 3.2711e-13, 2.5893e-13],\n", + " [8.9534e-03, 1.1584e-04, 1.3333e-06, 1.1441e-06],\n", + " [9.9103e-01, 9.9988e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5408, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6082e-05, 1.4775e-10, 2.1370e-15, 1.8104e-15],\n", + " [8.8521e-03, 2.5656e-05, 9.1213e-08, 8.0155e-08],\n", + " [9.9113e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5565, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.0538e-05, 6.5032e-10, 5.9195e-15, 4.4514e-15],\n", + " [6.6051e-03, 3.9549e-05, 8.8732e-08, 7.7599e-08],\n", + " [9.9338e-01, 9.9996e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "21000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5565, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5801e-05, 2.4881e-09, 1.1989e-14, 9.3250e-15],\n", + " [1.1208e-02, 8.6259e-05, 1.5281e-07, 1.3481e-07],\n", + " [9.8877e-01, 9.9991e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5456, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8291e-05, 7.9380e-10, 2.7196e-15, 2.6802e-14],\n", + " [1.3511e-02, 5.6811e-05, 8.4469e-08, 2.5516e-07],\n", + " [9.8646e-01, 9.9994e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5636, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9507e-06, 1.7117e-10, 4.6402e-16, 1.0445e-14],\n", + " [5.2006e-03, 2.5885e-05, 3.3190e-08, 1.5132e-07],\n", + " [9.9480e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5750, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2444e-06, 2.7993e-10, 6.1005e-16, 2.5271e-14],\n", + " [4.1440e-03, 3.5661e-05, 4.3352e-08, 2.6298e-07],\n", + " [9.9585e-01, 9.9996e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5351, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0452e-05, 2.0314e-10, 2.7550e-17, 3.4566e-15],\n", + " [1.7656e-02, 3.0928e-05, 9.0952e-09, 9.5844e-08],\n", + " [9.8230e-01, 9.9997e-01, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5457, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7855e-06, 9.7789e-12, 3.2736e-15, 2.2839e-14],\n", + " [2.6971e-03, 2.2512e-06, 1.8368e-08, 5.2754e-08],\n", + " [9.9730e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5407, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1926e-07, 1.8083e-13, 1.5933e-16, 7.7042e-16],\n", + " [6.7652e-04, 1.3856e-07, 1.3235e-09, 3.3401e-09],\n", + " [9.9932e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5397, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.6279e-08, 1.3311e-14, 2.0644e-17, 8.3193e-17],\n", + " [2.6647e-04, 2.1307e-08, 2.1912e-10, 5.2190e-10],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5393, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3618e-08, 1.6099e-15, 3.8478e-18, 1.3724e-17],\n", + " [1.2309e-04, 4.5325e-09, 4.8645e-11, 1.1217e-10],\n", + " [9.9988e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5392, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3089e-09, 2.4618e-16, 8.4663e-19, 2.7542e-18],\n", + " [6.1409e-05, 1.1261e-09, 1.2422e-11, 2.8076e-11],\n", + " [9.9994e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5391, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1308e-09, 4.2768e-17, 2.0071e-19, 6.0834e-19],\n", + " [3.1980e-05, 3.0495e-10, 3.4293e-12, 7.6539e-12],\n", + " [9.9997e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2303e-09, 7.9708e-18, 4.9246e-20, 1.4097e-19],\n", + " [1.7129e-05, 8.7148e-11, 9.9394e-13, 2.2006e-12],\n", + " [9.9998e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8835e-10, 1.4842e-18, 1.2195e-20, 3.2969e-20],\n", + " [9.3048e-06, 2.5782e-11, 2.9746e-13, 6.5498e-13],\n", + " [9.9999e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9739e-10, 2.8820e-19, 3.0783e-21, 7.9096e-21],\n", + " [5.1212e-06, 7.8146e-12, 9.1010e-14, 1.9961e-13],\n", + " [9.9999e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3473e-11, 6.0871e-20, 8.7299e-22, 2.1171e-21],\n", + " [2.8029e-06, 2.3866e-12, 2.8031e-14, 6.1306e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4695e-11, 1.2025e-20, 2.1115e-22, 4.9539e-22],\n", + " [1.5608e-06, 7.4220e-13, 8.7660e-15, 1.9160e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7698e-11, 3.3386e-21, 8.8350e-23, 1.8958e-22],\n", + " [8.7751e-07, 2.3387e-13, 2.7832e-15, 6.0672e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3404e-12, 8.6857e-22, 3.2943e-23, 6.4975e-23],\n", + " [4.9854e-07, 7.5243e-14, 9.0402e-16, 1.9572e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6184e-12, 1.2343e-21, 1.4397e-22, 2.1807e-22],\n", + " [2.8209e-07, 2.7088e-14, 3.2649e-16, 7.0847e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "40000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8167e-12, 2.3500e-22, 2.6903e-23, 4.1757e-23],\n", + " [1.6084e-07, 1.2097e-14, 1.4681e-16, 3.1868e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "41000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.5385, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[1.4076e-09, 4.2209e-20, 3.5140e-22, 8.6742e-22],\n", + " [1.5936e-07, 8.6000e-15, 1.5144e-16, 4.1089e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5507, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6732e-04, 9.5150e-15, 3.2005e-17, 6.8905e-17],\n", + " [8.2168e-03, 7.8889e-10, 6.5889e-12, 1.2909e-11],\n", + " [9.9152e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1320e-06, 2.4679e-17, 2.1126e-19, 3.3816e-19],\n", + " [2.6040e-04, 6.5036e-12, 6.2308e-14, 1.0644e-13],\n", + " [9.9974e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5370, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4575e-06, 3.0842e-17, 2.7249e-19, 4.3387e-19],\n", + " [2.8748e-04, 7.6502e-12, 7.5444e-14, 1.2844e-13],\n", + " [9.9971e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7969e-06, 3.9357e-17, 3.6612e-19, 5.7763e-19],\n", + " [3.1745e-04, 9.4446e-12, 9.8416e-14, 1.6605e-13],\n", + " [9.9968e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5395, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9520e-06, 4.4919e-17, 4.4184e-19, 6.8836e-19],\n", + " [3.3050e-04, 1.0522e-11, 1.1505e-13, 1.9206e-13],\n", + " [9.9967e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5370, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0383e-06, 5.1157e-17, 5.5099e-19, 8.3898e-19],\n", + " [3.3848e-04, 1.1737e-11, 1.3963e-13, 2.2775e-13],\n", + " [9.9966e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5371, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.9885e-07, 1.2128e-17, 1.7896e-19, 2.4433e-19],\n", + " [1.4818e-04, 4.0200e-12, 5.2903e-14, 8.0603e-14],\n", + " [9.9985e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5394, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1240e-06, 4.1339e-17, 8.8502e-19, 1.1335e-18],\n", + " [2.7463e-04, 1.1492e-11, 2.1477e-13, 3.0935e-13],\n", + " [9.9972e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5347, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0371e-06, 4.2458e-17, 1.1825e-18, 1.4094e-18],\n", + " [2.6518e-04, 1.1630e-11, 2.5623e-13, 3.5106e-13],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5191, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8355e-03, 5.0034e-16, 1.1666e-18, 1.8665e-18],\n", + " [3.7543e-02, 8.2853e-10, 1.2247e-11, 1.9446e-11],\n", + " [9.6062e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5295, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8180e-04, 7.2007e-17, 2.0745e-19, 2.5587e-19],\n", + " [1.6184e-02, 1.5875e-10, 2.3594e-12, 3.2731e-12],\n", + " [9.8333e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5300, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4585e-04, 2.5924e-17, 7.9633e-20, 9.4305e-20],\n", + " [1.0448e-02, 6.7373e-11, 9.7323e-13, 1.3194e-12],\n", + " [9.8931e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5330, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8955e-04, 2.0647e-17, 6.8307e-20, 7.8137e-20],\n", + " [8.8863e-03, 5.5394e-11, 8.2553e-13, 1.0970e-12],\n", + " [9.9092e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5342, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0863e-04, 1.3087e-17, 5.2045e-20, 5.5105e-20],\n", + " [6.4215e-03, 4.0429e-11, 6.6138e-13, 8.3933e-13],\n", + " [9.9347e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5315, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3666e-04, 4.2585e-17, 3.5450e-19, 2.8690e-19],\n", + " [1.2056e-02, 1.5395e-10, 4.8860e-12, 5.4115e-12],\n", + " [9.8771e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5314, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4311e-04, 6.3380e-17, 5.6089e-19, 4.4252e-19],\n", + " [1.2359e-02, 2.0554e-10, 6.8584e-12, 7.4822e-12],\n", + " [9.8740e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5288, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4021e-04, 7.4797e-17, 6.1756e-19, 4.9190e-19],\n", + " [1.3049e-02, 2.8745e-10, 9.0855e-12, 9.8594e-12],\n", + " [9.8671e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "59000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.0119, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[9.7257e-01, 2.8119e-18, 9.6907e-14, 2.0380e-17],\n", + " [2.7221e-02, 2.2712e-09, 5.3586e-07, 6.6865e-09],\n", + " [2.0959e-04, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([0, 0, 1])\n", + "loss= tensor(2.0119, grad_fn=) , return= 15971.328125\n", + "discReturns/1000= tensor([14.3910, 10.3097, 5.4935])\n", + "actionProbs tensor([[9.7797e-01, 4.8010e-19, 4.4624e-14, 5.7223e-18],\n", + " [2.1904e-02, 3.7777e-10, 1.6514e-07, 1.4573e-09],\n", + " [1.2446e-04, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "61000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0089, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8122e-01, 1.7438e-19, 2.0926e-14, 2.1107e-18],\n", + " [1.8702e-02, 1.1688e-10, 6.4833e-08, 4.5457e-10],\n", + " [8.1473e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0089, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8434e-01, 6.4931e-20, 1.0242e-14, 8.1008e-19],\n", + " [1.5611e-02, 4.0401e-11, 2.8383e-08, 1.6031e-10],\n", + " [5.1351e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.0088, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8727e-01, 2.4883e-20, 5.2772e-15, 3.2842e-19],\n", + " [1.2695e-02, 1.7229e-11, 1.4993e-08, 7.0661e-11],\n", + " [3.1587e-05, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5396, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2698e-07, 1.1843e-17, 7.5200e-14, 6.6233e-15],\n", + " [2.7211e-04, 6.1369e-11, 1.1710e-08, 2.2705e-09],\n", + " [9.9973e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5391, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0041e-08, 1.0975e-19, 5.3514e-16, 4.6351e-17],\n", + " [5.4866e-05, 2.7603e-12, 5.0268e-10, 9.6825e-11],\n", + " [9.9995e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4575e-10, 8.3933e-23, 3.2252e-19, 2.5685e-20],\n", + " [2.1456e-06, 9.3031e-15, 1.5729e-12, 2.8050e-13],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7096e-10, 2.7267e-23, 1.9684e-20, 1.5955e-21],\n", + " [5.4067e-07, 2.0903e-15, 9.0301e-14, 1.6161e-14],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4127e-10, 2.1993e-23, 7.3411e-21, 6.2481e-22],\n", + " [2.9197e-07, 7.6030e-16, 1.4778e-14, 2.7326e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3753e-10, 1.5451e-23, 3.9870e-21, 3.4757e-22],\n", + " [1.5875e-07, 4.9522e-16, 7.7530e-15, 1.4650e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6619e-11, 6.0161e-24, 1.2789e-21, 1.1296e-22],\n", + " [6.3712e-08, 2.3749e-16, 3.3676e-15, 6.4431e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6714e-11, 8.4956e-24, 1.9482e-21, 1.7239e-22],\n", + " [5.8626e-08, 2.4323e-16, 3.4712e-15, 6.6434e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.6660e-11, 9.9376e-24, 2.2346e-21, 1.9785e-22],\n", + " [5.8249e-08, 2.4088e-16, 3.4142e-15, 6.5358e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8695e-11, 1.3604e-23, 3.0038e-21, 2.6613e-22],\n", + " [5.8033e-08, 2.4679e-16, 3.5068e-15, 6.7172e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4690e-10, 2.3297e-23, 4.9595e-21, 4.3901e-22],\n", + " [5.7700e-08, 2.5128e-16, 3.5590e-15, 6.8234e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0253e-10, 5.0918e-23, 1.2434e-20, 1.0583e-21],\n", + " [5.7913e-08, 2.6890e-16, 3.8413e-15, 7.3659e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6722e-10, 1.0569e-22, 2.9025e-20, 2.3995e-21],\n", + " [5.8839e-08, 2.9938e-16, 4.2965e-15, 8.2364e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3414e-10, 3.6227e-22, 1.1247e-19, 8.9823e-21],\n", + " [5.5982e-08, 3.4013e-16, 4.8414e-15, 9.2798e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "78000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8431e-09, 1.1870e-21, 2.9112e-19, 2.4474e-20],\n", + " [5.3006e-08, 3.4858e-16, 4.7103e-15, 9.2659e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9290e-09, 4.6894e-21, 8.1369e-19, 7.7490e-20],\n", + " [5.4457e-08, 3.5464e-16, 4.4496e-15, 9.3179e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.6900e-09, 2.7067e-20, 2.8606e-18, 3.1693e-19],\n", + " [4.9789e-08, 4.2031e-16, 4.8899e-15, 1.0624e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "81000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.6490e-09, 2.9137e-20, 2.8760e-18, 3.3301e-19],\n", + " [5.1331e-08, 3.5602e-16, 3.7994e-15, 8.6239e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1274e-09, 4.8394e-20, 3.8664e-18, 4.8595e-19],\n", + " [4.8591e-08, 5.1280e-16, 4.3413e-15, 1.0748e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3645e-09, 4.7192e-20, 3.0698e-18, 4.0658e-19],\n", + " [4.3816e-08, 6.6829e-16, 3.5214e-15, 1.0134e-15],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.9998e-09, 1.0830e-19, 3.9019e-18, 5.2114e-19],\n", + " [4.0573e-08, 5.3614e-16, 2.4320e-15, 7.2312e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0218e-10, 4.3768e-23, 8.8902e-22, 1.5935e-22],\n", + " [1.8348e-08, 4.3821e-17, 1.9317e-16, 7.1918e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8536e-11, 3.4322e-24, 6.4018e-23, 1.1812e-23],\n", + " [1.3832e-08, 2.7261e-17, 1.2697e-16, 4.7988e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3131e-11, 2.6812e-24, 5.0087e-23, 9.2606e-24],\n", + " [1.3735e-08, 2.6678e-17, 1.2474e-16, 4.7172e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0738e-11, 2.3772e-24, 4.4357e-23, 8.2125e-24],\n", + " [1.3691e-08, 2.6400e-17, 1.2365e-16, 4.6776e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.6490e-11, 1.8651e-24, 3.4554e-23, 6.4188e-24],\n", + " [1.3603e-08, 2.5810e-17, 1.2132e-16, 4.5921e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.7429e-11, 5.8619e-24, 1.1453e-22, 2.0808e-23],\n", + " [1.5250e-08, 3.0425e-17, 1.4189e-16, 5.3328e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2133e-11, 2.2351e-24, 4.2119e-23, 7.7587e-24],\n", + " [1.4115e-08, 2.6375e-17, 1.2471e-16, 4.7094e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8447e-12, 3.3629e-26, 4.6730e-25, 9.5360e-26],\n", + " [1.1891e-08, 1.6650e-17, 8.4162e-17, 3.1954e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2863e-12, 1.7339e-26, 2.3495e-25, 4.8236e-26],\n", + " [1.1669e-08, 1.5065e-17, 7.6909e-17, 2.9215e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5627e-16, 1.5132e-30, 6.1297e-30, 1.6511e-30],\n", + " [4.8974e-09, 5.2784e-18, 2.8634e-17, 1.1017e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.2601e-16, 8.6587e-31, 3.3285e-30, 9.0483e-31],\n", + " [4.6606e-09, 4.9468e-18, 2.6761e-17, 1.0315e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.0167e-16, 1.3875e-30, 5.5059e-30, 1.4868e-30],\n", + " [5.0424e-09, 5.2101e-18, 2.8532e-17, 1.0953e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "97000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0010e-17, 1.0136e-31, 4.0564e-31, 1.1089e-31],\n", + " [3.0856e-09, 3.0812e-18, 1.6048e-17, 6.2980e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0195e-16, 1.0599e-31, 4.1565e-31, 1.1358e-31],\n", + " [3.3036e-09, 3.1126e-18, 1.6494e-17, 6.4431e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.7582e-17, 2.7968e-32, 1.1112e-31, 3.0347e-32],\n", + " [2.3332e-09, 2.1215e-18, 1.0812e-17, 4.2994e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5040e-17, 2.0073e-32, 7.9130e-32, 2.1548e-32],\n", + " [2.2588e-09, 1.9224e-18, 9.8447e-18, 3.9131e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "101000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3478e-17, 1.6645e-32, 6.5621e-32, 1.7829e-32],\n", + " [2.2824e-09, 1.8043e-18, 9.1530e-18, 3.6385e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8950e-17, 8.3065e-33, 3.1846e-32, 8.7932e-33],\n", + " [1.8152e-09, 1.4947e-18, 7.4671e-18, 3.0031e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5429e-17, 5.9841e-33, 2.2727e-32, 6.3043e-33],\n", + " [1.6987e-09, 1.3612e-18, 6.7323e-18, 2.7188e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0905e-17, 7.8191e-33, 3.0274e-32, 8.3126e-33],\n", + " [1.9530e-09, 1.4523e-18, 7.2250e-18, 2.8990e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9801e-17, 7.0244e-33, 2.7175e-32, 7.4732e-33],\n", + " [1.9217e-09, 1.4087e-18, 6.9976e-18, 2.8115e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2171e-17, 7.6177e-33, 2.9729e-32, 8.1461e-33],\n", + " [2.0268e-09, 1.4354e-18, 7.1518e-18, 2.8670e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1661e-17, 4.1438e-33, 1.5129e-32, 4.2897e-33],\n", + " [1.6027e-09, 1.4031e-18, 6.6789e-18, 2.7464e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7098e-17, 5.1068e-33, 1.9727e-32, 5.4509e-33],\n", + " [1.8484e-09, 1.2919e-18, 6.3878e-18, 2.5771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8047e-17, 5.1424e-33, 2.0009e-32, 5.5208e-33],\n", + " [1.8975e-09, 1.2879e-18, 6.3920e-18, 2.5764e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1009e-17, 5.7941e-33, 2.2820e-32, 6.2671e-33],\n", + " [2.0321e-09, 1.3242e-18, 6.6073e-18, 2.6550e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8348e-17, 4.9049e-33, 1.9104e-32, 5.2842e-33],\n", + " [1.9404e-09, 1.3023e-18, 6.4473e-18, 2.6048e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6838e-17, 4.5847e-33, 1.7623e-32, 4.9116e-33],\n", + " [1.8896e-09, 1.3362e-18, 6.5499e-18, 2.6614e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3304e-17, 3.8334e-33, 1.4173e-32, 4.0236e-33],\n", + " [1.7651e-09, 1.4231e-18, 6.7588e-18, 2.7863e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8651e-17, 4.5554e-33, 1.7689e-32, 4.9097e-33],\n", + " [2.0129e-09, 1.3260e-18, 6.5001e-18, 2.6361e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8311e-17, 4.3911e-33, 1.6995e-32, 4.7341e-33],\n", + " [2.0140e-09, 1.3451e-18, 6.5703e-18, 2.6722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "116000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6872e-17, 4.1089e-33, 1.5704e-32, 4.4068e-33],\n", + " [1.9643e-09, 1.3787e-18, 6.6706e-18, 2.7281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5727e-17, 3.8111e-33, 1.4389e-32, 4.0670e-33],\n", + " [1.9361e-09, 1.4137e-18, 6.7652e-18, 2.7826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6097e-17, 3.6799e-33, 1.3883e-32, 3.9250e-33],\n", + " [1.9920e-09, 1.4205e-18, 6.7555e-18, 2.7818e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2811e-17, 3.0941e-33, 1.1252e-32, 3.2401e-33],\n", + " [1.8597e-09, 1.5108e-18, 6.9797e-18, 2.9152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5639e-17, 3.4061e-33, 1.2757e-32, 3.6281e-33],\n", + " [2.0115e-09, 1.4555e-18, 6.8544e-18, 2.8371e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "121000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5150e-17, 3.2314e-33, 1.2021e-32, 3.4336e-33],\n", + " [2.0123e-09, 1.4799e-18, 6.9163e-18, 2.8731e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5259e-17, 3.1830e-33, 1.1850e-32, 3.3886e-33],\n", + " [2.0278e-09, 1.4874e-18, 6.9484e-18, 2.8892e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7833e-17, 3.4196e-33, 1.3028e-32, 3.6907e-33],\n", + " [2.1587e-09, 1.4476e-18, 6.8638e-18, 2.8347e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3489e-17, 2.8417e-33, 1.0380e-32, 3.0046e-33],\n", + " [1.9595e-09, 1.5517e-18, 7.1403e-18, 2.9969e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3551e-17, 2.7103e-33, 9.8627e-33, 2.8597e-33],\n", + " [2.0037e-09, 1.5661e-18, 7.1460e-18, 3.0058e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5407e-17, 2.8598e-33, 1.0606e-32, 3.0529e-33],\n", + " [2.1122e-09, 1.5336e-18, 7.0819e-18, 2.9633e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2658e-17, 2.5383e-33, 9.1068e-33, 2.6653e-33],\n", + " [1.9824e-09, 1.6437e-18, 7.4071e-18, 3.1386e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5479e-17, 2.7506e-33, 1.0203e-32, 2.9463e-33],\n", + " [2.1394e-09, 1.5556e-18, 7.1691e-18, 3.0077e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9910e-17, 3.1098e-33, 1.1977e-32, 3.4048e-33],\n", + " [2.3633e-09, 1.4868e-18, 7.0215e-18, 2.9124e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3163e-17, 2.5591e-33, 9.0955e-33, 2.6846e-33],\n", + " [2.0856e-09, 1.8168e-18, 8.0777e-18, 3.4486e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1370e-17, 3.0403e-33, 1.1805e-32, 3.3535e-33],\n", + " [2.4771e-09, 1.4939e-18, 7.0587e-18, 2.9287e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3837e-17, 3.1657e-33, 1.2493e-32, 3.5290e-33],\n", + " [2.5964e-09, 1.4736e-18, 7.0317e-18, 2.9059e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0266e-17, 2.7676e-33, 1.0638e-32, 3.0463e-33],\n", + " [2.4759e-09, 1.5383e-18, 7.1860e-18, 3.0011e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6169e-17, 2.5542e-33, 9.3189e-33, 2.7330e-33],\n", + " [2.3383e-09, 1.8005e-18, 8.0746e-18, 3.4360e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "135000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.5919e-17, 2.5639e-33, 9.2557e-33, 2.7297e-33],\n", + " [2.3596e-09, 1.9065e-18, 8.4633e-18, 3.6186e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1051e-17, 2.6123e-33, 1.0077e-32, 2.8944e-33],\n", + " [2.5729e-09, 1.5658e-18, 7.2917e-18, 3.0548e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6139e-17, 2.5701e-33, 9.1236e-33, 2.7139e-33],\n", + " [2.4718e-09, 2.1160e-18, 9.1980e-18, 3.9647e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8577e-17, 2.5620e-33, 9.3491e-33, 2.7518e-33],\n", + " [2.6219e-09, 1.9729e-18, 8.7161e-18, 3.7287e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8676e-17, 2.5621e-33, 9.2430e-33, 2.7341e-33],\n", + " [2.6978e-09, 2.1006e-18, 9.1483e-18, 3.9328e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2759e-17, 2.5665e-33, 9.7289e-33, 2.8277e-33],\n", + " [2.8661e-09, 1.8312e-18, 8.2705e-18, 3.5069e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "141000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.1985e-17, 2.5753e-33, 9.5950e-33, 2.8132e-33],\n", + " [2.8885e-09, 1.9939e-18, 8.8626e-18, 3.7855e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8553e-17, 2.5842e-33, 9.0883e-33, 2.7323e-33],\n", + " [2.8321e-09, 2.4955e-18, 1.0570e-17, 4.6080e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9687e-17, 2.5810e-33, 9.1124e-33, 2.7380e-33],\n", + " [2.9519e-09, 2.5336e-18, 1.0706e-17, 4.6692e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0454e-17, 2.5878e-33, 9.1565e-33, 2.7556e-33],\n", + " [3.0350e-09, 2.6024e-18, 1.0983e-17, 4.7976e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.8664e-17, 2.5925e-33, 8.8503e-33, 2.7084e-33],\n", + " [3.0336e-09, 3.0374e-18, 1.2422e-17, 5.5021e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1178e-17, 2.6005e-33, 9.1435e-33, 2.7712e-33],\n", + " [3.1700e-09, 2.8337e-18, 1.1831e-17, 5.2014e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2448e-17, 2.6237e-33, 1.0400e-32, 3.0143e-33],\n", + " [3.5499e-09, 1.9984e-18, 9.1328e-18, 3.8771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0758e-17, 2.5930e-33, 8.8767e-33, 2.7276e-33],\n", + " [3.3021e-09, 3.2794e-18, 1.3295e-17, 5.9170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9952e-17, 2.5926e-33, 8.7108e-33, 2.7024e-33],\n", + " [3.3257e-09, 3.5908e-18, 1.4306e-17, 6.4180e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2528e-17, 2.5926e-33, 8.8963e-33, 2.7400e-33],\n", + " [3.5247e-09, 3.4578e-18, 1.3921e-17, 6.2152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5091e-17, 2.5901e-33, 9.0324e-33, 2.7679e-33],\n", + " [3.7327e-09, 3.3951e-18, 1.3752e-17, 6.1216e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9351e-17, 2.5654e-33, 8.2284e-33, 2.6112e-33],\n", + " [3.5726e-09, 4.5646e-18, 1.7261e-17, 7.9040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2052e-17, 2.5718e-33, 8.4637e-33, 2.6717e-33],\n", + " [3.7997e-09, 4.4754e-18, 1.7178e-17, 7.8381e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "154000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4396e-17, 2.5722e-33, 8.6057e-33, 2.7036e-33],\n", + " [4.0011e-09, 4.3935e-18, 1.6986e-17, 7.7278e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9451e-17, 2.5996e-33, 9.1243e-33, 2.8191e-33],\n", + " [4.2457e-09, 3.8907e-18, 1.5574e-17, 6.9944e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.5797e-17, 2.5371e-33, 8.3666e-33, 2.6500e-33],\n", + " [4.3366e-09, 4.9150e-18, 1.8523e-17, 8.5009e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3186e-17, 2.5256e-33, 7.9848e-33, 2.5767e-33],\n", + " [4.3092e-09, 5.7860e-18, 2.1005e-17, 9.7902e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9847e-17, 2.4869e-33, 7.3570e-33, 2.4376e-33],\n", + " [4.2999e-09, 7.2961e-18, 2.4921e-17, 1.1879e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3578e-17, 2.5330e-33, 8.6243e-33, 2.7154e-33],\n", + " [5.1077e-09, 5.0568e-18, 1.9130e-17, 8.7661e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.7760e-17, 2.4256e-33, 6.6924e-33, 2.2844e-33],\n", + " [4.4927e-09, 9.6660e-18, 3.0741e-17, 1.5042e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "161000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4257e-17, 2.4573e-33, 7.3908e-33, 2.4542e-33],\n", + " [4.9814e-09, 7.9801e-18, 2.7042e-17, 1.2952e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8821e-17, 2.4602e-33, 7.6790e-33, 2.5202e-33],\n", + " [5.3851e-09, 7.4807e-18, 2.5905e-17, 1.2305e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.2014e-17, 2.4051e-33, 6.8514e-33, 2.3329e-33],\n", + " [5.1248e-09, 1.0063e-17, 3.2274e-17, 1.5798e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7387e-17, 2.4306e-33, 7.3322e-33, 2.4508e-33],\n", + " [5.5468e-09, 8.9138e-18, 2.9761e-17, 1.4365e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7957e-17, 2.3793e-33, 7.0270e-33, 2.3673e-33],\n", + " [5.8874e-09, 9.7943e-18, 3.1738e-17, 1.5447e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3933e-17, 2.2976e-33, 6.2955e-33, 2.1835e-33],\n", + " [5.9781e-09, 1.2666e-17, 3.8160e-17, 1.9050e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6971e-17, 2.3072e-33, 6.4992e-33, 2.2422e-33],\n", + " [6.3248e-09, 1.2465e-17, 3.8162e-17, 1.8985e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.3308e-17, 2.2599e-33, 6.0422e-33, 2.1328e-33],\n", + " [6.2099e-09, 1.5032e-17, 4.3950e-17, 2.2281e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9389e-17, 2.2943e-33, 6.5263e-33, 2.2646e-33],\n", + " [6.7852e-09, 1.3607e-17, 4.1505e-17, 2.0773e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8107e-17, 2.1137e-33, 5.0559e-33, 1.8727e-33],\n", + " [6.2884e-09, 2.2673e-17, 5.9512e-17, 3.1442e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.9012e-17, 2.0766e-33, 4.9351e-33, 1.8367e-33],\n", + " [6.6765e-09, 2.4275e-17, 6.2640e-17, 3.3281e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.1735e-17, 2.0909e-33, 5.1385e-33, 1.8989e-33],\n", + " [7.0881e-09, 2.3619e-17, 6.2199e-17, 3.2886e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "173000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5877e-17, 2.2031e-33, 6.2669e-33, 2.2094e-33],\n", + " [8.3331e-09, 1.7316e-17, 5.0818e-17, 2.5900e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.0148e-17, 2.0162e-33, 4.7376e-33, 1.7957e-33],\n", + " [7.3738e-09, 2.9896e-17, 7.4819e-17, 4.0454e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3733e-17, 1.8766e-33, 3.8647e-33, 1.5417e-33],\n", + " [6.8902e-09, 4.4195e-17, 9.8729e-17, 5.5681e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "176000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.5883e-18, 1.6948e-33, 2.9373e-33, 1.2449e-33],\n", + " [6.4133e-09, 6.9869e-17, 1.3425e-16, 7.9651e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "177000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4353e-17, 1.7684e-33, 3.5422e-33, 1.4333e-33],\n", + " [7.6864e-09, 5.2182e-17, 1.1118e-16, 6.3661e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "178000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8149e-18, 1.5796e-33, 2.7384e-33, 1.1670e-33],\n", + " [7.4235e-09, 7.8103e-17, 1.4600e-16, 8.7349e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "179000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3919e-17, 1.6396e-33, 3.1438e-33, 1.3002e-33],\n", + " [8.3871e-09, 6.5156e-17, 1.3085e-16, 7.6510e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "180000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.8745e-18, 1.4895e-33, 2.3948e-33, 1.0591e-33],\n", + " [7.2644e-09, 1.0521e-16, 1.8319e-16, 1.1305e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "181000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.1580e-18, 1.4521e-33, 2.3187e-33, 1.0311e-33],\n", + " [7.6564e-09, 1.1257e-16, 1.9262e-16, 1.1961e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "182000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.0084e-18, 1.2922e-33, 1.7468e-33, 8.2467e-34],\n", + " [7.0179e-09, 1.7553e-16, 2.6043e-16, 1.6988e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "183000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.4347e-18, 1.3960e-33, 2.2740e-33, 1.0122e-33],\n", + " [8.6402e-09, 1.2112e-16, 2.0601e-16, 1.2839e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "184000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.6202e-18, 1.3348e-33, 2.0832e-33, 9.4518e-34],\n", + " [8.7771e-09, 1.4237e-16, 2.3138e-16, 1.4668e-16],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "185000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9313e-20, 3.5155e-38, 1.0407e-37, 5.5990e-38],\n", + " [7.0221e-10, 9.1095e-19, 2.1832e-18, 1.4709e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "186000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9006e-20, 3.4938e-38, 1.0322e-37, 5.5585e-38],\n", + " [6.9973e-10, 9.1111e-19, 2.1791e-18, 1.4691e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "187000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9869e-20, 3.5398e-38, 1.0515e-37, 5.6495e-38],\n", + " [7.0695e-10, 9.0975e-19, 2.1873e-18, 1.4722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "188000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8219e-20, 3.4359e-38, 1.0096e-37, 5.4506e-38],\n", + " [6.9369e-10, 9.1264e-19, 2.1698e-18, 1.4659e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "189000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.4013e-20, 3.2183e-38, 9.1366e-38, 5.0050e-38],\n", + " [6.6097e-10, 9.4354e-19, 2.1648e-18, 1.4797e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "190000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7437e-20, 3.3929e-38, 9.8899e-38, 5.3594e-38],\n", + " [6.9011e-10, 9.2534e-19, 2.1801e-18, 1.4775e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "191000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.6251e-20, 3.3797e-38, 9.7125e-38, 5.2939e-38],\n", + " [6.8534e-10, 9.5684e-19, 2.2205e-18, 1.5122e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "192000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0325e-20, 3.4623e-38, 1.0329e-37, 5.5485e-38],\n", + " [7.1046e-10, 8.9432e-19, 2.1555e-18, 1.4504e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "193000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5643e-20, 3.4007e-38, 9.6573e-38, 5.2907e-38],\n", + " [6.8717e-10, 9.9506e-19, 2.2782e-18, 1.5585e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "194000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8339e-20, 3.4314e-38, 1.0016e-37, 5.4297e-38],\n", + " [7.0335e-10, 9.4133e-19, 2.2156e-18, 1.5025e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "195000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6973e-20, 3.4215e-38, 9.8264e-38, 5.3624e-38],\n", + " [6.9818e-10, 9.7900e-19, 2.2649e-18, 1.5446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "196000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9600e-20, 3.5101e-38, 1.1278e-37, 5.8923e-38],\n", + " [7.5462e-10, 7.6341e-19, 1.9821e-18, 1.3031e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "197000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9437e-20, 3.4423e-38, 1.0115e-37, 5.4736e-38],\n", + " [7.1404e-10, 9.3681e-19, 2.2164e-18, 1.5010e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "198000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8559e-20, 3.4363e-38, 9.9924e-38, 5.4310e-38],\n", + " [7.1147e-10, 9.6201e-19, 2.2503e-18, 1.5297e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "199000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9717e-20, 3.4455e-38, 1.0121e-37, 5.4808e-38],\n", + " [7.1905e-10, 9.4389e-19, 2.2298e-18, 1.5111e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "200000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7774e-20, 3.4321e-38, 9.8661e-38, 5.3895e-38],\n", + " [7.1127e-10, 9.9402e-19, 2.2949e-18, 1.5669e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "201000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2308e-20, 3.4644e-38, 1.0400e-37, 5.5876e-38],\n", + " [7.3506e-10, 9.0605e-19, 2.1859e-18, 1.4718e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "202000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6594e-20, 3.4242e-38, 9.6807e-38, 5.3262e-38],\n", + " [7.0945e-10, 1.0400e-18, 2.3567e-18, 1.6191e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "203000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9682e-20, 3.4480e-38, 1.0054e-37, 5.4671e-38],\n", + " [7.2728e-10, 9.7473e-19, 2.2787e-18, 1.5502e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "204000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.7470e-20, 3.4323e-38, 9.7663e-38, 5.3630e-38],\n", + " [7.1781e-10, 1.0325e-18, 2.3524e-18, 1.6138e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "205000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9903e-20, 3.4510e-38, 1.0049e-37, 5.4707e-38],\n", + " [7.3272e-10, 9.8573e-19, 2.2978e-18, 1.5650e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "206000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9257e-20, 3.4471e-38, 9.9560e-38, 5.4391e-38],\n", + " [7.3144e-10, 1.0072e-18, 2.3268e-18, 1.5896e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "207000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.8126e-20, 3.4391e-38, 9.8039e-38, 5.3847e-38],\n", + " [7.2731e-10, 1.0400e-18, 2.3691e-18, 1.6259e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "208000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3890e-20, 3.4801e-38, 1.0472e-37, 5.6330e-38],\n", + " [7.5679e-10, 9.2560e-19, 2.2279e-18, 1.5024e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "209000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7721e-20, 3.5074e-38, 1.0868e-37, 5.7821e-38],\n", + " [7.7554e-10, 8.7034e-19, 2.1575e-18, 1.4417e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "210000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.7687e-20, 3.5079e-38, 1.0850e-37, 5.7782e-38],\n", + " [7.7745e-10, 8.7704e-19, 2.1687e-18, 1.4504e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "211000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0732e-20, 3.4606e-38, 1.0060e-37, 5.4901e-38],\n", + " [7.4869e-10, 1.0112e-18, 2.3439e-18, 1.6004e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "212000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5289e-20, 3.4923e-38, 1.0562e-37, 5.6774e-38],\n", + " [7.7160e-10, 9.2928e-19, 2.2423e-18, 1.5117e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "213000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2762e-20, 3.4760e-38, 1.0266e-37, 5.5713e-38],\n", + " [7.6238e-10, 9.8340e-19, 2.3140e-18, 1.5728e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "214000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4867e-20, 3.4909e-38, 1.0487e-37, 5.6552e-38],\n", + " [7.7382e-10, 9.5004e-19, 2.2738e-18, 1.5372e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "215000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9613e-20, 3.5246e-38, 1.0968e-37, 5.8366e-38],\n", + " [7.9638e-10, 8.8194e-19, 2.1869e-18, 1.4623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "216000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0194e-20, 3.4592e-38, 9.9217e-38, 5.4512e-38],\n", + " [7.5601e-10, 1.0605e-18, 2.4168e-18, 1.6601e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "217000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9715e-20, 3.5267e-38, 1.0948e-37, 5.8349e-38],\n", + " [8.0086e-10, 8.9267e-19, 2.2055e-18, 1.4768e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "218000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4760e-20, 3.4924e-38, 1.0406e-37, 5.6370e-38],\n", + " [7.8261e-10, 9.8314e-19, 2.3266e-18, 1.5794e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "219000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.1248e-20, 3.4685e-38, 9.9950e-38, 5.4870e-38],\n", + " [7.6816e-10, 1.0625e-18, 2.4278e-18, 1.6669e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "220000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3401e-20, 3.4842e-38, 1.0224e-37, 5.5750e-38],\n", + " [7.8079e-10, 1.0250e-18, 2.3843e-18, 1.6279e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "221000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6444e-20, 3.5062e-38, 1.0540e-37, 5.6951e-38],\n", + " [7.9658e-10, 9.7475e-19, 2.3231e-18, 1.5741e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "222000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8517e-20, 3.5215e-38, 1.0737e-37, 5.7721e-38],\n", + " [8.0802e-10, 9.4841e-19, 2.2918e-18, 1.5463e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "223000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4831e-20, 3.4953e-38, 1.0332e-37, 5.6232e-38],\n", + " [7.9411e-10, 1.0202e-18, 2.3864e-18, 1.6270e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "224000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6441e-20, 3.5080e-38, 1.0487e-37, 5.6847e-38],\n", + " [8.0389e-10, 9.9928e-19, 2.3627e-18, 1.6056e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "225000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8903e-20, 3.5263e-38, 1.0727e-37, 5.7774e-38],\n", + " [8.1668e-10, 9.6462e-19, 2.3205e-18, 1.5686e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "226000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7078e-20, 3.5139e-38, 1.0519e-37, 5.7029e-38],\n", + " [8.1165e-10, 1.0046e-18, 2.3750e-18, 1.6145e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "227000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4367e-20, 3.4944e-38, 1.0214e-37, 5.5907e-38],\n", + " [8.0137e-10, 1.0628e-18, 2.4503e-18, 1.6792e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "228000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8651e-20, 3.5258e-38, 1.0648e-37, 5.7569e-38],\n", + " [8.2289e-10, 9.9227e-19, 2.3641e-18, 1.6036e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "229000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.4793e-20, 3.4986e-38, 1.0220e-37, 5.5998e-38],\n", + " [8.0902e-10, 1.0745e-18, 2.4715e-18, 1.6955e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "230000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8031e-20, 3.5231e-38, 1.0543e-37, 5.7250e-38],\n", + " [8.2619e-10, 1.0227e-18, 2.4095e-18, 1.6407e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "231000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2282e-20, 3.4822e-38, 9.9102e-38, 5.4891e-38],\n", + " [8.0167e-10, 1.1474e-18, 2.5656e-18, 1.7765e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "232000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.0882e-20, 3.5446e-38, 1.0791e-37, 5.8252e-38],\n", + " [8.4378e-10, 9.9332e-19, 2.3781e-18, 1.6116e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "233000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6389e-20, 3.5123e-38, 1.0315e-37, 5.6484e-38],\n", + " [8.2685e-10, 1.0805e-18, 2.4911e-18, 1.7086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "234000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.0979e-20, 3.4726e-38, 9.6998e-38, 5.4183e-38],\n", + " [8.0319e-10, 1.2122e-18, 2.6522e-18, 1.8501e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "235000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7792e-20, 3.5238e-38, 1.0414e-37, 5.6937e-38],\n", + " [8.3970e-10, 1.0769e-18, 2.4940e-18, 1.7088e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "236000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[2.9909e-20, 3.4648e-38, 9.5369e-38, 5.3619e-38],\n", + " [8.0286e-10, 1.2634e-18, 2.7184e-18, 1.9070e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "237000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2054e-20, 3.4823e-38, 9.7649e-38, 5.4527e-38],\n", + " [8.1707e-10, 1.2190e-18, 2.6709e-18, 1.8631e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "238000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.6260e-20, 3.5138e-38, 1.0197e-37, 5.6210e-38],\n", + " [8.4107e-10, 1.1366e-18, 2.5773e-18, 1.7786e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "239000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8069e-20, 3.5950e-38, 1.1304e-37, 6.0436e-38],\n", + " [8.9362e-10, 9.5640e-19, 2.3526e-18, 1.5826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "240000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9430e-20, 3.5382e-38, 1.0478e-37, 5.7353e-38],\n", + " [8.6134e-10, 1.0970e-18, 2.5352e-18, 1.7396e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "241000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9392e-20, 3.5384e-38, 1.0456e-37, 5.7300e-38],\n", + " [8.6382e-10, 1.1069e-18, 2.5506e-18, 1.7520e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "242000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9635e-20, 3.5407e-38, 1.0455e-37, 5.7339e-38],\n", + " [8.6851e-10, 1.1151e-18, 2.5649e-18, 1.7632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "243000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4522e-20, 3.5749e-38, 1.0897e-37, 5.9060e-38],\n", + " [8.9242e-10, 1.0445e-18, 2.4800e-18, 1.6882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "244000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3303e-20, 3.5674e-38, 1.0763e-37, 5.8587e-38],\n", + " [8.9051e-10, 1.0736e-18, 2.5202e-18, 1.7220e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "245000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0922e-20, 3.5510e-38, 1.0518e-37, 5.7684e-38],\n", + " [8.8302e-10, 1.1228e-18, 2.5844e-18, 1.7771e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "246000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3756e-20, 3.5714e-38, 1.0770e-37, 5.8676e-38],\n", + " [8.9758e-10, 1.0835e-18, 2.5383e-18, 1.7359e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "247000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6724e-20, 3.5202e-38, 1.0067e-37, 5.6001e-38],\n", + " [8.6864e-10, 1.2225e-18, 2.7107e-18, 1.8865e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "248000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.9910e-20, 3.5451e-38, 1.0364e-37, 5.7191e-38],\n", + " [8.8677e-10, 1.1705e-18, 2.6523e-18, 1.8336e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "249000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7779e-20, 3.5286e-38, 1.0131e-37, 5.6317e-38],\n", + " [8.7986e-10, 1.2238e-18, 2.7196e-18, 1.8920e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "250000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.3633e-20, 3.4967e-38, 9.6836e-38, 5.4605e-38],\n", + " [8.6135e-10, 1.3287e-18, 2.8438e-18, 2.0024e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "251000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0679e-20, 3.5513e-38, 1.0377e-37, 5.7338e-38],\n", + " [8.9909e-10, 1.1880e-18, 2.6837e-18, 1.8579e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "252000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2297e-20, 3.5635e-38, 1.0509e-37, 5.7885e-38],\n", + " [9.0955e-10, 1.1700e-18, 2.6657e-18, 1.8409e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "253000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8943e-20, 3.5388e-38, 1.0169e-37, 5.6595e-38],\n", + " [8.9686e-10, 1.2435e-18, 2.7568e-18, 1.9205e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "254000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6198e-20, 3.5910e-38, 1.0820e-37, 5.9157e-38],\n", + " [9.3260e-10, 1.1269e-18, 2.6200e-18, 1.7984e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "255000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6912e-20, 3.5963e-38, 1.0865e-37, 5.9362e-38],\n", + " [9.3845e-10, 1.1254e-18, 2.6215e-18, 1.7987e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "256000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4112e-20, 3.5776e-38, 1.0587e-37, 5.8338e-38],\n", + " [9.3061e-10, 1.1844e-18, 2.6983e-18, 1.8647e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "257000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.2611e-20, 3.5671e-38, 1.0428e-37, 5.7755e-38],\n", + " [9.2709e-10, 1.2220e-18, 2.7472e-18, 1.9068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "258000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3179e-20, 3.6364e-38, 1.1310e-37, 6.1196e-38],\n", + " [9.7502e-10, 1.0746e-18, 2.5705e-18, 1.7500e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "259000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.9383e-20, 3.6137e-38, 1.0974e-37, 5.9954e-38],\n", + " [9.6368e-10, 1.1377e-18, 2.6536e-18, 1.8213e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "260000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3230e-20, 3.5717e-38, 1.0405e-37, 5.7791e-38],\n", + " [9.4151e-10, 1.2529e-18, 2.7976e-18, 1.9471e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "261000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7960e-20, 3.6049e-38, 1.0797e-37, 5.9362e-38],\n", + " [9.6604e-10, 1.1864e-18, 2.7225e-18, 1.8790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "262000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7236e-20, 3.6005e-38, 1.0709e-37, 5.9063e-38],\n", + " [9.6699e-10, 1.2117e-18, 2.7577e-18, 1.9086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "263000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7359e-20, 3.6016e-38, 1.0696e-37, 5.9053e-38],\n", + " [9.7106e-10, 1.2219e-18, 2.7741e-18, 1.9218e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "264000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.7675e-20, 3.6661e-38, 1.1508e-37, 6.2223e-38],\n", + " [1.0155e-09, 1.0894e-18, 2.6146e-18, 1.7803e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "265000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3157e-20, 3.5721e-38, 1.0275e-37, 5.7482e-38],\n", + " [9.5993e-10, 1.3241e-18, 2.9038e-18, 2.0345e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "266000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0024e-20, 3.5361e-38, 9.9251e-38, 5.6085e-38],\n", + " [9.4924e-10, 1.4005e-18, 2.9926e-18, 2.1145e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "267000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2654e-20, 3.6376e-38, 1.1035e-37, 6.0544e-38],\n", + " [1.0086e-09, 1.1934e-18, 2.7576e-18, 1.9013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "268000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9182e-20, 3.6145e-38, 1.0723e-37, 5.9363e-38],\n", + " [9.9810e-10, 1.2590e-18, 2.8408e-18, 1.9737e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "269000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6202e-20, 3.5937e-38, 1.0448e-37, 5.8314e-38],\n", + " [9.8823e-10, 1.3210e-18, 2.9176e-18, 2.0411e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "270000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5595e-20, 3.5872e-38, 1.0364e-37, 5.8016e-38],\n", + " [9.8927e-10, 1.3453e-18, 2.9496e-18, 2.0687e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "271000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2960e-20, 3.5533e-38, 1.0071e-37, 5.6818e-38],\n", + " [9.8046e-10, 1.4038e-18, 3.0158e-18, 2.1291e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "272000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5739e-20, 3.6565e-38, 1.1154e-37, 6.1198e-38],\n", + " [1.0392e-09, 1.2096e-18, 2.7976e-18, 1.9300e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "273000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.7497e-20, 3.5977e-38, 1.0452e-37, 5.8457e-38],\n", + " [1.0083e-09, 1.3481e-18, 2.9645e-18, 2.0783e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "274000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6146e-20, 3.5788e-38, 1.0290e-37, 5.7808e-38],\n", + " [1.0056e-09, 1.3817e-18, 3.0042e-18, 2.1141e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "275000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.9001e-20, 3.6757e-38, 1.1329e-37, 6.1989e-38],\n", + " [1.0625e-09, 1.2003e-18, 2.7980e-18, 1.9265e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "276000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6903e-20, 3.5787e-38, 1.0289e-37, 5.7862e-38],\n", + " [1.0171e-09, 1.3957e-18, 3.0283e-18, 2.1333e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "277000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5049e-20, 3.5544e-38, 1.0081e-37, 5.7013e-38],\n", + " [1.0119e-09, 1.4400e-18, 3.0787e-18, 2.1793e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "278000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.7341e-20, 3.5753e-38, 1.0259e-37, 5.7790e-38],\n", + " [1.0271e-09, 1.4152e-18, 3.0581e-18, 2.1580e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "279000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9036e-20, 3.5902e-38, 1.0384e-37, 5.8342e-38],\n", + " [1.0384e-09, 1.3994e-18, 3.0456e-18, 2.1446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "280000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8933e-20, 3.6756e-38, 1.1174e-37, 6.1630e-38],\n", + " [1.0855e-09, 1.2752e-18, 2.9147e-18, 2.0215e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "281000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0894e-20, 3.5985e-38, 1.0448e-37, 5.8700e-38],\n", + " [1.0587e-09, 1.4093e-18, 3.0700e-18, 2.1625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "282000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.3299e-20, 3.6184e-38, 1.0618e-37, 5.9445e-38],\n", + " [1.0739e-09, 1.3881e-18, 3.0529e-18, 2.1445e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "283000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8323e-20, 3.5608e-38, 1.0130e-37, 5.7427e-38],\n", + " [1.0568e-09, 1.4842e-18, 3.1596e-18, 2.2430e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "284000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.1801e-20, 3.7485e-38, 1.1940e-37, 6.4834e-38],\n", + " [1.1529e-09, 1.1857e-18, 2.8280e-18, 1.9370e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "285000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2299e-20, 3.5943e-38, 1.0409e-37, 5.8668e-38],\n", + " [1.0835e-09, 1.4482e-18, 3.1323e-18, 2.2134e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "286000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3639e-20, 3.6036e-38, 1.0487e-37, 5.9024e-38],\n", + " [1.0938e-09, 1.4419e-18, 3.1308e-18, 2.2101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "287000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3833e-20, 3.6010e-38, 1.0462e-37, 5.8954e-38],\n", + " [1.0997e-09, 1.4552e-18, 3.1506e-18, 2.2267e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "288000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.4855e-20, 3.6065e-38, 1.0506e-37, 5.9178e-38],\n", + " [1.1091e-09, 1.4561e-18, 3.1573e-18, 2.2309e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "289000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0626e-20, 3.6576e-38, 1.0939e-37, 6.1027e-38],\n", + " [1.1377e-09, 1.3907e-18, 3.0934e-18, 2.1685e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "290000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.3739e-20, 3.4745e-38, 9.4338e-38, 5.4658e-38],\n", + " [1.0661e-09, 1.6891e-18, 3.4032e-18, 2.4623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "291000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5359e-20, 3.5971e-38, 1.0427e-37, 5.8938e-38],\n", + " [1.1254e-09, 1.4941e-18, 3.2129e-18, 2.2776e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "292000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2595e-20, 3.5631e-38, 1.0145e-37, 5.7780e-38],\n", + " [1.1192e-09, 1.5580e-18, 3.2855e-18, 2.3442e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "293000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1492e-20, 3.5470e-38, 1.0010e-37, 5.7241e-38],\n", + " [1.1191e-09, 1.5941e-18, 3.3279e-18, 2.3826e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "294000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.8099e-20, 3.6990e-38, 1.1289e-37, 6.2669e-38],\n", + " [1.1929e-09, 1.3769e-18, 3.1073e-18, 2.1710e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "295000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7107e-20, 3.4868e-38, 9.5342e-38, 5.5256e-38],\n", + " [1.1090e-09, 1.7169e-18, 3.4624e-18, 2.5076e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "296000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6752e-20, 3.7587e-38, 1.1811e-37, 6.4911e-38],\n", + " [1.2350e-09, 1.3169e-18, 3.0533e-18, 2.1162e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "297000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.9762e-20, 3.6066e-38, 1.0505e-37, 5.9489e-38],\n", + " [1.1774e-09, 1.5362e-18, 3.2943e-18, 2.3410e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "298000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.8819e-20, 3.5907e-38, 1.0378e-37, 5.8985e-38],\n", + " [1.1796e-09, 1.5700e-18, 3.3357e-18, 2.3781e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "299000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6408e-20, 3.4540e-38, 9.2970e-38, 5.4342e-38],\n", + " [1.1263e-09, 1.8121e-18, 3.5791e-18, 2.6119e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "300000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8253e-20, 3.5742e-38, 1.0244e-37, 5.8483e-38],\n", + " [1.1880e-09, 1.6144e-18, 3.3932e-18, 2.4286e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "301000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5225e-20, 3.6348e-38, 1.0742e-37, 6.0633e-38],\n", + " [1.2215e-09, 1.5288e-18, 3.3108e-18, 2.3477e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "302000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0196e-20, 3.5851e-38, 1.0332e-37, 5.8909e-38],\n", + " [1.2044e-09, 1.6113e-18, 3.3994e-18, 2.4310e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "303000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.2415e-20, 3.5997e-38, 1.0453e-37, 5.9463e-38],\n", + " [1.2197e-09, 1.5980e-18, 3.3926e-18, 2.4220e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "304000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.0759e-20, 3.5783e-38, 1.0282e-37, 5.8763e-38],\n", + " [1.2182e-09, 1.6402e-18, 3.4413e-18, 2.4665e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "305000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.7332e-20, 3.4310e-38, 9.1431e-38, 5.3829e-38],\n", + " [1.1605e-09, 1.9085e-18, 3.7061e-18, 2.7230e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "306000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.9258e-20, 3.7228e-38, 1.1483e-37, 6.3949e-38],\n", + " [1.3033e-09, 1.4511e-18, 3.2609e-18, 2.2882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "307000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8797e-20, 3.7866e-38, 1.2043e-37, 6.6320e-38],\n", + " [1.3410e-09, 1.3757e-18, 3.1847e-18, 2.2144e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "308000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5762e-20, 3.5984e-38, 1.0456e-37, 5.9654e-38],\n", + " [1.2634e-09, 1.6459e-18, 3.4743e-18, 2.4881e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "309000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8232e-20, 3.5205e-38, 9.8455e-38, 5.7042e-38],\n", + " [1.2369e-09, 1.7823e-18, 3.6149e-18, 2.6224e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "310000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7071e-20, 3.5031e-38, 9.7143e-38, 5.6496e-38],\n", + " [1.2367e-09, 1.8211e-18, 3.6582e-18, 2.6626e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "311000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.5262e-20, 3.6596e-38, 1.0961e-37, 6.1931e-38],\n", + " [1.3202e-09, 1.5838e-18, 3.4327e-18, 2.4398e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "312000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8087e-20, 3.5926e-38, 1.0420e-37, 5.9645e-38],\n", + " [1.2983e-09, 1.6946e-18, 3.5513e-18, 2.5519e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "313000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5848e-20, 3.5657e-38, 1.0210e-37, 5.8774e-38],\n", + " [1.2956e-09, 1.7480e-18, 3.6112e-18, 2.6074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "314000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2425e-20, 3.5259e-38, 9.9078e-38, 5.7490e-38],\n", + " [1.2877e-09, 1.8243e-18, 3.6928e-18, 2.6844e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "315000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3139e-20, 3.4258e-38, 9.1603e-38, 5.4211e-38],\n", + " [1.2495e-09, 2.0175e-18, 3.8796e-18, 2.8673e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "316000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1244e-20, 3.4999e-38, 9.7162e-38, 5.6724e-38],\n", + " [1.2963e-09, 1.8935e-18, 3.7750e-18, 2.7591e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "317000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2532e-20, 3.5059e-38, 9.7649e-38, 5.6970e-38],\n", + " [1.3081e-09, 1.8929e-18, 3.7816e-18, 2.7628e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "318000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7510e-20, 3.5440e-38, 1.0057e-37, 5.8301e-38],\n", + " [1.3380e-09, 1.8418e-18, 3.7429e-18, 2.7207e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "319000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0515e-20, 3.6452e-38, 1.0853e-37, 6.1812e-38],\n", + " [1.3980e-09, 1.6948e-18, 3.6088e-18, 2.5855e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "320000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8598e-20, 3.5385e-38, 1.0023e-37, 5.8229e-38],\n", + " [1.3570e-09, 1.8739e-18, 3.7902e-18, 2.7609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "321000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8717e-20, 3.5310e-38, 9.9733e-38, 5.8047e-38],\n", + " [1.3650e-09, 1.8975e-18, 3.8211e-18, 2.7881e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "322000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.8814e-20, 3.4295e-38, 9.2289e-38, 5.4761e-38],\n", + " [1.3262e-09, 2.0922e-18, 4.0076e-18, 2.9719e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "323000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.4115e-20, 3.4725e-38, 9.5463e-38, 5.6229e-38],\n", + " [1.3597e-09, 2.0261e-18, 3.9585e-18, 2.9181e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "324000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.5332e-20, 3.4754e-38, 9.5744e-38, 5.6390e-38],\n", + " [1.3728e-09, 2.0324e-18, 3.9732e-18, 2.9293e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "325000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5792e-20, 3.4725e-38, 9.5571e-38, 5.6348e-38],\n", + " [1.3818e-09, 2.0496e-18, 3.9972e-18, 2.9501e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "326000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.8448e-20, 3.6492e-38, 1.0911e-37, 6.2366e-38],\n", + " [1.4828e-09, 1.7690e-18, 3.7428e-18, 2.6928e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "327000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0174e-20, 3.5783e-38, 1.0360e-37, 5.9999e-38],\n", + " [1.4596e-09, 1.8932e-18, 3.8720e-18, 2.8169e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "328000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9049e-20, 3.4770e-38, 9.6071e-38, 5.6686e-38],\n", + " [1.4198e-09, 2.0794e-18, 4.0524e-18, 2.9944e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "329000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.4806e-20, 3.5193e-38, 9.9248e-38, 5.8142e-38],\n", + " [1.4519e-09, 2.0143e-18, 4.0015e-18, 2.9397e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "330000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.8401e-20, 3.6184e-38, 1.0682e-37, 6.1530e-38],\n", + " [1.5138e-09, 1.8627e-18, 3.8682e-18, 2.8029e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "331000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6817e-20, 3.5963e-38, 1.0515e-37, 6.0854e-38],\n", + " [1.5185e-09, 1.9142e-18, 3.9295e-18, 2.8589e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "332000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8570e-20, 3.6017e-38, 1.0561e-37, 6.1094e-38],\n", + " [1.5330e-09, 1.9175e-18, 3.9415e-18, 2.8673e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "333000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7321e-20, 3.6542e-38, 1.0973e-37, 6.2957e-38],\n", + " [1.5749e-09, 1.8504e-18, 3.8884e-18, 2.8100e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "334000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2723e-20, 3.4568e-38, 9.5015e-38, 5.6434e-38],\n", + " [1.4844e-09, 2.1935e-18, 4.2128e-18, 3.1334e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "335000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.7423e-20, 3.5659e-38, 1.0307e-37, 6.0100e-38],\n", + " [1.5552e-09, 2.0150e-18, 4.0629e-18, 2.9768e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "336000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0894e-20, 3.5064e-38, 9.8758e-38, 5.8202e-38],\n", + " [1.5367e-09, 2.1280e-18, 4.1748e-18, 3.0863e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "337000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.9427e-20, 3.4822e-38, 9.7114e-38, 5.7506e-38],\n", + " [1.5417e-09, 2.1880e-18, 4.2416e-18, 3.1488e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "338000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.9207e-20, 3.4709e-38, 9.6378e-38, 5.7213e-38],\n", + " [1.5497e-09, 2.2227e-18, 4.2829e-18, 3.1867e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "339000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0352e-20, 3.3868e-38, 9.0509e-38, 5.4569e-38],\n", + " [1.5185e-09, 2.4043e-18, 4.4510e-18, 3.3553e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "340000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4346e-20, 3.4134e-38, 9.2399e-38, 5.5476e-38],\n", + " [1.5455e-09, 2.3654e-18, 4.4288e-18, 3.3276e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "341000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4934e-20, 3.4083e-38, 9.2089e-38, 5.5382e-38],\n", + " [1.5587e-09, 2.3952e-18, 4.4678e-18, 3.3623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "342000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9296e-20, 3.5078e-38, 9.9271e-38, 5.8720e-38],\n", + " [1.6343e-09, 2.2257e-18, 4.3375e-18, 3.2208e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "343000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.1680e-20, 3.4406e-38, 9.4585e-38, 5.6611e-38],\n", + " [1.6096e-09, 2.3611e-18, 4.4639e-18, 3.3475e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "344000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.7479e-20, 3.3955e-38, 9.1529e-38, 5.5248e-38],\n", + " [1.6015e-09, 2.4693e-18, 4.5692e-18, 3.4513e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "345000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9132e-20, 3.4744e-38, 9.7114e-38, 5.7878e-38],\n", + " [1.6656e-09, 2.3372e-18, 4.4734e-18, 3.3446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "346000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0608e-19, 3.5834e-38, 1.0506e-37, 6.1532e-38],\n", + " [1.7417e-09, 2.1610e-18, 4.3304e-18, 3.1921e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "347000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3905e-20, 3.3331e-38, 8.7618e-38, 5.3538e-38],\n", + " [1.6137e-09, 2.6487e-18, 4.7540e-18, 3.6298e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "348000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.5908e-20, 3.4215e-38, 9.3668e-38, 5.6402e-38],\n", + " [1.6790e-09, 2.4811e-18, 4.6292e-18, 3.4927e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "349000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.8032e-20, 3.4999e-38, 9.9231e-38, 5.9011e-38],\n", + " [1.7401e-09, 2.3491e-18, 4.5302e-18, 3.3837e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "350000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1479e-20, 3.2824e-38, 8.4514e-38, 5.2187e-38],\n", + " [1.6304e-09, 2.8176e-18, 4.9280e-18, 3.7977e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "351000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1621e-19, 3.5965e-38, 1.0634e-37, 6.2352e-38],\n", + " [1.8326e-09, 2.2203e-18, 4.4466e-18, 3.2843e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "352000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1472e-19, 3.5732e-38, 1.0478e-37, 6.1699e-38],\n", + " [1.8405e-09, 2.2754e-18, 4.5100e-18, 3.3436e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "353000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4310e-20, 3.3526e-38, 8.9497e-38, 5.4664e-38],\n", + " [1.7260e-09, 2.7114e-18, 4.8871e-18, 3.7350e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "354000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.9761e-20, 3.3835e-38, 9.1695e-38, 5.5729e-38],\n", + " [1.7601e-09, 2.6582e-18, 4.8558e-18, 3.6967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "355000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.2804e-20, 3.3937e-38, 9.2509e-38, 5.6151e-38],\n", + " [1.7850e-09, 2.6542e-18, 4.8672e-18, 3.7021e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "356000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1512e-19, 3.5273e-38, 1.0188e-37, 6.0574e-38],\n", + " [1.8917e-09, 2.4256e-18, 4.6983e-18, 3.5143e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "357000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2009e-19, 3.5447e-38, 1.0320e-37, 6.1237e-38],\n", + " [1.9243e-09, 2.4175e-18, 4.7087e-18, 3.5174e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "358000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4332e-20, 3.3650e-38, 9.0929e-38, 5.5555e-38],\n", + " [1.8315e-09, 2.7793e-18, 5.0190e-18, 3.8414e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "359000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0942e-20, 3.2508e-38, 8.3642e-38, 5.2117e-38],\n", + " [1.7801e-09, 3.0585e-18, 5.2506e-18, 4.0852e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "360000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8789e-20, 3.2988e-38, 8.6813e-38, 5.3689e-38],\n", + " [1.8318e-09, 2.9699e-18, 5.2019e-18, 4.0236e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "361000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0896e-20, 3.2264e-38, 8.2329e-38, 5.1562e-38],\n", + " [1.8031e-09, 3.1599e-18, 5.3589e-18, 4.1891e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "362000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4771e-20, 3.3125e-38, 8.7996e-38, 5.4358e-38],\n", + " [1.8890e-09, 2.9862e-18, 5.2537e-18, 4.0622e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "363000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0801e-20, 3.1930e-38, 8.0594e-38, 5.0816e-38],\n", + " [1.8333e-09, 3.2971e-18, 5.5029e-18, 4.3283e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "364000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0651e-19, 3.3606e-38, 9.1478e-38, 5.6122e-38],\n", + " [1.9721e-09, 2.9265e-18, 5.2481e-18, 4.0374e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "365000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7101e-20, 3.0434e-38, 7.2097e-38, 4.6673e-38],\n", + " [1.7815e-09, 3.7549e-18, 5.8596e-18, 4.7126e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "366000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1328e-19, 3.3775e-38, 9.2875e-38, 5.6876e-38],\n", + " [2.0267e-09, 2.9289e-18, 5.2836e-18, 4.0606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "367000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1322e-19, 3.3654e-38, 9.2171e-38, 5.6585e-38],\n", + " [2.0392e-09, 2.9760e-18, 5.3368e-18, 4.1108e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "368000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.0024e-20, 3.0315e-38, 7.1898e-38, 4.6641e-38],\n", + " [1.8291e-09, 3.8290e-18, 5.9530e-18, 4.7989e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "369000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.3922e-20, 3.1349e-38, 7.8030e-38, 4.9766e-38],\n", + " [1.9249e-09, 3.5691e-18, 5.8020e-18, 4.6138e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "370000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.2392e-20, 3.1878e-38, 8.1320e-38, 5.1432e-38],\n", + " [1.9803e-09, 3.4503e-18, 5.7357e-18, 4.5307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "371000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1486e-20, 3.1686e-38, 8.0270e-38, 5.0954e-38],\n", + " [1.9887e-09, 3.5250e-18, 5.8076e-18, 4.6025e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "372000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6412e-20, 3.1165e-38, 7.7288e-38, 4.9515e-38],\n", + " [1.9766e-09, 3.6941e-18, 5.9462e-18, 4.7496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "373000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3381e-20, 3.1538e-38, 7.9626e-38, 5.0730e-38],\n", + " [2.0288e-09, 3.6240e-18, 5.9220e-18, 4.7101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "374000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.5043e-20, 3.0770e-38, 7.5251e-38, 4.8582e-38],\n", + " [1.9985e-09, 3.8642e-18, 6.1060e-18, 4.9109e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "375000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2113e-19, 3.3075e-38, 8.9385e-38, 5.5620e-38],\n", + " [2.1870e-09, 3.2928e-18, 5.7279e-18, 4.4706e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "376000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6477e-20, 3.0624e-38, 7.4665e-38, 4.8355e-38],\n", + " [2.0324e-09, 3.9565e-18, 6.2074e-18, 5.0079e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "377000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1921e-19, 3.2700e-38, 8.7218e-38, 5.4661e-38],\n", + " [2.2090e-09, 3.4369e-18, 5.8753e-18, 4.6152e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "378000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3754e-19, 3.3579e-38, 9.2941e-38, 5.7516e-38],\n", + " [2.3045e-09, 3.2697e-18, 5.7806e-18, 4.4955e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "379000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1073e-20, 3.0488e-38, 7.4373e-38, 4.8320e-38],\n", + " [2.1026e-09, 4.0751e-18, 6.3542e-18, 5.1443e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "380000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0303e-19, 3.1180e-38, 7.8547e-38, 5.0486e-38],\n", + " [2.1829e-09, 3.9091e-18, 6.2713e-18, 5.0341e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "381000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9697e-20, 3.0792e-38, 7.6457e-38, 4.9471e-38],\n", + " [2.1825e-09, 4.0490e-18, 6.3884e-18, 5.1579e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "382000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2136e-19, 3.2022e-38, 8.3904e-38, 5.3256e-38],\n", + " [2.3026e-09, 3.7373e-18, 6.2022e-18, 4.9304e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "383000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.1950e-20, 2.8835e-38, 6.5703e-38, 4.3835e-38],\n", + " [2.0984e-09, 4.6650e-18, 6.8189e-18, 5.6462e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "384000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.8818e-20, 2.9233e-38, 6.8117e-38, 4.5170e-38],\n", + " [2.1618e-09, 4.5752e-18, 6.7961e-18, 5.6019e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "385000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4646e-20, 2.8645e-38, 6.5053e-38, 4.3553e-38],\n", + " [2.1486e-09, 4.7919e-18, 6.9533e-18, 5.7776e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "386000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.9916e-20, 2.8931e-38, 6.6773e-38, 4.4518e-38],\n", + " [2.1986e-09, 4.7327e-18, 6.9455e-18, 5.7535e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "387000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0900e-19, 3.0368e-38, 7.5033e-38, 4.8963e-38],\n", + " [2.3289e-09, 4.3408e-18, 6.7289e-18, 5.4804e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "388000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.2784e-20, 2.8822e-38, 6.6464e-38, 4.4414e-38],\n", + " [2.2448e-09, 4.8277e-18, 7.0529e-18, 5.8567e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "389000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1292e-19, 3.0264e-38, 7.4760e-38, 4.8896e-38],\n", + " [2.3827e-09, 4.4313e-18, 6.8397e-18, 5.5842e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "390000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.6563e-20, 2.7871e-38, 6.1737e-38, 4.1893e-38],\n", + " [2.2315e-09, 5.2050e-18, 7.3251e-18, 6.1619e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "391000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6848e-20, 2.7658e-38, 6.0879e-38, 4.1445e-38],\n", + " [2.2496e-09, 5.3058e-18, 7.4108e-18, 6.2524e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "392000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.5932e-20, 2.8289e-38, 6.4307e-38, 4.3360e-38],\n", + " [2.3244e-09, 5.1197e-18, 7.3313e-18, 6.1393e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "393000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.4651e-20, 2.6153e-38, 5.3619e-38, 3.7438e-38],\n", + " [2.1861e-09, 5.9667e-18, 7.8270e-18, 6.7430e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "394000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.5584e-20, 2.6976e-38, 5.7858e-38, 3.9851e-38],\n", + " [2.2842e-09, 5.6624e-18, 7.6940e-18, 6.5583e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "395000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1683e-19, 2.9245e-38, 7.0068e-38, 4.6609e-38],\n", + " [2.5075e-09, 4.9293e-18, 7.3207e-18, 6.0707e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "396000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.2599e-20, 2.7168e-38, 5.9184e-38, 4.0654e-38],\n", + " [2.3665e-09, 5.6617e-18, 7.7580e-18, 6.6029e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "397000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3223e-19, 2.9871e-38, 7.4023e-38, 4.8811e-38],\n", + " [2.6284e-09, 4.8048e-18, 7.3062e-18, 6.0202e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "398000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9470e-20, 2.7307e-38, 6.0218e-38, 4.1301e-38],\n", + " [2.4486e-09, 5.6964e-18, 7.8477e-18, 6.6761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "399000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4603e-19, 3.0292e-38, 7.6869e-38, 5.0417e-38],\n", + " [2.7390e-09, 4.7561e-18, 7.3420e-18, 6.0278e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "400000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0153e-19, 2.7013e-38, 5.9134e-38, 4.0753e-38],\n", + " [2.4985e-09, 5.8822e-18, 8.0171e-18, 6.8512e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "401000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.0615e-20, 2.5905e-38, 5.3870e-38, 3.7803e-38],\n", + " [2.4395e-09, 6.3782e-18, 8.3117e-18, 7.2093e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "402000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0276e-19, 2.6649e-38, 5.7695e-38, 4.0010e-38],\n", + " [2.5444e-09, 6.1119e-18, 8.2137e-18, 7.0597e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "403000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6345e-20, 2.5987e-38, 5.4352e-38, 3.8176e-38],\n", + " [2.5200e-09, 6.4883e-18, 8.4521e-18, 7.3421e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "404000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3978e-20, 2.6607e-38, 5.1535e-38, 3.7150e-38],\n", + " [2.4183e-09, 7.2070e-18, 8.8352e-18, 7.8281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "405000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0882e-19, 2.6412e-38, 5.7077e-38, 3.9764e-38],\n", + " [2.6442e-09, 6.3502e-18, 8.4572e-18, 7.3042e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "406000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2583e-19, 2.7367e-38, 6.2106e-38, 4.2630e-38],\n", + " [2.7708e-09, 6.0101e-18, 8.3152e-18, 7.0990e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "407000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0270e-19, 2.6501e-38, 5.4593e-38, 3.8731e-38],\n", + " [2.6293e-09, 6.9090e-18, 8.8218e-18, 7.7313e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "408000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3192e-19, 2.7141e-38, 6.1472e-38, 4.2364e-38],\n", + " [2.8620e-09, 6.2135e-18, 8.5273e-18, 7.3105e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "409000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0196e-19, 2.6898e-38, 5.3760e-38, 3.8630e-38],\n", + " [2.6553e-09, 7.3518e-18, 9.1267e-18, 8.0817e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "410000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.7543e-20, 2.7219e-38, 5.2628e-38, 3.8275e-38],\n", + " [2.6302e-09, 7.7441e-18, 9.3520e-18, 8.3595e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "411000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0320e-19, 2.7227e-38, 5.3501e-38, 3.8757e-38],\n", + " [2.6942e-09, 7.6773e-18, 9.3671e-18, 8.3510e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "412000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1583e-20, 2.8604e-38, 4.6484e-38, 3.5857e-38],\n", + " [2.3973e-09, 9.8116e-18, 1.0324e-17, 9.6523e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "413000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0040e-19, 2.7723e-38, 5.2364e-38, 3.8534e-38],\n", + " [2.7016e-09, 8.2649e-18, 9.7354e-18, 8.7891e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "414000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1532e-19, 2.7480e-38, 5.4901e-38, 3.9726e-38],\n", + " [2.8446e-09, 7.8041e-18, 9.5764e-18, 8.5400e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "415000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0113e-19, 2.8071e-38, 5.1977e-38, 3.8600e-38],\n", + " [2.7373e-09, 8.6643e-18, 1.0007e-17, 9.1030e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "416000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.5741e-20, 2.8440e-38, 5.0612e-38, 3.8130e-38],\n", + " [2.7035e-09, 9.2098e-18, 1.0292e-17, 9.4679e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "417000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3090e-19, 2.7713e-38, 5.6783e-38, 4.0927e-38],\n", + " [3.0182e-09, 7.8525e-18, 9.7560e-18, 8.6844e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "418000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.4901e-19, 2.7548e-38, 5.9410e-38, 4.2178e-38],\n", + " [3.1699e-09, 7.4735e-18, 9.6342e-18, 8.4825e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "419000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2654e-19, 2.8155e-38, 5.5343e-38, 4.0545e-38],\n", + " [3.0185e-09, 8.4581e-18, 1.0130e-17, 9.1355e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "420000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2744e-19, 2.8313e-38, 5.5165e-38, 4.0590e-38],\n", + " [3.0427e-09, 8.6520e-18, 1.0268e-17, 9.2935e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "421000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.9341e-20, 2.9273e-38, 4.9782e-38, 3.8340e-38],\n", + " [2.8175e-09, 1.0349e-17, 1.1034e-17, 1.0339e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "422000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0189e-19, 2.9359e-38, 4.9991e-38, 3.8535e-38],\n", + " [2.8558e-09, 1.0443e-17, 1.1122e-17, 1.0432e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "423000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0751e-19, 2.9366e-38, 5.0803e-38, 3.9008e-38],\n", + " [2.9214e-09, 1.0350e-17, 1.1136e-17, 1.0418e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "424000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0323e-19, 2.9687e-38, 4.9645e-38, 3.8606e-38],\n", + " [2.9003e-09, 1.0932e-17, 1.1428e-17, 1.0798e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "425000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.7811e-20, 3.0315e-38, 4.6344e-38, 3.7150e-38],\n", + " [2.7605e-09, 1.2311e-17, 1.1987e-17, 1.1592e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "426000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3250e-19, 2.9378e-38, 5.4151e-38, 4.0923e-38],\n", + " [3.1899e-09, 9.9715e-18, 1.1177e-17, 1.0346e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "427000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0716e-19, 3.0168e-38, 4.9486e-38, 3.8897e-38],\n", + " [2.9877e-09, 1.1618e-17, 1.1878e-17, 1.1328e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "428000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8183e-20, 3.0924e-38, 4.5561e-38, 3.7134e-38],\n", + " [2.8139e-09, 1.3383e-17, 1.2570e-17, 1.2323e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "429000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2214e-19, 3.0245e-38, 5.1454e-38, 4.0101e-38],\n", + " [3.1617e-09, 1.1437e-17, 1.1959e-17, 1.1343e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "430000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1144e-19, 3.0628e-38, 4.9344e-38, 3.9186e-38],\n", + " [3.0792e-09, 1.2323e-17, 1.2335e-17, 1.1869e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "431000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.1900e-20, 3.1597e-38, 4.3284e-38, 3.6282e-38],\n", + " [2.7907e-09, 1.5123e-17, 1.3334e-17, 1.3366e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "432000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.2642e-20, 3.1732e-38, 4.3130e-38, 3.6299e-38],\n", + " [2.8150e-09, 1.5448e-17, 1.3505e-17, 1.3585e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "433000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.5930e-20, 3.1556e-38, 4.5401e-38, 3.7595e-38],\n", + " [2.9812e-09, 1.4662e-17, 1.3347e-17, 1.3269e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "434000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.3448e-19, 3.0812e-38, 5.1647e-38, 4.0777e-38],\n", + " [3.3597e-09, 1.2372e-17, 1.2631e-17, 1.2123e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "435000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.3553e-20, 3.1875e-38, 4.4395e-38, 3.7257e-38],\n", + " [2.9831e-09, 1.5542e-17, 1.3743e-17, 1.3806e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "436000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3086e-19, 4.1341e-38, 6.2034e-38, 5.0956e-38],\n", + " [3.5506e-09, 1.8225e-17, 1.6879e-17, 1.6745e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "437000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.9005e-20, 3.2484e-38, 3.8352e-38, 3.4055e-38],\n", + " [2.6791e-09, 1.8361e-17, 1.4313e-17, 1.4979e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "438000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1615e-19, 3.8388e-38, 5.4409e-38, 4.5665e-38],\n", + " [3.3753e-09, 1.8281e-17, 1.6187e-17, 1.6307e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "439000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.2872e-19, 3.9167e-38, 5.7262e-38, 4.7668e-38],\n", + " [3.5357e-09, 1.8274e-17, 1.6505e-17, 1.6539e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "440000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4538e-19, 4.0239e-38, 6.1099e-38, 5.0343e-38],\n", + " [3.7349e-09, 1.8270e-17, 1.6912e-17, 1.6835e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "441000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[9.9276e-20, 3.4439e-38, 4.5128e-38, 3.9045e-38],\n", + " [3.1592e-09, 1.8336e-17, 1.5248e-17, 1.5700e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "442000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.0633e-19, 3.4757e-38, 4.6424e-38, 3.9985e-38],\n", + " [3.2592e-09, 1.8330e-17, 1.5421e-17, 1.5833e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "443000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.1884e-19, 3.5567e-38, 4.9159e-38, 4.1952e-38],\n", + " [3.4265e-09, 1.8316e-17, 1.5754e-17, 1.6079e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "444000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.4227e-20, 3.0873e-38, 3.7350e-38, 3.3316e-38],\n", + " [2.9464e-09, 1.8378e-17, 1.4345e-17, 1.5095e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "445000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3592e-19, 3.6115e-38, 5.1777e-38, 4.3818e-38],\n", + " [3.6429e-09, 1.8304e-17, 1.6089e-17, 1.6337e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "446000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.4691e-20, 2.9992e-38, 3.5900e-38, 3.2236e-38],\n", + " [2.9590e-09, 1.8400e-17, 1.4195e-17, 1.5015e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "447000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6503e-20, 3.0966e-38, 3.8672e-38, 3.4305e-38],\n", + " [3.1370e-09, 1.8371e-17, 1.4580e-17, 1.5299e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "448000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[1.6556e-19, 3.6916e-38, 5.5943e-38, 4.6725e-38],\n", + " [3.9835e-09, 1.8230e-17, 1.6572e-17, 1.6692e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "449000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1580e-19, 3.1981e-38, 4.2150e-38, 3.6877e-38],\n", + " [3.4061e-09, 1.8350e-17, 1.5067e-17, 1.5671e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "450000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7634e-20, 2.9613e-38, 3.6428e-38, 3.2629e-38],\n", + " [3.1620e-09, 1.8389e-17, 1.4347e-17, 1.5168e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "451000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1558e-20, 2.4811e-38, 2.5597e-38, 2.4291e-38],\n", + " [2.5812e-09, 1.8524e-17, 1.2721e-17, 1.3998e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "452000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.1574e-20, 2.7996e-38, 3.3201e-38, 3.0190e-38],\n", + " [3.0794e-09, 1.8414e-17, 1.3936e-17, 1.4896e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "453000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.6942e-20, 2.4846e-38, 2.6165e-38, 2.4737e-38],\n", + " [2.6831e-09, 1.8510e-17, 1.2855e-17, 1.4115e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "454000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6544e-20, 2.5748e-38, 2.8351e-38, 2.6456e-38],\n", + " [2.8485e-09, 1.8477e-17, 1.3227e-17, 1.4397e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "455000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.8156e-20, 2.6651e-38, 3.0717e-38, 2.8291e-38],\n", + " [3.0344e-09, 1.8449e-17, 1.3616e-17, 1.4693e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "456000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0605e-19, 2.7959e-38, 3.4264e-38, 3.0999e-38],\n", + " [3.2953e-09, 1.8401e-17, 1.4156e-17, 1.5095e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "457000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1674e-20, 2.2964e-38, 2.2883e-38, 2.2148e-38],\n", + " [2.5962e-09, 1.8663e-17, 1.2359e-17, 1.3809e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "458000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.1965e-20, 2.3760e-38, 2.4935e-38, 2.3778e-38],\n", + " [2.7825e-09, 1.8581e-17, 1.2747e-17, 1.4099e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "459000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8154e-20, 2.2954e-38, 2.3446e-38, 2.2589e-38],\n", + " [2.7188e-09, 1.8617e-17, 1.2500e-17, 1.3929e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "460000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3956e-20, 2.3259e-38, 2.4348e-38, 2.3311e-38],\n", + " [2.8210e-09, 1.8591e-17, 1.2680e-17, 1.4072e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "461000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.6049e-20, 2.5104e-38, 2.8755e-38, 2.6790e-38],\n", + " [3.1688e-09, 1.8520e-17, 1.3441e-17, 1.4646e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "462000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4858e-20, 2.1779e-38, 2.1460e-38, 2.1000e-38],\n", + " [2.6661e-09, 1.8729e-17, 1.2186e-17, 1.3737e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "463000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.4641e-20, 2.1458e-38, 2.0991e-38, 2.0617e-38],\n", + " [2.6643e-09, 1.8748e-17, 1.2111e-17, 1.3692e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "464000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.5715e-20, 2.2277e-38, 2.3008e-38, 2.2246e-38],\n", + " [2.8597e-09, 1.8656e-17, 1.2511e-17, 1.3994e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "465000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.2306e-20, 1.9630e-38, 1.7481e-38, 1.7744e-38],\n", + " [2.4294e-09, 1.9008e-17, 1.1424e-17, 1.3224e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "466000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.1338e-20, 2.1230e-38, 2.1160e-38, 2.0755e-38],\n", + " [2.7906e-09, 1.8746e-17, 1.2202e-17, 1.3793e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "467000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2251e-20, 2.1085e-38, 2.1008e-38, 2.0635e-38],\n", + " [2.8084e-09, 1.8765e-17, 1.2191e-17, 1.3797e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "468000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.4275e-20, 2.0108e-38, 1.9060e-38, 1.9043e-38],\n", + " [2.6685e-09, 1.8885e-17, 1.1814e-17, 1.3533e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "469000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2569e-20, 1.7448e-38, 1.3995e-38, 1.4776e-38],\n", + " [2.2248e-09, 1.9299e-17, 1.0664e-17, 1.2705e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "470000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5054e-20, 1.9621e-38, 1.8459e-38, 1.8543e-38],\n", + " [2.6870e-09, 1.8905e-17, 1.1718e-17, 1.3481e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "471000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.0021e-20, 2.1430e-38, 2.2637e-38, 2.1958e-38],\n", + " [3.1047e-09, 1.8699e-17, 1.2571e-17, 1.4120e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "472000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6715e-20, 1.8316e-38, 1.6141e-38, 1.6605e-38],\n", + " [2.5323e-09, 1.9079e-17, 1.1232e-17, 1.3148e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "473000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6400e-20, 1.8054e-38, 1.5774e-38, 1.6297e-38],\n", + " [2.5283e-09, 1.9124e-17, 1.1167e-17, 1.3114e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "474000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0362e-20, 1.8224e-38, 1.6265e-38, 1.6711e-38],\n", + " [2.6075e-09, 1.9083e-17, 1.1298e-17, 1.3219e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "475000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.3762e-20, 1.9911e-38, 2.0059e-38, 1.9857e-38],\n", + " [3.0163e-09, 1.8787e-17, 1.2128e-17, 1.3827e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "476000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.3746e-20, 1.8104e-38, 1.6338e-38, 1.6767e-38],\n", + " [2.6750e-09, 1.9060e-17, 1.1342e-17, 1.3264e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "477000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.7673e-20, 2.0442e-38, 2.1580e-38, 2.1100e-38],\n", + " [3.2322e-09, 1.8724e-17, 1.2456e-17, 1.4089e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "478000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7732e-20, 1.7191e-38, 1.4771e-38, 1.5437e-38],\n", + " [2.5637e-09, 1.9215e-17, 1.0996e-17, 1.3030e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "479000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0942e-20, 1.6411e-38, 1.3361e-38, 1.4224e-38],\n", + " [2.4272e-09, 1.9398e-17, 1.0655e-17, 1.2795e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "480000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4715e-20, 1.6525e-38, 1.3743e-38, 1.4555e-38],\n", + " [2.5074e-09, 1.9345e-17, 1.0771e-17, 1.2890e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "481000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.3111e-20, 1.6225e-38, 1.3275e-38, 1.4149e-38],\n", + " [2.4761e-09, 1.9409e-17, 1.0662e-17, 1.2820e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "482000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6041e-20, 1.6266e-38, 1.3511e-38, 1.4350e-38],\n", + " [2.5378e-09, 1.9366e-17, 1.0738e-17, 1.2882e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "483000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9229e-20, 1.7110e-38, 1.5350e-38, 1.5927e-38],\n", + " [2.7886e-09, 1.9148e-17, 1.1213e-17, 1.3235e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "484000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8334e-20, 1.5260e-38, 1.1851e-38, 1.2891e-38],\n", + " [2.3797e-09, 1.9582e-17, 1.0307e-17, 1.2579e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "485000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7499e-20, 1.5878e-38, 1.3124e-38, 1.4011e-38],\n", + " [2.5719e-09, 1.9412e-17, 1.0675e-17, 1.2861e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "486000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.6157e-20, 1.5132e-38, 1.1457e-38, 1.2601e-38],\n", + " [2.3497e-09, 2.0173e-17, 1.0435e-17, 1.2825e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "487000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3284e-20, 1.7169e-38, 1.5469e-38, 1.6120e-38],\n", + " [2.8876e-09, 1.9723e-17, 1.1564e-17, 1.3685e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "488000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5848e-20, 1.6440e-38, 1.4141e-38, 1.4973e-38],\n", + " [2.7561e-09, 1.9863e-17, 1.1242e-17, 1.3456e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "489000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0230e-20, 1.6780e-38, 1.4737e-38, 1.5526e-38],\n", + " [2.8458e-09, 2.0044e-17, 1.1520e-17, 1.3735e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "490000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.1454e-20, 1.5920e-38, 1.3199e-38, 1.4183e-38],\n", + " [2.6844e-09, 2.0216e-17, 1.1121e-17, 1.3449e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "491000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.7182e-20, 1.8133e-38, 1.7856e-38, 1.8193e-38],\n", + " [3.2899e-09, 1.9782e-17, 1.2310e-17, 1.4347e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "492000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9765e-20, 1.6203e-38, 1.3973e-38, 1.4864e-38],\n", + " [2.8434e-09, 2.0142e-17, 1.1366e-17, 1.3654e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "493000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7051e-20, 1.5984e-38, 1.3523e-38, 1.4494e-38],\n", + " [2.8030e-09, 2.0394e-17, 1.1352e-17, 1.3705e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "494000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6668e-20, 1.6742e-38, 1.4858e-38, 1.5711e-38],\n", + " [2.9876e-09, 2.0589e-17, 1.1875e-17, 1.4195e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "495000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4379e-20, 1.4108e-38, 1.0087e-38, 1.1440e-38],\n", + " [2.3490e-09, 2.1303e-17, 1.0491e-17, 1.3175e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "496000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5369e-20, 1.5724e-38, 1.3004e-38, 1.4101e-38],\n", + " [2.7947e-09, 2.0987e-17, 1.1482e-17, 1.3968e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "497000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8584e-20, 1.4408e-38, 1.0580e-38, 1.1931e-38],\n", + " [2.4572e-09, 2.1556e-17, 1.0816e-17, 1.3524e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "498000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.0408e-20, 1.6540e-38, 1.4666e-38, 1.5603e-38],\n", + " [3.0749e-09, 2.1036e-17, 1.2081e-17, 1.4504e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "499000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4137e-20, 1.4490e-38, 1.0971e-38, 1.2287e-38],\n", + " [2.5818e-09, 2.1471e-17, 1.0976e-17, 1.3663e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "500000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.8285e-20, 1.4670e-38, 1.1377e-38, 1.2660e-38],\n", + " [2.6695e-09, 2.1419e-17, 1.1126e-17, 1.3790e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "501000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3469e-20, 1.4136e-38, 1.0550e-38, 1.1899e-38],\n", + " [2.5708e-09, 2.1536e-17, 1.0860e-17, 1.3592e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "502000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8226e-20, 1.5176e-38, 1.2397e-38, 1.3606e-38],\n", + " [2.8738e-09, 2.1490e-17, 1.1572e-17, 1.4204e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "503000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.2682e-20, 1.5580e-38, 1.2993e-38, 1.4194e-38],\n", + " [2.9711e-09, 2.1835e-17, 1.1950e-17, 1.4612e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "504000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3373e-20, 1.5594e-38, 1.3006e-38, 1.4225e-38],\n", + " [2.9909e-09, 2.2002e-17, 1.2040e-17, 1.4731e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "505000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.1594e-20, 1.5681e-38, 1.2922e-38, 1.4213e-38],\n", + " [2.9781e-09, 2.2562e-17, 1.2266e-17, 1.5054e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "506000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.3863e-20, 1.5627e-38, 1.2954e-38, 1.4243e-38],\n", + " [3.0220e-09, 2.2569e-17, 1.2297e-17, 1.5094e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "507000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5260e-20, 1.3292e-38, 9.0677e-39, 1.0620e-38],\n", + " [2.4326e-09, 2.3122e-17, 1.0917e-17, 1.4012e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "508000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6953e-20, 1.5606e-38, 1.3014e-38, 1.4327e-38],\n", + " [3.0912e-09, 2.2826e-17, 1.2471e-17, 1.5320e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "509000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.4250e-20, 1.6392e-38, 1.4677e-38, 1.5829e-38],\n", + " [3.3849e-09, 2.2674e-17, 1.3010e-17, 1.5761e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "510000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0327e-20, 1.4056e-38, 1.0553e-38, 1.2045e-38],\n", + " [2.7781e-09, 2.3082e-17, 1.1642e-17, 1.4676e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "511000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.5463e-20, 1.3731e-38, 9.9471e-39, 1.1498e-38],\n", + " [2.6852e-09, 2.3454e-17, 1.1532e-17, 1.4663e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "512000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.8046e-20, 1.5393e-38, 1.2684e-38, 1.4101e-38],\n", + " [3.1431e-09, 2.3564e-17, 1.2741e-17, 1.5750e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "513000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0059e-20, 1.5333e-38, 1.2691e-38, 1.4109e-38],\n", + " [3.1811e-09, 2.3574e-17, 1.2763e-17, 1.5782e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "514000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[7.6201e-20, 1.4952e-38, 1.2097e-38, 1.3559e-38],\n", + " [3.1137e-09, 2.3633e-17, 1.2569e-17, 1.5635e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "515000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1515e-20, 1.3805e-38, 1.0233e-38, 1.1806e-38],\n", + " [2.8327e-09, 2.3854e-17, 1.1888e-17, 1.5093e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "516000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6649e-20, 1.3557e-38, 9.6966e-39, 1.1336e-38],\n", + " [2.7458e-09, 2.4422e-17, 1.1873e-17, 1.5205e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "517000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.8502e-20, 1.4124e-38, 1.0805e-38, 1.2387e-38],\n", + " [2.9902e-09, 2.4211e-17, 1.2331e-17, 1.5581e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "518000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8773e-20, 1.4030e-38, 1.0697e-38, 1.2295e-38],\n", + " [3.0013e-09, 2.4344e-17, 1.2357e-17, 1.5642e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "519000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8375e-20, 1.3164e-38, 9.3735e-39, 1.1023e-38],\n", + " [2.7915e-09, 2.4519e-17, 1.1823e-17, 1.5213e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "520000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.4362e-20, 1.9613e-38, 1.4929e-38, 1.7209e-38],\n", + " [3.4419e-09, 3.2442e-17, 1.6331e-17, 2.0753e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "521000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1357e-20, 1.5447e-38, 1.0729e-38, 1.2753e-38],\n", + " [2.9109e-09, 2.8055e-17, 1.3312e-17, 1.7242e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "522000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1429e-19, 2.3343e-38, 1.9398e-38, 2.1836e-38],\n", + " [4.0389e-09, 3.6341e-17, 1.9393e-17, 2.4263e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "523000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0110e-20, 1.6348e-38, 1.1839e-38, 1.3949e-38],\n", + " [3.1340e-09, 2.9353e-17, 1.4376e-17, 1.8483e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "524000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1155e-20, 1.4360e-38, 9.9852e-39, 1.1941e-38],\n", + " [2.9087e-09, 2.7093e-17, 1.2907e-17, 1.6753e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "525000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2171e-20, 1.4116e-38, 9.8627e-39, 1.1800e-38],\n", + " [2.9305e-09, 2.6844e-17, 1.2828e-17, 1.6652e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "526000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4634e-20, 1.4013e-38, 9.8940e-39, 1.1819e-38],\n", + " [2.9823e-09, 2.6701e-17, 1.2830e-17, 1.6640e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "527000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.5331e-20, 1.3707e-38, 9.7019e-39, 1.1600e-38],\n", + " [2.9915e-09, 2.6320e-17, 1.2653e-17, 1.6420e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "528000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.6823e-20, 1.6371e-38, 1.2570e-38, 1.4670e-38],\n", + " [3.4707e-09, 2.9405e-17, 1.4902e-17, 1.9045e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "529000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.4874e-20, 1.1655e-38, 7.8382e-39, 9.5533e-39],\n", + " [2.7235e-09, 2.3857e-17, 1.1087e-17, 1.4562e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "530000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.4594e-20, 1.1527e-38, 7.7521e-39, 9.4641e-39],\n", + " [2.7217e-09, 2.3799e-17, 1.1082e-17, 1.4560e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "531000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.2859e-20, 1.0951e-38, 7.2901e-39, 8.9428e-39],\n", + " [2.6695e-09, 2.3049e-17, 1.0650e-17, 1.4036e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "532000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1193e-19, 1.7770e-38, 1.4649e-38, 1.6820e-38],\n", + " [3.9441e-09, 3.1018e-17, 1.6432e-17, 2.0784e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "533000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0822e-20, 1.1624e-38, 8.0731e-39, 9.8071e-39],\n", + " [2.8797e-09, 2.4093e-17, 1.1481e-17, 1.5018e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "534000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4115e-20, 9.0448e-39, 5.7180e-39, 7.1705e-39],\n", + " [2.4273e-09, 2.0654e-17, 9.2471e-18, 1.2343e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "535000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1320e-20, 9.9320e-39, 6.5673e-39, 8.1304e-39],\n", + " [2.6314e-09, 2.1949e-17, 1.0135e-17, 1.3410e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "536000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6477e-20, 1.2620e-38, 9.3530e-39, 1.1185e-38],\n", + " [3.2340e-09, 2.5399e-17, 1.2612e-17, 1.6330e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "537000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.5613e-20, 9.8859e-39, 6.6808e-39, 8.2392e-39],\n", + " [2.7310e-09, 2.1851e-17, 1.0212e-17, 1.3481e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "538000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4965e-20, 1.1021e-38, 7.8110e-39, 9.5039e-39],\n", + " [2.9770e-09, 2.3535e-17, 1.1390e-17, 1.4890e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "539000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.0194e-20, 1.0176e-38, 7.0486e-39, 8.6521e-39],\n", + " [2.8538e-09, 2.2398e-17, 1.0669e-17, 1.4026e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "540000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8022e-20, 8.5363e-39, 5.5351e-39, 6.9484e-39],\n", + " [2.5303e-09, 2.0104e-17, 9.1649e-18, 1.2222e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "541000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9835e-20, 9.5671e-39, 6.6058e-39, 8.1421e-39],\n", + " [2.8310e-09, 2.1534e-17, 1.0214e-17, 1.3465e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "542000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6352e-20, 1.1161e-38, 8.2656e-39, 9.9768e-39],\n", + " [3.2182e-09, 2.3733e-17, 1.1787e-17, 1.5332e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "543000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.8566e-20, 1.1270e-38, 8.4215e-39, 1.0152e-38],\n", + " [3.2723e-09, 2.3976e-17, 1.1999e-17, 1.5585e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "544000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0303e-20, 7.0605e-39, 4.3524e-39, 5.5833e-39],\n", + " [2.3043e-09, 1.7996e-17, 7.9459e-18, 1.0733e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "545000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.3314e-20, 7.1784e-39, 4.5140e-39, 5.7633e-39],\n", + " [2.3866e-09, 1.8165e-17, 8.1152e-18, 1.0930e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "546000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7205e-20, 8.3930e-39, 5.7154e-39, 7.1247e-39],\n", + " [2.7537e-09, 1.9970e-17, 9.3861e-18, 1.2452e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "547000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6468e-20, 8.4168e-39, 5.7253e-39, 7.1489e-39],\n", + " [2.7497e-09, 2.0159e-17, 9.5080e-18, 1.2611e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "548000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8882e-20, 7.4286e-39, 4.8423e-39, 6.1386e-39],\n", + " [2.5437e-09, 1.8663e-17, 8.5529e-18, 1.1455e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "549000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6716e-20, 8.1504e-39, 5.5517e-39, 6.9487e-39],\n", + " [2.7537e-09, 1.9821e-17, 9.3622e-18, 1.2430e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "550000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0907e-20, 9.1767e-39, 6.6569e-39, 8.1819e-39],\n", + " [3.0864e-09, 2.1301e-17, 1.0465e-17, 1.3740e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "551000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9989e-20, 8.9467e-39, 6.4705e-39, 7.9752e-39],\n", + " [3.0675e-09, 2.1039e-17, 1.0328e-17, 1.3577e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "552000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9149e-20, 5.9619e-39, 3.6458e-39, 4.7444e-39],\n", + " [2.2606e-09, 1.6404e-17, 7.2184e-18, 9.8195e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "553000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1471e-19, 1.1940e-38, 9.9234e-39, 1.1743e-38],\n", + " [3.9574e-09, 2.5133e-17, 1.3468e-17, 1.7266e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "554000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4887e-20, 5.2174e-39, 3.0825e-39, 4.0689e-39],\n", + " [2.1315e-09, 1.5238e-17, 6.5762e-18, 9.0167e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "555000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8405e-20, 5.4667e-39, 3.3210e-39, 4.3511e-39],\n", + " [2.2284e-09, 1.5574e-17, 6.8160e-18, 9.3095e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "556000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5462e-20, 5.9676e-39, 3.8042e-39, 4.9152e-39],\n", + " [2.4304e-09, 1.6438e-17, 7.4202e-18, 1.0045e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "557000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2865e-20, 7.1855e-39, 5.0252e-39, 6.3141e-39],\n", + " [2.8719e-09, 1.8401e-17, 8.8109e-18, 1.1720e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "558000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5917e-20, 6.5661e-39, 4.4420e-39, 5.6476e-39],\n", + " [2.7027e-09, 1.7452e-17, 8.1863e-18, 1.0966e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "559000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2192e-20, 6.2535e-39, 4.1519e-39, 5.3173e-39],\n", + " [2.6132e-09, 1.7015e-17, 7.9016e-18, 1.0626e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "560000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.1721e-20, 6.8306e-39, 4.7562e-39, 6.0067e-39],\n", + " [2.8471e-09, 1.7949e-17, 8.5894e-18, 1.1450e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "561000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.5814e-20, 8.4278e-39, 6.4472e-39, 7.9200e-39],\n", + " [3.3873e-09, 2.0518e-17, 1.0447e-17, 1.3682e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "562000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6515e-20, 5.5296e-39, 3.5536e-39, 4.6182e-39],\n", + " [2.4613e-09, 1.5876e-17, 7.2320e-18, 9.8058e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "563000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9335e-20, 4.8941e-39, 2.9976e-39, 3.9602e-39],\n", + " [2.2545e-09, 1.4751e-17, 6.5145e-18, 8.9238e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "564000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.0126e-20, 6.2901e-39, 4.3501e-39, 5.5370e-39],\n", + " [2.8073e-09, 1.7185e-17, 8.2034e-18, 1.0976e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "565000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0682e-20, 5.5688e-39, 3.6680e-39, 4.7471e-39],\n", + " [2.5703e-09, 1.5994e-17, 7.4062e-18, 1.0010e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "566000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7466e-20, 5.8841e-39, 4.0160e-39, 5.1466e-39],\n", + " [2.7382e-09, 1.6528e-17, 7.8241e-18, 1.0510e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "567000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[6.9286e-20, 6.5337e-39, 4.6984e-39, 5.9298e-39],\n", + " [3.0138e-09, 1.7622e-17, 8.6189e-18, 1.1470e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "568000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.3999e-20, 5.3822e-39, 3.6025e-39, 4.6570e-39],\n", + " [2.6401e-09, 1.5633e-17, 7.2943e-18, 9.8535e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "569000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.7363e-20, 6.8103e-39, 5.0539e-39, 6.3346e-39],\n", + " [3.1922e-09, 1.8151e-17, 9.0683e-18, 1.2009e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "570000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3104e-20, 5.1923e-39, 3.4613e-39, 4.4921e-39],\n", + " [2.6185e-09, 1.5353e-17, 7.1547e-18, 9.6825e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "571000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6589e-20, 4.7295e-39, 3.0378e-39, 3.9940e-39],\n", + " [2.4478e-09, 1.4538e-17, 6.6204e-18, 9.0297e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "572000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1379e-20, 4.3170e-39, 2.6798e-39, 3.5659e-39],\n", + " [2.3006e-09, 1.3770e-17, 6.1359e-18, 8.4307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "573000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5470e-20, 4.4895e-39, 2.8619e-39, 3.7808e-39],\n", + " [2.4121e-09, 1.4094e-17, 6.3840e-18, 8.7320e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "574000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2401e-20, 5.4285e-39, 3.7885e-39, 4.8699e-39],\n", + " [2.8442e-09, 1.5856e-17, 7.6171e-18, 1.0239e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "575000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6676e-20, 6.1002e-39, 4.5094e-39, 5.7000e-39],\n", + " [3.1611e-09, 1.7029e-17, 8.4798e-18, 1.1282e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "576000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.2900e-20, 4.7056e-39, 3.1327e-39, 4.0974e-39],\n", + " [2.6054e-09, 1.4546e-17, 6.7780e-18, 9.2075e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "577000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1670e-20, 4.6025e-39, 3.0461e-39, 3.9971e-39],\n", + " [2.5782e-09, 1.4405e-17, 6.6990e-18, 9.1128e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "578000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1490e-20, 5.0420e-39, 3.5042e-39, 4.5335e-39],\n", + " [2.8176e-09, 1.5226e-17, 7.3005e-18, 9.8446e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "579000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3179e-20, 4.4764e-39, 2.9830e-39, 3.9152e-39],\n", + " [2.6072e-09, 1.4146e-17, 6.5963e-18, 8.9756e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "580000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.7363e-20, 4.0340e-39, 2.5978e-39, 3.4522e-39],\n", + " [2.4484e-09, 1.3263e-17, 6.0423e-18, 8.2877e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "581000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9277e-20, 5.1038e-39, 3.6621e-39, 4.7098e-39],\n", + " [2.9848e-09, 1.5348e-17, 7.4986e-18, 1.0075e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "582000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6064e-20, 3.9342e-39, 2.5183e-39, 3.3607e-39],\n", + " [2.4220e-09, 1.3156e-17, 5.9901e-18, 8.2282e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "583000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2272e-20, 4.2448e-39, 2.8200e-39, 3.7234e-39],\n", + " [2.5905e-09, 1.3822e-17, 6.4562e-18, 8.8045e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "584000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.7049e-20, 5.9052e-39, 4.5345e-39, 5.7302e-39],\n", + " [3.3870e-09, 1.7020e-17, 8.7414e-18, 1.1594e-17],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "585000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6289e-20, 4.3138e-39, 2.9273e-39, 3.8494e-39],\n", + " [2.6931e-09, 1.4019e-17, 6.6475e-18, 9.0362e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "586000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2592e-20, 4.0313e-39, 2.6809e-39, 3.5522e-39],\n", + " [2.5944e-09, 1.3441e-17, 6.2861e-18, 8.5862e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "587000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3521e-20, 3.9753e-39, 2.6550e-39, 3.5178e-39],\n", + " [2.6126e-09, 1.3318e-17, 6.2397e-18, 8.5233e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "588000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.0524e-20, 4.6468e-39, 3.3515e-39, 4.3414e-39],\n", + " [3.0100e-09, 1.4653e-17, 7.2039e-18, 9.7054e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "589000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6717e-20, 3.4761e-39, 2.2294e-39, 2.9994e-39],\n", + " [2.4245e-09, 1.2255e-17, 5.5827e-18, 7.7013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "590000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7014e-20, 2.9191e-39, 1.7495e-39, 2.4081e-39],\n", + " [2.1430e-09, 1.1008e-17, 4.7948e-18, 6.7111e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "591000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0569e-20, 3.9541e-39, 2.7295e-39, 3.5985e-39],\n", + " [2.7719e-09, 1.3293e-17, 6.3502e-18, 8.6463e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "592000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0098e-20, 3.8791e-39, 2.6719e-39, 3.5292e-39],\n", + " [2.7608e-09, 1.3161e-17, 6.2822e-18, 8.5614e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "593000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8359e-20, 3.3083e-39, 2.1412e-39, 2.8869e-39],\n", + " [2.4615e-09, 1.1930e-17, 5.4676e-18, 7.5477e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "594000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6613e-20, 2.7561e-39, 1.6473e-39, 2.2794e-39],\n", + " [2.1359e-09, 1.0719e-17, 4.6731e-18, 6.5528e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "595000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2453e-20, 3.4324e-39, 2.2771e-39, 3.0534e-39],\n", + " [2.5734e-09, 1.2269e-17, 5.7270e-18, 7.8712e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "596000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8406e-20, 3.6009e-39, 2.4606e-39, 3.2732e-39],\n", + " [2.7165e-09, 1.2629e-17, 6.0024e-18, 8.2102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "597000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9894e-20, 2.7548e-39, 1.6859e-39, 2.3235e-39],\n", + " [2.2268e-09, 1.0726e-17, 4.7441e-18, 6.6337e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "598000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6495e-20, 3.4156e-39, 2.3120e-39, 3.0919e-39],\n", + " [2.6676e-09, 1.2253e-17, 5.7904e-18, 7.9431e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "599000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2467e-20, 3.5697e-39, 2.4840e-39, 3.2974e-39],\n", + " [2.8057e-09, 1.2584e-17, 6.0475e-18, 8.2589e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "600000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.1890e-20, 3.8793e-39, 2.8108e-39, 3.6903e-39],\n", + " [3.0225e-09, 1.3291e-17, 6.5633e-18, 8.8981e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "601000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1564e-20, 3.0654e-39, 2.0226e-39, 2.7375e-39],\n", + " [2.5416e-09, 1.1515e-17, 5.3586e-18, 7.4007e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "602000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0001e-20, 3.3621e-39, 2.3165e-39, 3.0969e-39],\n", + " [2.7534e-09, 1.2225e-17, 5.8557e-18, 8.0222e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "603000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5726e-20, 2.7753e-39, 1.7644e-39, 2.4153e-39],\n", + " [2.4035e-09, 1.0918e-17, 4.9654e-18, 6.8964e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "604000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0078e-20, 2.5360e-39, 1.5403e-39, 2.1259e-39],\n", + " [2.2865e-09, 1.0474e-17, 4.6293e-18, 6.4432e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "605000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8394e-20, 2.8141e-39, 1.8196e-39, 2.4832e-39],\n", + " [2.4756e-09, 1.1043e-17, 5.0829e-18, 7.0425e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "606000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1849e-20, 2.8508e-39, 1.8817e-39, 2.5591e-39],\n", + " [2.5492e-09, 1.1088e-17, 5.1649e-18, 7.1457e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "607000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8763e-20, 2.4050e-39, 1.4391e-39, 1.9915e-39],\n", + " [2.2860e-09, 1.0318e-17, 4.5307e-18, 6.2940e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "608000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6277e-20, 2.6030e-39, 1.6494e-39, 2.2597e-39],\n", + " [2.4539e-09, 1.0675e-17, 4.8528e-18, 6.7198e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "609000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1346e-20, 2.3849e-39, 1.4520e-39, 2.0039e-39],\n", + " [2.3529e-09, 1.0247e-17, 4.5416e-18, 6.3000e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "610000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1277e-20, 2.3837e-39, 1.4501e-39, 2.0008e-39],\n", + " [2.3688e-09, 1.0328e-17, 4.5874e-18, 6.3527e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "611000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2698e-20, 2.9915e-39, 2.0855e-39, 2.8081e-39],\n", + " [2.8017e-09, 1.1468e-17, 5.5341e-18, 7.6062e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "612000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5087e-20, 2.4034e-39, 1.5000e-39, 2.0609e-39],\n", + " [2.4614e-09, 1.0338e-17, 4.6589e-18, 6.4391e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "613000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5142e-20, 2.6780e-39, 1.7867e-39, 2.4257e-39],\n", + " [2.6752e-09, 1.0896e-17, 5.1225e-18, 7.0481e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "614000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.6664e-20, 2.3822e-39, 1.4998e-39, 2.0577e-39],\n", + " [2.5101e-09, 1.0320e-17, 4.6785e-18, 6.4554e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "615000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5275e-20, 2.3215e-39, 1.4456e-39, 1.9870e-39],\n", + " [2.4929e-09, 1.0242e-17, 4.6171e-18, 6.3675e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "616000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.3412e-20, 2.5014e-39, 1.6434e-39, 2.2377e-39],\n", + " [2.6653e-09, 1.0581e-17, 4.9268e-18, 6.7728e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "617000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5599e-20, 2.5000e-39, 1.6612e-39, 2.2576e-39],\n", + " [2.7133e-09, 1.0562e-17, 4.9488e-18, 6.7966e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "618000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.2999e-20, 2.6649e-39, 1.8434e-39, 2.4878e-39],\n", + " [2.8654e-09, 1.0928e-17, 5.2533e-18, 7.1937e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "619000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5038e-20, 2.4146e-39, 1.5944e-39, 2.1694e-39],\n", + " [2.7226e-09, 1.0432e-17, 4.8725e-18, 6.6840e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "620000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9845e-20, 2.2739e-39, 1.4517e-39, 1.9867e-39],\n", + " [2.6369e-09, 1.0227e-17, 4.6893e-18, 6.4340e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "621000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.6485e-20, 2.3878e-39, 1.5865e-39, 2.1562e-39],\n", + " [2.7755e-09, 1.0440e-17, 4.9027e-18, 6.7101e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "622000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[4.4591e-20, 2.0388e-39, 1.2488e-39, 1.7224e-39],\n", + " [2.5335e-09, 9.7053e-18, 4.3320e-18, 5.9534e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "623000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1745e-20, 1.9415e-39, 1.1620e-39, 1.6091e-39],\n", + " [2.4796e-09, 9.5223e-18, 4.1943e-18, 5.7656e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "624000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0154e-20, 2.1425e-39, 1.3626e-39, 1.8663e-39],\n", + " [2.6812e-09, 1.0011e-17, 4.5851e-18, 6.2738e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "625000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.2121e-20, 2.1495e-39, 1.3826e-39, 1.8901e-39],\n", + " [2.7266e-09, 1.0014e-17, 4.6156e-18, 6.3099e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "626000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7818e-20, 2.2325e-39, 1.4842e-39, 2.0173e-39],\n", + " [2.8458e-09, 1.0173e-17, 4.7819e-18, 6.5234e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "627000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4369e-20, 1.8988e-39, 1.1538e-39, 1.5936e-39],\n", + " [2.5778e-09, 9.4971e-18, 4.2304e-18, 5.7925e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "628000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9008e-20, 2.2341e-39, 1.4938e-39, 2.0277e-39],\n", + " [2.9009e-09, 1.0284e-17, 4.8675e-18, 6.6218e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "629000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.1865e-20, 2.2921e-39, 1.5569e-39, 2.1070e-39],\n", + " [2.9742e-09, 1.0476e-17, 5.0178e-18, 6.8104e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "630000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1999e-20, 2.0200e-39, 1.2913e-39, 1.7671e-39],\n", + " [2.7822e-09, 9.8735e-18, 4.5527e-18, 6.1979e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "631000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9429e-20, 2.1213e-39, 1.4150e-39, 1.9220e-39],\n", + " [2.9407e-09, 1.0079e-17, 4.7659e-18, 6.4699e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "632000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6551e-20, 2.4053e-39, 1.7418e-39, 2.3328e-39],\n", + " [3.2569e-09, 1.0666e-17, 5.2976e-18, 7.1615e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "633000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4020e-20, 1.9276e-39, 1.2409e-39, 1.6967e-39],\n", + " [2.8505e-09, 9.6595e-18, 4.4686e-18, 6.0704e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "634000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1218e-20, 1.8236e-39, 1.1507e-39, 1.5793e-39],\n", + " [2.7968e-09, 9.4039e-18, 4.2938e-18, 5.8374e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "635000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0685e-20, 2.0339e-39, 1.3601e-39, 1.8464e-39],\n", + " [3.0229e-09, 1.0016e-17, 4.7612e-18, 6.4358e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "636000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.2713e-20, 2.3849e-39, 1.7644e-39, 2.3538e-39],\n", + " [3.4249e-09, 1.0768e-17, 5.4375e-18, 7.3119e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "637000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[9.6149e-20, 2.5994e-39, 2.0197e-39, 2.6719e-39],\n", + " [3.6571e-09, 1.1280e-17, 5.8779e-18, 7.8781e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "638000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5956e-20, 1.6171e-39, 9.7952e-40, 1.3541e-39],\n", + " [2.7353e-09, 9.0359e-18, 4.0424e-18, 5.4833e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "639000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0046e-19, 2.5559e-39, 2.0085e-39, 2.6526e-39],\n", + " [3.7460e-09, 1.1205e-17, 5.8775e-18, 7.8636e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "640000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.1901e-20, 1.6763e-39, 1.0550e-39, 1.4485e-39],\n", + " [2.8958e-09, 9.2270e-18, 4.2306e-18, 5.7158e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "641000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1876e-20, 1.4330e-39, 8.3703e-40, 1.1651e-39],\n", + " [2.6654e-09, 8.5708e-18, 3.7501e-18, 5.0860e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "642000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1563e-20, 1.5928e-39, 9.9652e-40, 1.3702e-39],\n", + " [2.9068e-09, 9.0142e-18, 4.1162e-18, 5.5562e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "643000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4551e-20, 1.8365e-39, 1.2408e-39, 1.6817e-39],\n", + " [3.2168e-09, 9.7674e-18, 4.6997e-18, 6.2984e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "644000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0659e-20, 1.7265e-39, 1.1399e-39, 1.5517e-39],\n", + " [3.1441e-09, 9.4791e-18, 4.4937e-18, 6.0281e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "645000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7175e-20, 1.6255e-39, 1.0500e-39, 1.4353e-39],\n", + " [3.0764e-09, 9.2051e-18, 4.3020e-18, 5.7766e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "646000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8386e-20, 1.7695e-39, 1.2125e-39, 1.6402e-39],\n", + " [3.3095e-09, 9.5583e-18, 4.6283e-18, 6.1919e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "647000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[8.0259e-20, 1.8968e-39, 1.3697e-39, 1.8356e-39],\n", + " [3.5345e-09, 9.8521e-18, 4.9222e-18, 6.5631e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "648000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0527e-19, 2.2397e-39, 1.7692e-39, 2.3346e-39],\n", + " [3.9690e-09, 1.0752e-17, 5.6876e-18, 7.5413e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "649000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1070e-19, 2.2577e-39, 1.8103e-39, 2.3832e-39],\n", + " [4.0574e-09, 1.0781e-17, 5.7496e-18, 7.6161e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "650000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6409e-20, 1.7456e-39, 1.2351e-39, 1.6618e-39],\n", + " [3.5065e-09, 9.5363e-18, 4.7124e-18, 6.2754e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "651000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5975e-20, 1.5873e-39, 1.0680e-39, 1.4501e-39],\n", + " [3.3260e-09, 9.1775e-18, 4.4051e-18, 5.8757e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "652000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.5431e-20, 1.5400e-39, 1.0314e-39, 1.4018e-39],\n", + " [3.3215e-09, 9.0363e-18, 4.3213e-18, 5.7636e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "653000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5701e-20, 1.2263e-39, 7.2675e-40, 1.0101e-39],\n", + " [2.8963e-09, 8.1779e-18, 3.6335e-18, 4.8761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "654000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4503e-20, 1.4661e-39, 9.7442e-40, 1.3266e-39],\n", + " [3.3292e-09, 8.8626e-18, 4.2211e-18, 5.6237e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "655000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0570e-20, 1.3879e-39, 9.0198e-40, 1.2331e-39],\n", + " [3.2635e-09, 8.6715e-18, 4.0776e-18, 5.4342e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "656000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[8.2894e-20, 1.6327e-39, 1.1783e-39, 1.5807e-39],\n", + " [3.7067e-09, 9.3302e-18, 4.6747e-18, 6.1882e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "657000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1231e-20, 1.0563e-39, 6.0100e-40, 8.4227e-40],\n", + " [2.8181e-09, 7.6649e-18, 3.3255e-18, 4.4625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "658000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6916e-20, 1.1463e-39, 6.8166e-40, 9.4734e-40],\n", + " [2.9867e-09, 8.0179e-18, 3.5809e-18, 4.7849e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "659000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2808e-20, 1.0566e-39, 6.0803e-40, 8.5035e-40],\n", + " [2.8849e-09, 7.7093e-18, 3.3713e-18, 4.5127e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "660000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.6668e-20, 1.6149e-39, 1.1810e-39, 1.5802e-39],\n", + " [3.8565e-09, 9.4665e-18, 4.8123e-18, 6.3353e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "661000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4573e-20, 1.3152e-39, 8.6837e-40, 1.1842e-39],\n", + " [3.4356e-09, 8.5969e-18, 4.1006e-18, 5.4308e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "662000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7630e-20, 1.3168e-39, 8.8159e-40, 1.1996e-39],\n", + " [3.5056e-09, 8.5862e-18, 4.1269e-18, 5.4597e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "663000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0847e-20, 1.1078e-39, 6.7356e-40, 9.3271e-40],\n", + " [3.1535e-09, 8.0039e-18, 3.6387e-18, 4.8335e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "664000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0875e-20, 1.1049e-39, 6.7205e-40, 9.3041e-40],\n", + " [3.1796e-09, 8.0664e-18, 3.6800e-18, 4.8794e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "665000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.5446e-20, 1.1268e-39, 7.0414e-40, 9.7036e-40],\n", + " [3.2978e-09, 8.1223e-18, 3.7631e-18, 4.9800e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "666000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.8680e-20, 1.1406e-39, 7.2554e-40, 9.9685e-40],\n", + " [3.3782e-09, 8.1559e-18, 3.8173e-18, 5.0451e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "667000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0268e-20, 1.1289e-39, 7.2337e-40, 9.9283e-40],\n", + " [3.4204e-09, 8.1028e-18, 3.8061e-18, 5.0268e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "668000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.1583e-20, 9.9931e-40, 6.0635e-40, 8.4090e-40],\n", + " [3.2185e-09, 7.6435e-18, 3.4692e-18, 4.5965e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "669000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0592e-20, 1.0757e-39, 6.8820e-40, 9.4539e-40],\n", + " [3.4387e-09, 7.8962e-18, 3.6990e-18, 4.8839e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "670000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[8.0671e-20, 1.2764e-39, 9.0040e-40, 1.2147e-39],\n", + " [3.8831e-09, 8.6095e-18, 4.2927e-18, 5.6250e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "671000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.5545e-20, 9.0299e-40, 5.2486e-40, 7.3363e-40],\n", + " [3.1074e-09, 7.3911e-18, 3.2813e-18, 4.3452e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "672000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0029e-20, 1.0280e-39, 6.5442e-40, 8.9990e-40],\n", + " [3.4789e-09, 7.8269e-18, 3.6695e-18, 4.8305e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "673000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.2490e-20, 1.1723e-39, 7.7087e-40, 1.0258e-39],\n", + " [4.0236e-09, 8.7520e-18, 4.2098e-18, 5.3879e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "674000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6293e-20, 7.3171e-40, 3.8833e-40, 5.4882e-40],\n", + " [2.8499e-09, 6.7211e-18, 2.8337e-18, 3.7625e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "675000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4034e-20, 1.0233e-39, 6.4905e-40, 8.7568e-40],\n", + " [3.7683e-09, 8.0952e-18, 3.8050e-18, 4.9117e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "676000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9225e-20, 9.7101e-40, 6.0269e-40, 8.1910e-40],\n", + " [3.6311e-09, 7.8907e-18, 3.6674e-18, 4.7529e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "677000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0295e-20, 9.4170e-40, 5.8774e-40, 7.9916e-40],\n", + " [3.6526e-09, 7.7363e-18, 3.6018e-18, 4.6704e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "678000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4593e-20, 8.8207e-40, 5.3538e-40, 7.3462e-40],\n", + " [3.4822e-09, 7.4849e-18, 3.4326e-18, 4.4737e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "679000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4354e-20, 9.7059e-40, 6.2047e-40, 8.4002e-40],\n", + " [3.7998e-09, 7.9651e-18, 3.7846e-18, 4.8861e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "680000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.9411e-20, 9.9305e-40, 6.4970e-40, 8.7491e-40],\n", + " [3.9428e-09, 8.0668e-18, 3.8857e-18, 4.9999e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "681000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.0984e-20, 8.8513e-40, 5.5673e-40, 7.5935e-40],\n", + " [3.6790e-09, 7.5242e-18, 3.5293e-18, 4.5800e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "682000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.0137e-20, 7.7166e-40, 4.5598e-40, 6.3244e-40],\n", + " [3.3470e-09, 6.9890e-18, 3.1520e-18, 4.1305e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "683000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9557e-20, 7.4263e-40, 4.3630e-40, 6.0637e-40],\n", + " [3.3281e-09, 6.8414e-18, 3.0693e-18, 4.0264e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "684000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.8157e-20, 9.8433e-40, 6.6998e-40, 8.9717e-40],\n", + " [4.1860e-09, 8.0743e-18, 3.9919e-18, 5.1137e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "685000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.9240e-20, 7.2926e-40, 4.2789e-40, 5.9543e-40],\n", + " [3.3426e-09, 6.8472e-18, 3.0792e-18, 4.0360e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "686000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.4619e-20, 9.1364e-40, 6.1400e-40, 8.2752e-40],\n", + " [4.0801e-09, 7.7347e-18, 3.7911e-18, 4.8757e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "687000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[7.6706e-20, 9.0460e-40, 6.1308e-40, 8.2541e-40],\n", + " [4.1294e-09, 7.6813e-18, 3.7807e-18, 4.8598e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "688000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.7715e-20, 7.3740e-40, 4.5477e-40, 6.2717e-40],\n", + " [3.5944e-09, 6.8572e-18, 3.1716e-18, 4.1361e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "689000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.9652e-20, 5.8768e-40, 3.1899e-40, 4.5270e-40],\n", + " [3.0328e-09, 6.1321e-18, 2.6157e-18, 3.4632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "690000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.4676e-20, 7.6203e-40, 4.8814e-40, 6.6837e-40],\n", + " [3.8013e-09, 6.9993e-18, 3.3186e-18, 4.3072e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "691000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8297e-20, 6.2868e-40, 3.6401e-40, 5.0990e-40],\n", + " [3.3207e-09, 6.3328e-18, 2.8095e-18, 3.6929e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "692000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.3686e-20, 7.2621e-40, 4.6198e-40, 6.3424e-40],\n", + " [3.7814e-09, 6.8373e-18, 3.2249e-18, 4.1896e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "693000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2422e-20, 4.8195e-40, 2.4342e-40, 3.5177e-40],\n", + " [2.7811e-09, 5.5734e-18, 2.2709e-18, 3.0324e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "694000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.2226e-20, 6.9781e-40, 4.4032e-40, 6.0627e-40],\n", + " [3.7636e-09, 6.7511e-18, 3.1740e-18, 4.1248e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "695000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[7.3114e-20, 7.6193e-40, 5.0836e-40, 6.9176e-40],\n", + " [4.0703e-09, 7.1017e-18, 3.4677e-18, 4.4734e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "696000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3720e-20, 5.4960e-40, 3.0713e-40, 4.3484e-40],\n", + " [3.2085e-09, 5.9957e-18, 2.6074e-18, 3.4384e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "697000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.9178e-20, 5.7723e-40, 3.3561e-40, 4.7138e-40],\n", + " [3.3967e-09, 6.1686e-18, 2.7538e-18, 3.6132e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "698000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8120e-20, 6.8682e-40, 4.4623e-40, 6.1199e-40],\n", + " [3.9564e-09, 6.7603e-18, 3.2434e-18, 4.1978e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "699000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7746e-20, 6.6187e-40, 4.2833e-40, 5.8834e-40],\n", + " [3.9445e-09, 6.6217e-18, 3.1646e-18, 4.0991e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "700000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8264e-20, 5.3899e-40, 3.1073e-40, 4.3801e-40],\n", + " [3.3827e-09, 5.9844e-18, 2.6579e-18, 3.4904e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "701000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2296e-20, 4.1683e-40, 2.0941e-40, 3.0446e-40],\n", + " [2.8086e-09, 5.2374e-18, 2.1257e-18, 2.8398e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "702000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.5533e-20, 5.5465e-40, 3.3447e-40, 4.6743e-40],\n", + " [3.6072e-09, 6.0562e-18, 2.7618e-18, 3.6093e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "703000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.6943e-20, 5.4820e-40, 3.3296e-40, 4.6488e-40],\n", + " [3.6483e-09, 6.0115e-18, 2.7505e-18, 3.5925e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "704000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.4947e-20, 7.2712e-40, 5.2609e-40, 7.0719e-40],\n", + " [4.6286e-09, 6.9636e-18, 3.5682e-18, 4.5616e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "705000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[6.7954e-20, 5.9434e-40, 3.8365e-40, 5.2915e-40],\n", + " [3.9857e-09, 6.3234e-18, 3.0168e-18, 3.9080e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "706000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9320e-20, 4.3406e-40, 2.3284e-40, 3.3463e-40],\n", + " [3.1100e-09, 5.4206e-18, 2.3010e-18, 3.0466e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "707000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4527e-20, 5.1074e-40, 3.0572e-40, 4.2918e-40],\n", + " [3.6164e-09, 5.8846e-18, 2.6776e-18, 3.4994e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "708000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9156e-20, 5.2204e-40, 3.2089e-40, 4.4815e-40],\n", + " [3.7542e-09, 5.9428e-18, 2.7472e-18, 3.5799e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "709000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.8477e-20, 3.9953e-40, 2.1194e-40, 3.0589e-40],\n", + " [3.0766e-09, 5.1753e-18, 2.1733e-18, 2.8842e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "710000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6313e-20, 4.9276e-40, 2.9768e-40, 4.1778e-40],\n", + " [3.6855e-09, 5.8006e-18, 2.6545e-18, 3.4651e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "711000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7260e-20, 4.8715e-40, 2.9562e-40, 4.1470e-40],\n", + " [3.7130e-09, 5.7602e-18, 2.6411e-18, 3.4466e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "712000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8880e-20, 3.7932e-40, 2.0153e-40, 2.9130e-40],\n", + " [3.1036e-09, 5.0587e-18, 2.1257e-18, 2.8205e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "713000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8843e-20, 5.2434e-40, 3.3861e-40, 4.6912e-40],\n", + " [4.0595e-09, 6.0105e-18, 2.8708e-18, 3.7169e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "714000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.6321e-20, 4.5325e-40, 2.7291e-40, 3.8425e-40],\n", + " [3.6985e-09, 5.5686e-18, 2.5381e-18, 3.3157e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "715000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.4319e-20, 3.8586e-40, 2.1390e-40, 3.0686e-40],\n", + " [3.3097e-09, 5.1210e-18, 2.2103e-18, 2.9177e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "716000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3497e-20, 3.8015e-40, 2.0956e-40, 3.0114e-40],\n", + " [3.2941e-09, 5.1105e-18, 2.2019e-18, 2.9068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "717000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[5.0960e-20, 4.1248e-40, 2.4003e-40, 3.4105e-40],\n", + " [3.5571e-09, 5.3562e-18, 2.3937e-18, 3.1378e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "718000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4065e-20, 4.1549e-40, 2.4635e-40, 3.4883e-40],\n", + " [3.6546e-09, 5.3685e-18, 2.4250e-18, 3.1726e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "719000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.4190e-20, 4.0439e-40, 2.3961e-40, 3.3957e-40],\n", + " [3.6571e-09, 5.2863e-18, 2.3834e-18, 3.1196e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "720000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.7857e-20, 4.5021e-40, 2.8776e-40, 4.0134e-40],\n", + " [4.0612e-09, 5.5876e-18, 2.6441e-18, 3.4294e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "721000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.8640e-20, 3.6449e-40, 2.0786e-40, 2.9745e-40],\n", + " [3.4874e-09, 5.0229e-18, 2.2085e-18, 2.9045e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "722000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6760e-20, 3.0968e-40, 1.6077e-40, 2.3498e-40],\n", + " [3.0754e-09, 4.6464e-18, 1.9265e-18, 2.5615e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "723000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9140e-20, 3.1748e-40, 1.6835e-40, 2.4503e-40],\n", + " [3.1720e-09, 4.7176e-18, 1.9841e-18, 2.6307e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "724000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1117e-20, 3.2351e-40, 1.7449e-40, 2.5315e-40],\n", + " [3.2565e-09, 4.7871e-18, 2.0387e-18, 2.6962e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "725000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.8102e-20, 4.1825e-40, 2.6729e-40, 3.7389e-40],\n", + " [4.1104e-09, 5.4507e-18, 2.5854e-18, 3.3507e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "726000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.2725e-20, 3.1258e-40, 1.7027e-40, 2.4683e-40],\n", + " [3.3122e-09, 4.6891e-18, 2.0042e-18, 2.6493e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "727000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5382e-20, 2.7549e-40, 1.4068e-40, 2.0696e-40],\n", + " [3.0348e-09, 4.3909e-18, 1.7984e-18, 2.3967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "728000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.4808e-20, 3.1260e-40, 1.7299e-40, 2.5017e-40],\n", + " [3.3976e-09, 4.7093e-18, 2.0347e-18, 2.6840e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "729000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[6.3558e-20, 3.7245e-40, 2.3181e-40, 3.2690e-40],\n", + " [3.9925e-09, 5.1443e-18, 2.3945e-18, 3.1146e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "730000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.0063e-20, 3.1948e-40, 1.8320e-40, 2.6316e-40],\n", + " [3.5745e-09, 4.7512e-18, 2.0959e-18, 2.7542e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "731000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5040e-20, 2.9382e-40, 1.6237e-40, 2.3528e-40],\n", + " [3.4029e-09, 4.5458e-18, 1.9556e-18, 2.5824e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "732000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.3337e-20, 2.9162e-40, 1.5951e-40, 2.3175e-40],\n", + " [3.3699e-09, 4.5862e-18, 1.9700e-18, 2.6007e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "733000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0284e-20, 2.3497e-40, 1.1387e-40, 1.6997e-40],\n", + " [2.8592e-09, 4.1136e-18, 1.6349e-18, 2.1903e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "734000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.9436e-20, 3.3456e-40, 2.0330e-40, 2.8897e-40],\n", + " [3.9040e-09, 4.9207e-18, 2.2591e-18, 2.9454e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "735000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2057e-20, 2.3119e-40, 1.1393e-40, 1.6966e-40],\n", + " [2.9335e-09, 4.0684e-18, 1.6304e-18, 2.1813e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "736000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[5.7058e-20, 3.1214e-40, 1.8664e-40, 2.6654e-40],\n", + " [3.8286e-09, 4.7370e-18, 2.1472e-18, 2.8067e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "737000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3940e-20, 1.8989e-40, 8.4762e-41, 1.2913e-40],\n", + " [2.5748e-09, 3.7002e-18, 1.3940e-18, 1.8867e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "738000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0141e-20, 2.4977e-40, 1.3257e-40, 1.9455e-40],\n", + " [3.2668e-09, 4.2485e-18, 1.7857e-18, 2.3675e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "739000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4068e-20, 1.8569e-40, 8.3019e-41, 1.2656e-40],\n", + " [2.5830e-09, 3.6592e-18, 1.3781e-18, 1.8653e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "740000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8394e-20, 2.4209e-40, 1.2679e-40, 1.8677e-40],\n", + " [3.2235e-09, 4.2261e-18, 1.7675e-18, 2.3447e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "741000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4505e-20, 2.2248e-40, 1.1227e-40, 1.6685e-40],\n", + " [3.0670e-09, 4.0421e-18, 1.6485e-18, 2.1975e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "742000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1834e-20, 2.4402e-40, 1.3135e-40, 1.9257e-40],\n", + " [3.3595e-09, 4.2482e-18, 1.8069e-18, 2.3894e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "743000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4230e-20, 2.1356e-40, 1.0734e-40, 1.5984e-40],\n", + " [3.0609e-09, 3.9638e-18, 1.6116e-18, 2.1496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "744000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2163e-20, 2.0163e-40, 9.9131e-41, 1.4841e-40],\n", + " [2.9729e-09, 3.8443e-18, 1.5392e-18, 2.0592e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "745000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[5.5030e-20, 2.6526e-40, 1.5609e-40, 2.2481e-40],\n", + " [3.8098e-09, 4.4154e-18, 1.9816e-18, 2.5947e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "746000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6067e-20, 2.0512e-40, 1.0456e-40, 1.5549e-40],\n", + " [3.1325e-09, 3.8676e-18, 1.5812e-18, 2.1074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "747000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5901e-20, 1.9944e-40, 1.0138e-40, 1.5096e-40],\n", + " [3.1247e-09, 3.8071e-18, 1.5516e-18, 2.0694e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "748000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9698e-20, 2.1920e-40, 1.1326e-40, 1.6615e-40],\n", + " [3.3752e-09, 4.1072e-18, 1.7017e-18, 2.2399e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "749000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1330e-20, 2.1213e-40, 1.1123e-40, 1.6279e-40],\n", + " [3.4383e-09, 4.0144e-18, 1.6764e-18, 2.2037e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "750000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4698e-20, 1.8653e-40, 9.2756e-41, 1.3786e-40],\n", + " [3.1357e-09, 3.7601e-18, 1.5155e-18, 2.0128e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "751000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9383e-20, 1.6652e-40, 7.8691e-41, 1.1868e-40],\n", + " [2.8741e-09, 3.5398e-18, 1.3796e-18, 1.8502e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "752000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0767e-20, 1.9540e-40, 1.0211e-40, 1.5007e-40],\n", + " [3.3923e-09, 3.8550e-18, 1.6001e-18, 2.1102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "753000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.4042e-20, 1.7233e-40, 8.5198e-41, 1.2724e-40],\n", + " [3.0859e-09, 3.6059e-18, 1.4428e-18, 1.9231e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "754000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4963e-20, 1.7586e-40, 8.7871e-41, 1.3098e-40],\n", + " [3.1419e-09, 3.6686e-18, 1.4828e-18, 1.9722e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "755000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3896e-20, 1.6954e-40, 8.3917e-41, 1.2552e-40],\n", + " [3.0870e-09, 3.5981e-18, 1.4441e-18, 1.9253e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "756000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.1252e-20, 1.8321e-40, 9.6328e-41, 1.4199e-40],\n", + " [3.4039e-09, 3.7503e-18, 1.5616e-18, 2.0626e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "757000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6653e-20, 1.4663e-40, 6.7681e-41, 1.0339e-40],\n", + " [2.7408e-09, 3.3606e-18, 1.2946e-18, 1.7479e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "758000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9216e-20, 1.5077e-40, 7.1560e-41, 1.0862e-40],\n", + " [2.8668e-09, 3.4112e-18, 1.3361e-18, 1.7966e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "759000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8770e-20, 1.1593e-40, 4.8098e-41, 7.5770e-41],\n", + " [2.2832e-09, 2.9692e-18, 1.0669e-18, 1.4697e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "760000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.2869e-20, 1.5533e-40, 7.6480e-41, 1.1518e-40],\n", + " [3.0386e-09, 3.4727e-18, 1.3910e-18, 1.8609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "761000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7550e-20, 1.3764e-40, 6.4188e-41, 9.8189e-41],\n", + " [2.7702e-09, 3.2566e-18, 1.2587e-18, 1.7013e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "762000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9211e-20, 1.6287e-40, 8.4636e-41, 1.2593e-40],\n", + " [3.3107e-09, 3.5622e-18, 1.4729e-18, 1.9556e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "763000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3409e-20, 1.2190e-40, 5.4152e-41, 8.4099e-41],\n", + " [2.5450e-09, 3.0611e-18, 1.1465e-18, 1.5648e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "764000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.3818e-20, 1.6865e-40, 9.0712e-41, 1.3394e-40],\n", + " [3.5018e-09, 3.6392e-18, 1.5382e-18, 2.0317e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "765000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7650e-20, 1.2821e-40, 5.9915e-41, 9.1976e-41],\n", + " [2.7610e-09, 3.1450e-18, 1.2140e-18, 1.6448e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "766000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4360e-20, 1.4159e-40, 7.0700e-41, 1.0672e-40],\n", + " [3.0802e-09, 3.3161e-18, 1.3338e-18, 1.7877e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "767000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6536e-20, 1.2360e-40, 5.7160e-41, 8.8146e-41],\n", + " [2.7088e-09, 3.1016e-18, 1.1915e-18, 1.6181e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "768000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2131e-20, 1.5594e-40, 8.3049e-41, 1.2342e-40],\n", + " [3.4253e-09, 3.5105e-18, 1.4739e-18, 1.9542e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "769000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3205e-20, 1.3409e-40, 6.6392e-41, 1.0072e-40],\n", + " [3.0268e-09, 3.2397e-18, 1.2971e-18, 1.7432e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "770000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9071e-20, 1.4497e-40, 7.5524e-41, 1.1314e-40],\n", + " [3.2917e-09, 3.3869e-18, 1.4018e-18, 1.8678e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "771000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0707e-20, 1.2432e-40, 6.0172e-41, 9.2037e-41],\n", + " [2.9041e-09, 3.1212e-18, 1.2312e-18, 1.6632e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "772000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1469e-20, 1.2392e-40, 6.0431e-41, 9.2325e-41],\n", + " [2.9362e-09, 3.1159e-18, 1.2339e-18, 1.6658e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "773000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2035e-20, 1.2570e-40, 6.1743e-41, 9.4206e-41],\n", + " [2.9718e-09, 3.1531e-18, 1.2572e-18, 1.6948e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "774000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.5355e-20, 1.2977e-40, 6.5691e-41, 9.9533e-41],\n", + " [3.1192e-09, 3.2075e-18, 1.3021e-18, 1.7476e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "775000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4857e-20, 1.2774e-40, 6.4470e-41, 9.7861e-41],\n", + " [3.1003e-09, 3.1912e-18, 1.2945e-18, 1.7387e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "776000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9647e-20, 1.3401e-40, 7.0356e-41, 1.0580e-40],\n", + " [3.3045e-09, 3.2740e-18, 1.3602e-18, 1.8161e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "777000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2527e-20, 1.3841e-40, 7.4322e-41, 1.1118e-40],\n", + " [3.4298e-09, 3.3417e-18, 1.4101e-18, 1.8756e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "778000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1034e-20, 1.1473e-40, 5.5958e-41, 8.5961e-41],\n", + " [2.9152e-09, 3.0243e-18, 1.1994e-18, 1.6233e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "779000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9014e-20, 1.2729e-40, 6.6556e-41, 1.0045e-40],\n", + " [3.2709e-09, 3.1964e-18, 1.3237e-18, 1.7712e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "780000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7028e-20, 1.0370e-40, 4.8563e-41, 7.5569e-41],\n", + " [2.7154e-09, 2.8762e-18, 1.1119e-18, 1.5170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "781000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8388e-20, 8.4198e-41, 3.5024e-41, 5.6104e-41],\n", + " [2.2500e-09, 2.5962e-18, 9.3184e-19, 1.2934e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "782000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.6177e-20, 1.1718e-40, 6.0019e-41, 9.1376e-41],\n", + " [3.1455e-09, 3.0768e-18, 1.2581e-18, 1.6921e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "783000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6250e-20, 1.1515e-40, 5.9007e-41, 8.9903e-41],\n", + " [3.1433e-09, 3.0484e-18, 1.2456e-18, 1.6764e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "784000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1889e-20, 1.0558e-40, 5.2036e-41, 8.0187e-41],\n", + " [2.9392e-09, 2.9110e-18, 1.1592e-18, 1.5719e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "785000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0511e-20, 1.0105e-40, 4.9137e-41, 7.6064e-41],\n", + " [2.8684e-09, 2.8440e-18, 1.1217e-18, 1.5258e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "786000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.1082e-20, 1.0257e-40, 5.0277e-41, 7.7734e-41],\n", + " [2.9068e-09, 2.8834e-18, 1.1465e-18, 1.5569e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "787000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5132e-20, 1.0877e-40, 5.5412e-41, 8.4874e-41],\n", + " [3.0977e-09, 2.9836e-18, 1.2170e-18, 1.6420e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "788000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6242e-20, 1.0857e-40, 5.5842e-41, 8.5397e-41],\n", + " [3.1419e-09, 2.9809e-18, 1.2221e-18, 1.6473e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "789000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7672e-20, 1.0829e-40, 5.6376e-41, 8.6040e-41],\n", + " [3.1976e-09, 2.9772e-18, 1.2283e-18, 1.6538e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "790000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2551e-20, 8.1832e-41, 3.6201e-41, 5.7295e-41],\n", + " [2.5017e-09, 2.6017e-18, 9.6832e-19, 1.3309e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "791000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8360e-20, 1.1913e-40, 6.6936e-41, 1.0028e-40],\n", + " [3.6197e-09, 3.1327e-18, 1.3539e-18, 1.8016e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "792000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6070e-20, 8.6719e-41, 4.0380e-41, 6.3490e-41],\n", + " [2.6670e-09, 2.6727e-18, 1.0286e-18, 1.4098e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "793000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5348e-20, 9.9425e-41, 5.0908e-41, 7.8331e-41],\n", + " [3.0906e-09, 2.8611e-18, 1.1677e-18, 1.5799e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "794000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9656e-20, 9.0295e-41, 4.3901e-41, 6.8550e-41],\n", + " [2.8310e-09, 2.7282e-18, 1.0791e-18, 1.4733e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "795000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2016e-20, 9.2368e-41, 4.5971e-41, 7.1400e-41],\n", + " [2.9389e-09, 2.7616e-18, 1.1075e-18, 1.5071e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "796000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5402e-20, 8.1546e-41, 3.7441e-41, 5.8772e-41],\n", + " [2.6769e-09, 2.6388e-18, 1.0065e-18, 1.3729e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "797000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4948e-20, 7.9428e-41, 3.6173e-41, 5.6789e-41],\n", + " [2.6656e-09, 2.6165e-18, 9.9229e-19, 1.3522e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "798000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6320e-20, 7.9896e-41, 3.7035e-41, 5.8014e-41],\n", + " [2.7251e-09, 2.6181e-18, 1.0027e-18, 1.3654e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "799000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2758e-20, 8.6572e-41, 4.3362e-41, 6.7414e-41],\n", + " [2.9604e-09, 2.6748e-18, 1.0726e-18, 1.4606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "800000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3598e-20, 8.7538e-41, 4.4242e-41, 6.8647e-41],\n", + " [3.0074e-09, 2.7026e-18, 1.0916e-18, 1.4836e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "801000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5105e-20, 8.7483e-41, 4.4847e-41, 6.9444e-41],\n", + " [3.0657e-09, 2.6997e-18, 1.0987e-18, 1.4918e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "802000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.7610e-20, 8.9484e-41, 4.6915e-41, 7.2355e-41],\n", + " [3.1624e-09, 2.7261e-18, 1.1243e-18, 1.5235e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "803000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1455e-20, 8.2472e-41, 4.0593e-41, 6.2995e-41],\n", + " [2.9655e-09, 2.6716e-18, 1.0621e-18, 1.4380e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "804000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9868e-20, 7.9103e-41, 3.8152e-41, 5.9279e-41],\n", + " [2.9170e-09, 2.6379e-18, 1.0351e-18, 1.3997e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "805000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9632e-20, 7.7475e-41, 3.7207e-41, 5.7797e-41],\n", + " [2.9152e-09, 2.6200e-18, 1.0245e-18, 1.3841e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "806000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.5776e-20, 8.4714e-41, 4.3566e-41, 6.7156e-41],\n", + " [3.1523e-09, 2.7161e-18, 1.1100e-18, 1.4967e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "807000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8293e-20, 7.4941e-41, 3.5351e-41, 5.4892e-41],\n", + " [2.8967e-09, 2.6205e-18, 1.0158e-18, 1.3672e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "808000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5211e-20, 7.0128e-41, 3.1693e-41, 4.9380e-41],\n", + " [2.7811e-09, 2.5695e-18, 9.6990e-19, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "809000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5641e-20, 7.0243e-41, 3.1923e-41, 4.9673e-41],\n", + " [2.8094e-09, 2.5786e-18, 9.7720e-19, 1.3121e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "810000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4864e-20, 6.8239e-41, 3.0632e-41, 4.7693e-41],\n", + " [2.7832e-09, 2.5555e-18, 9.6053e-19, 1.2886e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "811000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6864e-20, 6.9472e-41, 3.2022e-41, 4.9710e-41],\n", + " [2.8699e-09, 2.5659e-18, 9.7918e-19, 1.3129e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "812000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3615e-20, 6.6152e-41, 2.9127e-41, 4.5340e-41],\n", + " [2.7607e-09, 2.5609e-18, 9.5394e-19, 1.2750e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "813000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5345e-20, 7.7808e-41, 3.9574e-41, 6.0746e-41],\n", + " [3.2142e-09, 2.6801e-18, 1.0880e-18, 1.4545e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "814000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0408e-20, 8.1315e-41, 4.3365e-41, 6.6234e-41],\n", + " [3.3857e-09, 2.7123e-18, 1.1320e-18, 1.5126e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "815000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.5134e-20, 7.5554e-41, 3.8261e-41, 5.8663e-41],\n", + " [3.2300e-09, 2.6651e-18, 1.0788e-18, 1.4386e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "816000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4342e-20, 6.2487e-41, 2.7657e-41, 4.2908e-41],\n", + " [2.8260e-09, 2.5190e-18, 9.3918e-19, 1.2496e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "817000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3182e-20, 6.0004e-41, 2.6059e-41, 4.0472e-41],\n", + " [2.7819e-09, 2.4872e-18, 9.1594e-19, 1.2174e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "818000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.9746e-20, 6.6744e-41, 3.1697e-41, 4.8767e-41],\n", + " [3.0701e-09, 2.5792e-18, 1.0037e-18, 1.3323e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "819000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0424e-20, 7.6546e-41, 4.0628e-41, 6.1797e-41],\n", + " [3.4625e-09, 2.7016e-18, 1.1260e-18, 1.4931e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "820000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3543e-20, 7.0857e-41, 3.5161e-41, 5.3737e-41],\n", + " [3.2596e-09, 2.6735e-18, 1.0737e-18, 1.4189e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "821000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.3510e-20, 5.9226e-41, 2.5812e-41, 3.9908e-41],\n", + " [2.8616e-09, 2.5349e-18, 9.4065e-19, 1.2409e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "822000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6343e-20, 6.0860e-41, 2.7582e-41, 4.2455e-41],\n", + " [2.9941e-09, 2.5515e-18, 9.6826e-19, 1.2762e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "823000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7466e-20, 6.0774e-41, 2.7919e-41, 4.2890e-41],\n", + " [3.0486e-09, 2.5476e-18, 9.7371e-19, 1.2822e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "824000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1497e-20, 6.3804e-41, 3.0770e-41, 4.7002e-41],\n", + " [3.2258e-09, 2.5935e-18, 1.0211e-18, 1.3426e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "825000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.9766e-20, 7.0763e-41, 3.7140e-41, 5.6223e-41],\n", + " [3.5390e-09, 2.6890e-18, 1.1156e-18, 1.4649e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "826000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1008e-20, 6.2047e-41, 2.9709e-41, 4.5340e-41],\n", + " [3.2314e-09, 2.5845e-18, 1.0137e-18, 1.3293e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "827000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7983e-20, 5.8033e-41, 2.6733e-41, 4.0928e-41],\n", + " [3.1160e-09, 2.5305e-18, 9.6887e-19, 1.2692e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "828000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7754e-20, 5.6942e-41, 2.6126e-41, 3.9975e-41],\n", + " [3.1194e-09, 2.5212e-18, 9.6293e-19, 1.2594e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "829000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0094e-20, 5.7935e-41, 2.7332e-41, 4.1684e-41],\n", + " [3.2228e-09, 2.5314e-18, 9.8222e-19, 1.2837e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "830000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8612e-20, 5.7027e-41, 2.6434e-41, 4.0328e-41],\n", + " [3.1890e-09, 2.5477e-18, 9.8126e-19, 1.2790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "831000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3863e-20, 6.1646e-41, 3.0382e-41, 4.6023e-41],\n", + " [3.4215e-09, 2.6297e-18, 1.0533e-18, 1.3702e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "832000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7630e-20, 5.4944e-41, 2.5114e-41, 3.8293e-41],\n", + " [3.1776e-09, 2.5380e-18, 9.7060e-19, 1.2609e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "833000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0924e-20, 6.4425e-41, 3.3917e-41, 5.0986e-41],\n", + " [3.6919e-09, 2.6582e-18, 1.1055e-18, 1.4356e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "834000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0752e-20, 6.3378e-41, 3.3281e-41, 5.0004e-41],\n", + " [3.6997e-09, 2.6496e-18, 1.1003e-18, 1.4270e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "835000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9392e-20, 5.4899e-41, 2.5616e-41, 3.8858e-41],\n", + " [3.3066e-09, 2.5730e-18, 9.9921e-19, 1.2909e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "836000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3165e-20, 5.6547e-41, 2.7517e-41, 4.1541e-41],\n", + " [3.4703e-09, 2.5922e-18, 1.0311e-18, 1.3308e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "837000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6764e-20, 5.7738e-41, 2.9116e-41, 4.3771e-41],\n", + " [3.6176e-09, 2.6042e-18, 1.0569e-18, 1.3627e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "838000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1615e-20, 5.2601e-41, 2.5069e-41, 3.7867e-41],\n", + " [3.4261e-09, 2.5287e-18, 9.9093e-19, 1.2761e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "839000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6420e-20, 4.8715e-41, 2.1771e-41, 3.3043e-41],\n", + " [3.2310e-09, 2.5000e-18, 9.4584e-19, 1.2143e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "840000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6093e-20, 4.7557e-41, 2.1132e-41, 3.2073e-41],\n", + " [3.2224e-09, 2.4795e-18, 9.3400e-19, 1.1981e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "841000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0652e-20, 5.6914e-41, 2.9657e-41, 4.4295e-41],\n", + " [3.8176e-09, 2.6130e-18, 1.0818e-18, 1.3870e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "842000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3529e-20, 5.1068e-41, 2.4775e-41, 3.7238e-41],\n", + " [3.5581e-09, 2.5266e-18, 1.0012e-18, 1.2821e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "843000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.8787e-20, 5.4387e-41, 2.7824e-41, 4.1540e-41],\n", + " [3.7907e-09, 2.5983e-18, 1.0653e-18, 1.3606e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "844000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2917e-20, 4.9445e-41, 2.3798e-41, 3.5722e-41],\n", + " [3.5698e-09, 2.5215e-18, 9.9572e-19, 1.2705e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "845000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8973e-20, 5.8335e-41, 3.2422e-41, 4.7959e-41],\n", + " [4.1569e-09, 2.6485e-18, 1.1390e-18, 1.4526e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "846000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0863e-20, 4.6518e-41, 2.1834e-41, 3.2783e-41],\n", + " [3.5197e-09, 2.4911e-18, 9.6968e-19, 1.2327e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "847000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2927e-20, 5.3779e-41, 2.8460e-41, 4.2180e-41],\n", + " [4.0152e-09, 2.6212e-18, 1.0981e-18, 1.3932e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "848000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0366e-20, 4.4829e-41, 2.0884e-41, 3.1320e-41],\n", + " [3.5302e-09, 2.4771e-18, 9.6040e-19, 1.2170e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "849000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7077e-20, 4.1575e-41, 1.8553e-41, 2.7926e-41],\n", + " [3.3881e-09, 2.4178e-18, 9.1261e-19, 1.1552e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "850000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.2456e-20, 4.4357e-41, 2.1113e-41, 3.1564e-41],\n", + " [3.6349e-09, 2.4628e-18, 9.6536e-19, 1.2212e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "851000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.6726e-20, 5.2521e-41, 2.8567e-41, 4.2081e-41],\n", + " [4.2127e-09, 2.6221e-18, 1.1167e-18, 1.4086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "852000 actions: tensor([0, 0, 3])\n", + "loss= tensor(2.5348, grad_fn=) , return= 15963.328125\n", + "discReturns/1000= tensor([14.3845, 10.3025, 5.4855])\n", + "actionProbs tensor([[3.7039e-20, 4.5921e-41, 2.2906e-41, 3.4007e-41],\n", + " [3.8674e-09, 2.5128e-18, 1.0148e-18, 1.2785e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "853000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0225e-20, 4.6754e-41, 2.4004e-41, 3.5517e-41],\n", + " [3.9983e-09, 2.5236e-18, 1.0359e-18, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "854000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8870e-20, 3.9340e-41, 1.7881e-41, 2.6763e-41],\n", + " [3.5321e-09, 2.3911e-18, 9.1159e-19, 1.1464e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "855000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3020e-20, 4.0971e-41, 1.9528e-41, 2.9073e-41],\n", + " [3.7250e-09, 2.4182e-18, 9.4748e-19, 1.1905e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "856000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3929e-20, 4.1127e-41, 1.9792e-41, 2.9406e-41],\n", + " [3.7853e-09, 2.4340e-18, 9.6034e-19, 1.2043e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "857000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1227e-20, 3.9469e-41, 1.8434e-41, 2.7439e-41],\n", + " [3.6922e-09, 2.4214e-18, 9.4034e-19, 1.1766e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "858000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.5648e-20, 3.5828e-41, 1.5584e-41, 2.3330e-41],\n", + " [3.4503e-09, 2.3677e-18, 8.8268e-19, 1.1018e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "859000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6280e-20, 4.2370e-41, 2.0920e-41, 3.0892e-41],\n", + " [3.9660e-09, 2.5187e-18, 1.0162e-18, 1.2658e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "860000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0415e-20, 4.3726e-41, 2.2432e-41, 3.2981e-41],\n", + " [4.1398e-09, 2.5405e-18, 1.0478e-18, 1.3040e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "861000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.3103e-20, 3.8906e-41, 1.8531e-41, 2.7435e-41],\n", + " [3.8438e-09, 2.4460e-18, 9.6397e-19, 1.1987e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "862000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0091e-20, 3.6263e-41, 1.6660e-41, 2.4736e-41],\n", + " [3.7157e-09, 2.3897e-18, 9.2050e-19, 1.1434e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "863000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0110e-20, 3.6331e-41, 1.6706e-41, 2.4767e-41],\n", + " [3.7494e-09, 2.4172e-18, 9.3471e-19, 1.1578e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "864000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3870e-20, 3.7364e-41, 1.7903e-41, 2.6416e-41],\n", + " [3.9297e-09, 2.4336e-18, 9.6332e-19, 1.1920e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "865000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0471e-20, 3.4714e-41, 1.5985e-41, 2.3664e-41],\n", + " [3.7827e-09, 2.3752e-18, 9.1701e-19, 1.1336e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "866000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8051e-20, 3.2640e-41, 1.4565e-41, 2.1621e-41],\n", + " [3.6720e-09, 2.3265e-18, 8.8055e-19, 1.0876e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "867000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9738e-20, 3.2938e-41, 1.4998e-41, 2.2206e-41],\n", + " [3.7609e-09, 2.3306e-18, 8.9202e-19, 1.1009e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "868000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6310e-20, 3.1469e-41, 1.3727e-41, 2.0380e-41],\n", + " [3.6233e-09, 2.3282e-18, 8.7202e-19, 1.0731e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "869000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7563e-20, 3.1435e-41, 1.3928e-41, 2.0636e-41],\n", + " [3.6951e-09, 2.3239e-18, 8.7759e-19, 1.0790e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "870000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.6935e-20, 3.4887e-41, 1.7159e-41, 2.5139e-41],\n", + " [4.1430e-09, 2.3955e-18, 9.6137e-19, 1.1805e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "871000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1971e-20, 3.2017e-41, 1.4927e-41, 2.1975e-41],\n", + " [3.9275e-09, 2.3298e-18, 9.0479e-19, 1.1102e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "872000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.0580e-20, 3.5833e-41, 1.8236e-41, 2.6571e-41],\n", + " [4.3427e-09, 2.4411e-18, 1.0023e-18, 1.2261e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "873000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.4471e-20, 2.7506e-41, 1.1634e-41, 1.7256e-41],\n", + " [3.5892e-09, 2.2443e-18, 8.2395e-19, 1.0068e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "874000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.1618e-20, 3.4490e-41, 1.7670e-41, 2.5694e-41],\n", + " [4.4051e-09, 2.4055e-18, 9.8915e-19, 1.2074e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "875000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2215e-20, 2.9932e-41, 1.3953e-41, 2.0472e-41],\n", + " [4.0022e-09, 2.2985e-18, 8.9235e-19, 1.0884e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "876000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.8604e-20, 3.6340e-41, 1.9699e-41, 2.8420e-41],\n", + " [4.7309e-09, 2.4721e-18, 1.0539e-18, 1.2812e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "877000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8027e-20, 3.1612e-41, 1.5647e-41, 2.2767e-41],\n", + " [4.3163e-09, 2.3634e-18, 9.5322e-19, 1.1577e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "878000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.9291e-20, 2.2407e-41, 8.6642e-42, 1.2916e-41],\n", + " [3.3534e-09, 2.1336e-18, 7.4461e-19, 9.0268e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "879000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8606e-20, 2.7241e-41, 1.2163e-41, 1.7841e-41],\n", + " [3.9198e-09, 2.2845e-18, 8.6901e-19, 1.0510e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "880000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.9753e-20, 2.7117e-41, 1.2267e-41, 1.7958e-41],\n", + " [3.9873e-09, 2.2782e-18, 8.7242e-19, 1.0541e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "881000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6280e-20, 2.4995e-41, 1.0798e-41, 1.5873e-41],\n", + " [3.8100e-09, 2.2176e-18, 8.2525e-19, 9.9625e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "882000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5768e-20, 2.4799e-41, 1.0647e-41, 1.5638e-41],\n", + " [3.8138e-09, 2.2357e-18, 8.3147e-19, 1.0010e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "883000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.8284e-20, 2.9268e-41, 1.4494e-41, 2.0972e-41],\n", + " [4.4461e-09, 2.3524e-18, 9.5168e-19, 1.1445e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "884000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.5722e-20, 3.1156e-41, 1.6446e-41, 2.3631e-41],\n", + " [4.7676e-09, 2.3961e-18, 1.0059e-18, 1.2086e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "885000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4806e-20, 2.2829e-41, 9.6367e-42, 1.4157e-41],\n", + " [3.7775e-09, 2.1688e-18, 7.9602e-19, 9.5598e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "886000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2445e-20, 2.9066e-41, 1.4913e-41, 2.1458e-41],\n", + " [4.6643e-09, 2.3503e-18, 9.6984e-19, 1.1623e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "887000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.1013e-20, 2.4988e-41, 1.1442e-41, 1.6638e-41],\n", + " [4.1635e-09, 2.2584e-18, 8.7281e-19, 1.0439e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "888000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.2506e-20, 2.0949e-41, 8.5325e-42, 1.2547e-41],\n", + " [3.6893e-09, 2.1327e-18, 7.6765e-19, 9.1743e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "889000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0790e-20, 2.4513e-41, 1.0908e-41, 1.5501e-41],\n", + " [4.3503e-09, 2.3347e-18, 8.8780e-19, 1.0378e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "890000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.8867e-20, 2.2810e-41, 9.9492e-42, 1.4223e-41],\n", + " [4.1975e-09, 2.2484e-18, 8.4278e-19, 9.8933e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "891000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3930e-20, 2.5071e-41, 1.1578e-41, 1.6356e-41],\n", + " [4.5870e-09, 2.3883e-18, 9.3247e-19, 1.0845e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "892000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[4.0595e-20, 2.6936e-41, 1.3192e-41, 1.8409e-41],\n", + " [5.0102e-09, 2.4793e-18, 1.0026e-18, 1.1569e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "893000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.3466e-20, 2.3739e-41, 1.0934e-41, 1.5483e-41],\n", + " [4.5362e-09, 2.3210e-18, 9.0229e-19, 1.0515e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "894000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.4099e-20, 2.3451e-41, 1.0874e-41, 1.5388e-41],\n", + " [4.5703e-09, 2.3061e-18, 8.9915e-19, 1.0475e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "895000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.9915e-20, 1.7708e-41, 6.8594e-42, 1.0108e-41],\n", + " [3.4929e-09, 2.0148e-18, 7.0097e-19, 8.3876e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "896000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7867e-20, 1.6457e-41, 6.1349e-42, 9.1225e-42],\n", + " [3.3001e-09, 1.9445e-18, 6.5846e-19, 7.9302e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "897000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[4.2261e-20, 2.4610e-41, 1.2298e-41, 1.7163e-41],\n", + " [5.0871e-09, 2.3837e-18, 9.7368e-19, 1.1234e-18],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "898000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[3.0689e-20, 2.0299e-41, 9.1603e-42, 1.3092e-41],\n", + " [4.3211e-09, 2.1558e-18, 8.2549e-19, 9.6782e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "899000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7704e-20, 1.8821e-41, 8.2088e-42, 1.1831e-41],\n", + " [4.0949e-09, 2.0748e-18, 7.7616e-19, 9.1532e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "900000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.2148e-20, 1.6549e-41, 6.6660e-42, 9.7825e-42],\n", + " [3.6500e-09, 1.9502e-18, 6.9095e-19, 8.2519e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "901000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.2378e-20, 1.9716e-41, 9.0888e-42, 1.2961e-41],\n", + " [4.4295e-09, 2.1335e-18, 8.2700e-19, 9.6799e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "902000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[3.0548e-20, 1.9188e-41, 8.7049e-42, 1.2465e-41],\n", + " [4.3196e-09, 2.1198e-18, 8.1566e-19, 9.5660e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "903000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8589e-20, 1.4866e-41, 5.6514e-42, 8.4162e-42],\n", + " [3.3561e-09, 1.8762e-18, 6.4132e-19, 7.7273e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "904000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.4595e-20, 1.6426e-41, 6.8958e-42, 1.0060e-41],\n", + " [3.8534e-09, 1.9656e-18, 7.1588e-19, 8.5080e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "905000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8239e-20, 1.4016e-41, 5.2927e-42, 7.9075e-42],\n", + " [3.3084e-09, 1.8218e-18, 6.1774e-19, 7.4634e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "906000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0951e-20, 1.4680e-41, 5.8224e-42, 8.6124e-42],\n", + " [3.5417e-09, 1.8614e-18, 6.5112e-19, 7.8144e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "907000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.6621e-20, 1.6280e-41, 7.0401e-42, 1.0225e-41],\n", + " [4.0022e-09, 1.9639e-18, 7.2806e-19, 8.6262e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "908000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6731e-20, 1.5941e-41, 6.9042e-42, 1.0033e-41],\n", + " [4.0016e-09, 1.9431e-18, 7.1984e-19, 8.5340e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "909000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3182e-20, 1.4538e-41, 5.9863e-42, 8.8044e-42],\n", + " [3.7155e-09, 1.8585e-18, 6.6464e-19, 7.9462e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "910000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.8126e-20, 1.5751e-41, 6.9560e-42, 1.0082e-41],\n", + " [4.1002e-09, 1.9379e-18, 7.2633e-19, 8.5949e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "911000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7802e-20, 1.2659e-41, 4.7602e-42, 7.1508e-42],\n", + " [3.2603e-09, 1.7525e-18, 5.9092e-19, 7.1627e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "912000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5382e-20, 1.1589e-41, 4.1408e-42, 6.2932e-42],\n", + " [3.0231e-09, 1.6795e-18, 5.4654e-19, 6.6806e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "913000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0887e-20, 1.3001e-41, 5.1722e-42, 7.6875e-42],\n", + " [3.5177e-09, 1.7725e-18, 6.1824e-19, 7.4430e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "914000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0956e-20, 9.6970e-42, 3.0829e-42, 4.8121e-42],\n", + " [2.5643e-09, 1.5634e-18, 4.7306e-19, 5.8805e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "915000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.2820e-20, 1.3551e-41, 5.5842e-42, 8.2424e-42],\n", + " [3.7016e-09, 1.8300e-18, 6.5595e-19, 7.8507e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "916000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6007e-20, 1.1308e-41, 4.1128e-42, 6.2428e-42],\n", + " [3.0912e-09, 1.6787e-18, 5.5328e-19, 6.7507e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "917000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.6293e-20, 1.3842e-41, 5.9934e-42, 8.7651e-42],\n", + " [3.9587e-09, 1.8459e-18, 6.8172e-19, 8.1106e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "918000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3363e-20, 1.2839e-41, 5.3319e-42, 7.8767e-42],\n", + " [3.7227e-09, 1.7803e-18, 6.3859e-19, 7.6506e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "919000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5708e-20, 1.0514e-41, 3.7989e-42, 5.7902e-42],\n", + " [3.0433e-09, 1.6187e-18, 5.2872e-19, 6.4720e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "920000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1961e-20, 1.1980e-41, 4.8681e-42, 7.2363e-42],\n", + " [3.5945e-09, 1.7207e-18, 6.0660e-19, 7.3013e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "921000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.9507e-20, 1.1386e-41, 4.4477e-42, 6.6702e-42],\n", + " [3.3958e-09, 1.6883e-18, 5.8067e-19, 7.0289e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "922000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.7487e-20, 1.3230e-41, 5.8378e-42, 8.5311e-42],\n", + " [4.0411e-09, 1.8197e-18, 6.7914e-19, 8.0726e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "923000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0734e-20, 1.1416e-41, 4.5626e-42, 6.8187e-42],\n", + " [3.5004e-09, 1.6962e-18, 5.9197e-19, 7.1465e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "924000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6989e-20, 1.0252e-41, 3.8213e-42, 5.8014e-42],\n", + " [3.1615e-09, 1.6112e-18, 5.3623e-19, 6.5454e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "925000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8931e-20, 1.0620e-41, 4.1156e-42, 6.2007e-42],\n", + " [3.3407e-09, 1.6440e-18, 5.6163e-19, 6.8173e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "926000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7018e-20, 9.9198e-42, 3.7036e-42, 5.6290e-42],\n", + " [3.1607e-09, 1.5911e-18, 5.2959e-19, 6.4687e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "927000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1058e-20, 1.0651e-41, 4.2838e-42, 6.4137e-42],\n", + " [3.5094e-09, 1.6444e-18, 5.7398e-19, 6.9394e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "928000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3480e-20, 8.8268e-42, 3.0464e-42, 4.7154e-42],\n", + " [2.8174e-09, 1.5151e-18, 4.7920e-19, 5.9235e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "929000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3244e-20, 1.0947e-41, 4.5682e-42, 6.7921e-42],\n", + " [3.6945e-09, 1.6760e-18, 5.9993e-19, 7.2152e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "930000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.6107e-20, 9.1561e-42, 3.3617e-42, 5.1428e-42],\n", + " [3.0685e-09, 1.5397e-18, 5.0578e-19, 6.2038e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "931000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5841e-20, 8.9417e-42, 3.2636e-42, 5.0026e-42],\n", + " [3.0380e-09, 1.5217e-18, 4.9738e-19, 6.1094e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "932000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7966e-20, 1.1226e-41, 4.9998e-42, 7.3442e-42],\n", + " [4.0315e-09, 1.6929e-18, 6.3001e-19, 7.5191e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "933000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4115e-20, 8.1626e-42, 2.8629e-42, 4.4323e-42],\n", + " [2.8561e-09, 1.4558e-18, 4.6202e-19, 5.7174e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "934000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4863e-20, 8.2144e-42, 2.9343e-42, 4.5276e-42],\n", + " [2.9265e-09, 1.4595e-18, 4.6820e-19, 5.7817e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "935000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4072e-20, 7.9187e-42, 2.7802e-42, 4.3090e-42],\n", + " [2.8480e-09, 1.4361e-18, 4.5582e-19, 5.6436e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "936000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4859e-20, 8.1359e-42, 2.9161e-42, 4.5010e-42],\n", + " [2.9367e-09, 1.4634e-18, 4.7193e-19, 5.8225e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "937000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.5655e-20, 1.0123e-41, 4.3917e-42, 6.5062e-42],\n", + " [3.8548e-09, 1.6204e-18, 5.9214e-19, 7.1051e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "938000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0666e-20, 6.8201e-42, 2.1832e-42, 3.4570e-42],\n", + " [2.4794e-09, 1.3447e-18, 4.0144e-19, 5.0429e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "939000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6736e-20, 8.1107e-42, 3.0324e-42, 4.6467e-42],\n", + " [3.1010e-09, 1.4581e-18, 4.8169e-19, 5.9169e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "940000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7371e-20, 8.2452e-42, 3.1277e-42, 4.7812e-42],\n", + " [3.1674e-09, 1.4768e-18, 4.9336e-19, 6.0457e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "941000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.7032e-20, 9.8189e-42, 4.3454e-42, 6.4264e-42],\n", + " [3.9465e-09, 1.6024e-18, 5.9196e-19, 7.0939e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "942000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1619e-20, 6.7318e-42, 2.2225e-42, 3.5046e-42],\n", + " [2.5820e-09, 1.3410e-18, 4.0779e-19, 5.1070e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "943000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3302e-20, 7.0639e-42, 2.4509e-42, 3.8255e-42],\n", + " [2.7670e-09, 1.3747e-18, 4.3273e-19, 5.3778e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "944000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3257e-20, 6.9154e-42, 2.3976e-42, 3.7443e-42],\n", + " [2.7570e-09, 1.3601e-18, 4.2721e-19, 5.3140e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "945000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.7038e-20, 7.5642e-42, 2.8586e-42, 4.3861e-42],\n", + " [3.1208e-09, 1.4180e-18, 4.7101e-19, 5.7872e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "946000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1663e-20, 8.2256e-42, 3.3799e-42, 5.0951e-42],\n", + " [3.5131e-09, 1.4741e-18, 5.1666e-19, 6.2742e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "947000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5660e-20, 7.0906e-42, 2.6064e-42, 4.0287e-42],\n", + " [2.9870e-09, 1.3777e-18, 4.4858e-19, 5.5402e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "948000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4707e-20, 6.9140e-42, 2.4999e-42, 3.8788e-42],\n", + " [2.9058e-09, 1.3676e-18, 4.4197e-19, 5.4677e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "949000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0237e-20, 7.7716e-42, 3.1389e-42, 4.7574e-42],\n", + " [3.4027e-09, 1.4440e-18, 5.0126e-19, 6.1045e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "950000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8656e-20, 7.3918e-42, 2.9007e-42, 4.4281e-42],\n", + " [3.2623e-09, 1.4096e-18, 4.7976e-19, 5.8701e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "951000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.0139e-20, 7.5124e-42, 3.0282e-42, 4.5977e-42],\n", + " [3.3842e-09, 1.4197e-18, 4.9111e-19, 5.9889e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "952000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1925e-20, 5.9275e-42, 1.9926e-42, 3.1501e-42],\n", + " [2.6000e-09, 1.2694e-18, 3.8927e-19, 4.8789e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "953000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2281e-20, 5.9611e-42, 2.0277e-42, 3.1964e-42],\n", + " [2.6399e-09, 1.2755e-18, 3.9410e-19, 4.9323e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "954000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2028e-20, 5.8168e-42, 1.9632e-42, 3.1039e-42],\n", + " [2.6086e-09, 1.2603e-18, 3.8711e-19, 4.8525e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "955000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4420e-20, 6.1489e-42, 2.2098e-42, 3.4486e-42],\n", + " [2.8504e-09, 1.2928e-18, 4.1316e-19, 5.1352e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "956000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5097e-20, 6.2862e-42, 2.2981e-42, 3.5747e-42],\n", + " [2.9237e-09, 1.3120e-18, 4.2480e-19, 5.2650e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "957000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5092e-20, 6.1671e-42, 2.2547e-42, 3.5089e-42],\n", + " [2.9179e-09, 1.2995e-18, 4.2012e-19, 5.2107e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "958000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6101e-20, 6.2904e-42, 2.3570e-42, 3.6504e-42],\n", + " [3.0159e-09, 1.3134e-18, 4.3184e-19, 5.3362e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "959000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0862e-20, 5.2507e-42, 1.7194e-42, 2.7437e-42],\n", + " [2.4733e-09, 1.2059e-18, 3.6233e-19, 4.5707e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "960000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.3499e-20, 7.1256e-42, 3.0422e-42, 4.5850e-42],\n", + " [3.6313e-09, 1.3908e-18, 4.9718e-19, 6.0329e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "961000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6948e-20, 6.0872e-42, 2.3220e-42, 3.5901e-42],\n", + " [3.0778e-09, 1.2910e-18, 4.2779e-19, 5.2827e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "962000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1013e-20, 6.6800e-42, 2.7564e-42, 4.1899e-42],\n", + " [3.4397e-09, 1.3551e-18, 4.7436e-19, 5.7860e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "963000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7480e-20, 6.0942e-42, 2.3598e-42, 3.6406e-42],\n", + " [3.1329e-09, 1.2975e-18, 4.3510e-19, 5.3601e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "964000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5446e-20, 5.6753e-42, 2.1062e-42, 3.2818e-42],\n", + " [2.9395e-09, 1.2540e-18, 4.0831e-19, 5.0657e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "965000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2345e-20, 5.1652e-42, 1.7811e-42, 2.8194e-42],\n", + " [2.6342e-09, 1.2042e-18, 3.7410e-19, 4.6909e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "966000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4463e-20, 5.4188e-42, 1.9716e-42, 3.0885e-42],\n", + " [2.8462e-09, 1.2309e-18, 3.9580e-19, 4.9264e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "967000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3354e-20, 5.1596e-42, 1.8273e-42, 2.8811e-42],\n", + " [2.7308e-09, 1.2023e-18, 3.7931e-19, 4.7430e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "968000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6586e-20, 5.5744e-42, 2.1272e-42, 3.3015e-42],\n", + " [3.0392e-09, 1.2462e-18, 4.1253e-19, 5.1042e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "969000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.3808e-20, 5.1161e-42, 1.8343e-42, 2.8867e-42],\n", + " [2.7726e-09, 1.1984e-18, 3.8061e-19, 4.7544e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "970000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.0567e-20, 4.4968e-42, 1.4714e-42, 2.3640e-42],\n", + " [2.4215e-09, 1.1272e-18, 3.3662e-19, 4.2651e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "971000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.8943e-20, 5.7145e-42, 2.2883e-42, 3.5201e-42],\n", + " [3.2484e-09, 1.2675e-18, 4.3300e-19, 5.3237e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "972000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7076e-20, 5.3810e-42, 2.0795e-42, 3.2258e-42],\n", + " [3.0793e-09, 1.2317e-18, 4.1048e-19, 5.0769e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "973000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7982e-20, 5.4202e-42, 2.1328e-42, 3.2973e-42],\n", + " [3.1554e-09, 1.2352e-18, 4.1610e-19, 5.1354e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "974000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5817e-20, 5.0587e-42, 1.9044e-42, 2.9750e-42],\n", + " [2.9551e-09, 1.1953e-18, 3.9063e-19, 4.8555e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "975000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.1251e-20, 4.3875e-42, 1.4714e-42, 2.3570e-42],\n", + " [2.4952e-09, 1.1206e-18, 3.3955e-19, 4.2937e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "976000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[2.0214e-20, 5.5309e-42, 2.2729e-42, 3.4850e-42],\n", + " [3.3455e-09, 1.2504e-18, 4.3362e-19, 5.3199e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "977000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.8115e-20, 5.2044e-42, 2.0585e-42, 3.1866e-42],\n", + " [3.1624e-09, 1.2147e-18, 4.1042e-19, 5.0664e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "978000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6305e-20, 4.9130e-42, 1.8749e-42, 2.9259e-42],\n", + " [2.9962e-09, 1.1818e-18, 3.8953e-19, 4.8370e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "979000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5988e-20, 4.7952e-42, 1.8189e-42, 2.8432e-42],\n", + " [2.9624e-09, 1.1679e-18, 3.8280e-19, 4.7605e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "980000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.2385e-20, 4.2992e-42, 1.4952e-42, 2.3836e-42],\n", + " [2.6097e-09, 1.1120e-18, 3.4443e-19, 4.3391e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "981000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2842e-20, 4.2922e-42, 1.5120e-42, 2.4046e-42],\n", + " [2.6530e-09, 1.1105e-18, 3.4641e-19, 4.3587e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "982000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5430e-20, 4.5780e-42, 1.7180e-42, 2.6975e-42],\n", + " [2.9084e-09, 1.1471e-18, 3.7318e-19, 4.6528e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "983000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.5868e-20, 4.5710e-42, 1.7320e-42, 2.7157e-42],\n", + " [2.9455e-09, 1.1458e-18, 3.7475e-19, 4.6678e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "984000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4002e-20, 4.3426e-42, 1.5835e-42, 2.5041e-42],\n", + " [2.7745e-09, 1.1217e-18, 3.5857e-19, 4.4893e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "985000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.0386e-20, 3.7877e-42, 1.2486e-42, 2.0193e-42],\n", + " [2.3868e-09, 1.0518e-18, 3.1412e-19, 3.9948e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "986000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4470e-20, 4.2712e-42, 1.5751e-42, 2.4873e-42],\n", + " [2.8120e-09, 1.1119e-18, 3.5732e-19, 4.4712e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "987000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1343e-20, 3.8255e-42, 1.2990e-42, 2.0893e-42],\n", + " [2.4877e-09, 1.0557e-18, 3.2098e-19, 4.0677e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "988000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.1701e-20, 3.8087e-42, 1.3074e-42, 2.0991e-42],\n", + " [2.5224e-09, 1.0530e-18, 3.2200e-19, 4.0769e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "989000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[9.3613e-21, 3.4360e-42, 1.0930e-42, 1.7867e-42],\n", + " [2.2540e-09, 1.0030e-18, 2.9155e-19, 3.7346e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------\n", + "990000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[2.1286e-20, 4.8107e-42, 2.0291e-42, 3.1193e-42],\n", + " [3.4052e-09, 1.1802e-18, 4.1374e-19, 5.0815e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "991000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.4473e-20, 4.0385e-42, 1.4924e-42, 2.3626e-42],\n", + " [2.8044e-09, 1.0868e-18, 3.4882e-19, 4.3715e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "992000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3662e-20, 3.8802e-42, 1.4069e-42, 2.2365e-42],\n", + " [2.7206e-09, 1.0661e-18, 3.3738e-19, 4.2431e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "993000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.7481e-20, 4.2053e-42, 1.6577e-42, 2.5910e-42],\n", + " [3.0704e-09, 1.1061e-18, 3.6945e-19, 4.5922e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "994000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.3217e-20, 3.7653e-42, 1.3509e-42, 2.1552e-42],\n", + " [2.6761e-09, 1.0543e-18, 3.3140e-19, 4.1760e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "995000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6142e-20, 4.0287e-42, 1.5484e-42, 2.4341e-42],\n", + " [2.9528e-09, 1.0876e-18, 3.5724e-19, 4.4585e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "996000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.6227e-20, 3.9825e-42, 1.5330e-42, 2.4102e-42],\n", + " [2.9566e-09, 1.0812e-18, 3.5516e-19, 4.4336e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "997000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.4828e-20, 3.8480e-42, 1.4419e-42, 2.2813e-42],\n", + " [2.8344e-09, 1.0675e-18, 3.4530e-19, 4.3254e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "998000 actions: tensor([0, 0, 0])\n", + "loss= tensor(2.5390, grad_fn=) , return= 15972.328125\n", + "discReturns/1000= tensor([14.3918, 10.3106, 5.4945])\n", + "actionProbs tensor([[1.5259e-20, 3.8494e-42, 1.4559e-42, 2.3009e-42],\n", + " [2.8719e-09, 1.0671e-18, 3.4713e-19, 4.3440e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "999000 actions: tensor([0, 0, 2])\n", + "loss= tensor(2.5372, grad_fn=) , return= 15968.328125\n", + "discReturns/1000= tensor([14.3886, 10.3070, 5.4905])\n", + "actionProbs tensor([[1.2672e-20, 3.5201e-42, 1.2500e-42, 2.0039e-42],\n", + " [2.6142e-09, 1.0230e-18, 3.1891e-19, 4.0304e-19],\n", + " [1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " grad_fn=)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['learning'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['loss'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.00200.00
1203.50196.50
2205.25194.75
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.00 200.00\n", + "1 203.50 196.50\n", + "2 205.25 194.75" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 15972.328125\n", + "1 11926.328125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05112.2500004160.250000
15365.5625003937.562500
25494.5156253828.515625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5112.250000 4160.250000\n", + "1 5365.562500 3937.562500\n", + "2 5494.515625 3828.515625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0128.500135.500
1130.250133.750
2131.125132.875
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 128.500 135.500\n", + "1 130.250 133.750\n", + "2 131.125 132.875" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning['entry'],loss['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/naive_policy_gradient/test/test4.ipynb b/learningAgents/naive_policy_gradient/test/test4.ipynb new file mode 100644 index 0000000..c0669f6 --- /dev/null +++ b/learningAgents/naive_policy_gradient/test/test4.ipynb @@ -0,0 +1,4669 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from learningAgents import ReinforceAlgorithm\n", + "from environmentModel import Model, AdversaryModes\n", + "from NeuralNetwork import NeuralNetwork\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adversaryProbs=torch.zeros(len(AdversaryModes))\n", + "adversaryProbs[0]=1\n", + "adversaryProbs[1]=0\n", + "adversaryProbs[8]=0\n", + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 3, adversaryProbs=adversaryProbs, advHistoryNum=0)\n", + "adversaryProbs" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "neuralNet=NeuralNetwork(num_input=3+game.advHistoryNum, lr=0.0009,num_actions=4)\n", + "algorithm = ReinforceAlgorithm(game, neuralNet, numberIterations=1, numberEpisodes=500_000, discountFactor =0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.2586, 0.2267, 0.2415, 0.2732], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2533, 0.2339, 0.2419, 0.2709], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2527, 0.2385, 0.2395, 0.2692], grad_fn=)\n", + "--------------------------------------------------\n", + "0 actions: tensor([2, 0, 1])\n", + "loss= tensor(8.5116, grad_fn=) , return= 16077.953125\n", + "discReturns/1000= tensor([6.4173, 6.5452, 5.5306])\n", + "actionProbs tensor([[0.3393, 0.3253, 0.3351, 0.3369],\n", + " [0.3313, 0.3346, 0.3347, 0.3331],\n", + " [0.3294, 0.3401, 0.3302, 0.3299]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1817, 0.2163, 0.2985, 0.3034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2524, 0.2462, 0.2377, 0.2637], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3150, 0.2631, 0.1929, 0.2290], grad_fn=)\n", + "--------------------------------------------------\n", + "1000 actions: tensor([3, 0, 1])\n", + "loss= tensor(8.1034, grad_fn=) , return= 16128.5\n", + "discReturns/1000= tensor([6.4204, 6.5859, 5.5493])\n", + "actionProbs tensor([[0.2481, 0.3045, 0.4168, 0.3884],\n", + " [0.3336, 0.3355, 0.3213, 0.3267],\n", + " [0.4182, 0.3600, 0.2619, 0.2849]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1334, 0.2362, 0.3270, 0.3034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2938, 0.2644, 0.2113, 0.2305], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3979, 0.2562, 0.1596, 0.1863], grad_fn=)\n", + "--------------------------------------------------\n", + "2000 actions: tensor([1, 2, 0])\n", + "loss= tensor(8.1663, grad_fn=) , return= 16097.0625\n", + "discReturns/1000= tensor([6.4144, 6.5158, 5.5876])\n", + "actionProbs tensor([[0.2371, 0.4195, 0.5818, 0.5352],\n", + " [0.3511, 0.3156, 0.2528, 0.2734],\n", + " [0.4118, 0.2649, 0.1654, 0.1913]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1264, 0.3190, 0.3194, 0.2352], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2714, 0.2118, 0.2268, 0.2900], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3312, 0.1451, 0.1824, 0.3413], grad_fn=)\n", + "--------------------------------------------------\n", + "3000 actions: tensor([1, 2, 3])\n", + "loss= tensor(7.7956, grad_fn=) , return= 16088.0625\n", + "discReturns/1000= tensor([6.4140, 6.5140, 5.5786])\n", + "actionProbs tensor([[0.2283, 0.5553, 0.5223, 0.3443],\n", + " [0.3600, 0.2707, 0.2723, 0.3118],\n", + " [0.4118, 0.1740, 0.2054, 0.3440]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2482, 0.2621, 0.2458, 0.2438], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0078, 0.5132, 0.1748, 0.3042], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2996e-04, 6.7104e-01, 1.0558e-01, 2.2274e-01],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "4000 actions: tensor([2, 3, 1])\n", + "loss= tensor(6.2015, grad_fn=) , return= 16181.078125\n", + "discReturns/1000= tensor([6.4200, 6.5586, 5.6428])\n", + "actionProbs tensor([[9.9646e-01, 7.5082e-01, 9.1119e-01, 8.4861e-01],\n", + " [3.4226e-03, 1.6053e-01, 7.0757e-02, 1.1563e-01],\n", + " [1.1663e-04, 8.8657e-02, 1.8050e-02, 3.5764e-02]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.6987, 0.0778, 0.1138, 0.1097], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2867, 0.1874, 0.2457, 0.2802], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0299, 0.3304, 0.2827, 0.3570], grad_fn=)\n", + "--------------------------------------------------\n", + "5000 actions: tensor([0, 3, 2])\n", + "loss= tensor(7.0283, grad_fn=) , return= 16071.078125\n", + "discReturns/1000= tensor([6.4077, 6.4770, 5.6023])\n", + "actionProbs tensor([[0.9024, 0.4797, 0.5484, 0.4976],\n", + " [0.0932, 0.2908, 0.2981, 0.3200],\n", + " [0.0043, 0.2295, 0.1535, 0.1824]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.4281, 0.1196, 0.1586, 0.2937], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2674, 0.1681, 0.2319, 0.3326], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1276, 0.2072, 0.3222, 0.3430], grad_fn=)\n", + "--------------------------------------------------\n", + "6000 actions: tensor([2, 3, 3])\n", + "loss= tensor(9.3096, grad_fn=) , return= 16173.078125\n", + "discReturns/1000= tensor([6.4197, 6.5570, 5.6348])\n", + "actionProbs tensor([[0.5192, 0.2342, 0.2148, 0.2960],\n", + " [0.3081, 0.3128, 0.2983, 0.3183],\n", + " [0.1727, 0.4529, 0.4869, 0.3857]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3398, 0.1476, 0.1862, 0.3263], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2662, 0.1662, 0.2260, 0.3416], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1597, 0.1825, 0.2953, 0.3625], grad_fn=)\n", + "--------------------------------------------------\n", + "7000 actions: tensor([3, 1, 2])\n", + "loss= tensor(8.3283, grad_fn=) , return= 16161.8125\n", + "discReturns/1000= tensor([6.4216, 6.5917, 5.5836])\n", + "actionProbs tensor([[0.4162, 0.2694, 0.2361, 0.2880],\n", + " [0.3417, 0.3180, 0.3004, 0.3160],\n", + " [0.2421, 0.4126, 0.4635, 0.3960]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0036, 0.0059, 0.0867, 0.9037], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0407, 0.0646, 0.2431, 0.6516], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1662, 0.3718, 0.2997, 0.1622], grad_fn=)\n", + "--------------------------------------------------\n", + "8000 actions: tensor([3, 3, 0])\n", + "loss= tensor(3.7994, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[0.0040, 0.0030, 0.0450, 0.3491],\n", + " [0.0600, 0.0434, 0.1674, 0.3337],\n", + " [0.9360, 0.9536, 0.7876, 0.3171]], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4876e-05, 9.3187e-04, 8.7202e-03, 9.9030e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0129, 0.0520, 0.1422, 0.7930], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3535, 0.3230, 0.2566, 0.0670], grad_fn=)\n", + "--------------------------------------------------\n", + "9000 actions: tensor([3, 3, 0])\n", + "loss= tensor(2.6147, grad_fn=) , return= 16232.8125\n", + "discReturns/1000= tensor([6.4232, 6.5995, 5.6626])\n", + "actionProbs tensor([[6.3213e-06, 1.4238e-04, 1.6296e-03, 2.8665e-01],\n", + " [2.5665e-03, 1.1246e-02, 3.7628e-02, 3.2510e-01],\n", + " [9.9743e-01, 9.8861e-01, 9.6074e-01, 3.8824e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5217e-05, 3.0186e-04, 5.6817e-03, 9.9400e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0118, 0.0418, 0.1364, 0.8100], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3650, 0.3637, 0.2124, 0.0588], grad_fn=)\n", + "--------------------------------------------------\n", + "10000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.9327, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[8.9273e-06, 1.7587e-04, 5.2892e-03, 5.6887e-01],\n", + " [4.1136e-03, 1.4426e-02, 7.5196e-02, 2.7456e-01],\n", + " [9.9588e-01, 9.8540e-01, 9.1952e-01, 1.5657e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2717e-05, 9.0861e-04, 2.7069e-03, 9.9635e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0107, 0.0507, 0.0994, 0.8392], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2628, 0.2863, 0.3678, 0.0831], grad_fn=)\n", + "--------------------------------------------------\n", + "11000 actions: tensor([3, 3, 1])\n", + "loss= tensor(2.6499, grad_fn=) , return= 16231.8125\n", + "discReturns/1000= tensor([6.4231, 6.5993, 5.6616])\n", + "actionProbs tensor([[2.2516e-05, 5.6284e-04, 1.2880e-03, 4.7417e-01],\n", + " [5.6598e-03, 2.4260e-02, 3.6513e-02, 3.0839e-01],\n", + " [9.9432e-01, 9.7518e-01, 9.6220e-01, 2.1744e-01]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.8378e-05, 6.0701e-04, 2.0308e-03, 9.9734e-01],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.0076, 0.0434, 0.0840, 0.8649], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2351, 0.3016, 0.3613, 0.1021], grad_fn=)\n", + "--------------------------------------------------\n", + "12000 actions: tensor([3, 3, 2])\n", + "loss= tensor(2.6850, grad_fn=) , return= 16228.8125\n", + "discReturns/1000= tensor([6.4230, 6.5987, 5.6586])\n", + "actionProbs tensor([[1.8482e-05, 4.6682e-04, 1.2835e-03, 4.8667e-01],\n", + " [5.5341e-03, 2.4013e-02, 3.8230e-02, 3.0380e-01],\n", + " [9.9445e-01, 9.7552e-01, 9.6049e-01, 2.0953e-01]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3697, 0.4972, 0.1120, 0.0211], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2470e-01, 8.7203e-01, 3.2162e-03, 4.9112e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0515e-02, 9.4913e-01, 3.5373e-04, 1.1714e-06],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "13000 actions: tensor([1, 0, 1])\n", + "loss= tensor(7.0830, grad_fn=) , return= 16025.5625\n", + "discReturns/1000= tensor([6.4122, 6.5047, 5.5121])\n", + "actionProbs tensor([[9.9718e-01, 9.8445e-01, 9.9977e-01, 9.9998e-01],\n", + " [2.7010e-03, 1.3865e-02, 2.3050e-04, 1.8725e-05],\n", + " [1.2197e-04, 1.6822e-03, 2.8261e-06, 4.9786e-08]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3182, 0.5391, 0.1194, 0.0233], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5509e-03, 9.9830e-01, 1.4989e-04, 1.8189e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1629e-05, 9.9995e-01, 2.5145e-06, 5.5513e-09],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "14000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9848, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[9.9998e-01, 9.9152e-01, 9.9999e-01, 1.0000e+00],\n", + " [2.0585e-05, 7.7546e-03, 5.2999e-06, 3.3008e-07],\n", + " [6.3944e-08, 7.2479e-04, 8.2962e-09, 9.3999e-11]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3036, 0.5525, 0.1215, 0.0224], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2539e-04, 9.9963e-01, 4.1779e-05, 4.9783e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8154e-06, 9.9999e-01, 4.2360e-07, 9.7779e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "15000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9711, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9643e-01, 1.0000e+00, 1.0000e+00],\n", + " [1.9819e-06, 3.3333e-03, 6.3567e-07, 4.1076e-08],\n", + " [2.5657e-09, 2.4154e-04, 4.6686e-10, 5.8440e-12]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2998, 0.5370, 0.1414, 0.0217], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3903e-04, 9.9984e-01, 2.3061e-05, 2.4225e-07],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8420e-06, 1.0000e+00, 1.7909e-07, 3.8110e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "16000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9668, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9851e-01, 1.0000e+00, 1.0000e+00],\n", + " [3.5205e-07, 1.4113e-03, 1.2378e-07, 8.4585e-09],\n", + " [2.5367e-10, 7.6768e-05, 5.2276e-11, 7.2368e-13]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3207, 0.5181, 0.1460, 0.0152], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3543e-05, 9.9991e-01, 1.2442e-05, 9.3556e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5673e-07, 1.0000e+00, 7.5506e-08, 1.1750e-10],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "17000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9652, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9928e-01, 1.0000e+00, 1.0000e+00],\n", + " [8.2480e-08, 6.9354e-04, 3.0638e-08, 2.2169e-09],\n", + " [3.6713e-11, 3.0005e-05, 8.0429e-12, 1.2045e-13]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.3383, 0.4909, 0.1582, 0.0127], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8787e-05, 9.9995e-01, 6.9842e-06, 4.2598e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0504e-07, 1.0000e+00, 3.2688e-08, 4.1895e-11],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "18000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9645, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9955e-01, 1.0000e+00, 1.0000e+00],\n", + " [2.4289e-08, 4.3134e-04, 9.3548e-09, 7.1231e-10],\n", + " [7.2215e-12, 1.6308e-05, 1.6553e-12, 2.6486e-14]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1905, 0.7251, 0.0794, 0.0051], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9574e-05, 9.9997e-01, 1.4276e-06, 1.8202e-08],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1287e-07, 1.0000e+00, 3.5025e-09, 1.5485e-11],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "19000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9647, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9951e-01, 1.0000e+00, 1.0000e+00],\n", + " [5.3153e-08, 4.7185e-04, 6.1542e-09, 1.2312e-09],\n", + " [1.3510e-11, 1.6663e-05, 5.3320e-13, 3.6991e-14]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1986, 0.7299, 0.0673, 0.0042], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8482e-06, 1.0000e+00, 2.6069e-07, 4.6258e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5360e-09, 1.0000e+00, 2.6356e-10, 1.9015e-12],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "20000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9638, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 9.9995e-01, 1.0000e+00, 1.0000e+00],\n", + " [3.3424e-10, 4.9210e-05, 1.3919e-10, 3.9621e-11],\n", + " [7.4174e-15, 5.7078e-07, 1.6322e-15, 1.8890e-16]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1972, 0.7426, 0.0568, 0.0035], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9374e-07, 1.0000e+00, 7.9414e-08, 1.4723e-09],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0885e-10, 1.0000e+00, 4.1539e-11, 3.1162e-13],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "21000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 9.9999e-01, 1.0000e+00, 1.0000e+00],\n", + " [2.3388e-11, 1.2577e-05, 1.3068e-11, 3.9356e-12],\n", + " [1.4395e-16, 7.5111e-08, 4.0825e-17, 4.9747e-18]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2287, 0.7100, 0.0577, 0.0036], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1899e-07, 1.0000e+00, 3.2236e-08, 6.1867e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4805e-10, 1.0000e+00, 1.0156e-11, 7.8457e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "22000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.3540e-12, 4.9339e-06, 1.9585e-12, 5.9801e-13],\n", + " [9.0227e-18, 1.9633e-08, 2.4552e-18, 3.0177e-19]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([0.2510, 0.6890, 0.0567, 0.0033], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0986e-07, 1.0000e+00, 1.4619e-08, 2.6538e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1433e-11, 1.0000e+00, 2.8927e-12, 2.0861e-14],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "23000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [7.5219e-13, 2.4944e-06, 4.4320e-13, 1.3669e-13],\n", + " [1.0287e-18, 7.2863e-09, 2.5616e-19, 3.1387e-20]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2543, 0.6870, 0.0556, 0.0031], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7060e-08, 1.0000e+00, 7.5801e-09, 1.3230e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9835e-11, 1.0000e+00, 1.0288e-12, 7.0488e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "24000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8796e-13, 1.2191e-06, 1.1417e-13, 3.5628e-14],\n", + " [1.3766e-19, 2.5685e-09, 3.2646e-20, 3.9993e-21]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2706, 0.6732, 0.0517, 0.0045], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2764e-08, 1.0000e+00, 3.8387e-09, 1.0760e-10],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1982e-12, 1.0000e+00, 3.3819e-13, 3.6984e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "25000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.5756e-14, 6.8400e-07, 3.4187e-14, 1.1091e-14],\n", + " [2.1841e-20, 1.0708e-09, 4.7151e-21, 5.9682e-22]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2393, 0.7125, 0.0448, 0.0034], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0036e-08, 1.0000e+00, 2.4947e-09, 6.1273e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6171e-12, 1.0000e+00, 2.0062e-13, 1.9072e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "26000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9218e-14, 3.2208e-07, 1.2767e-14, 4.1169e-15],\n", + " [5.0811e-21, 3.6954e-10, 1.1780e-21, 1.4703e-22]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.2369, 0.7325, 0.0286, 0.0020], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7278e-08, 1.0000e+00, 1.5155e-09, 3.3104e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8506e-12, 1.0000e+00, 1.1481e-13, 9.5265e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "27000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [8.5239e-15, 1.5954e-07, 6.1895e-15, 1.9765e-15],\n", + " [1.5847e-21, 1.3308e-10, 3.9114e-22, 4.7447e-23]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([0.1775, 0.8058, 0.0157, 0.0010], grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0847e-08, 1.0000e+00, 7.4647e-10, 1.4703e-11],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2394e-12, 1.0000e+00, 4.9859e-14, 3.6364e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "28000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2649e-15, 8.6615e-08, 3.3111e-15, 1.0544e-15],\n", + " [5.3176e-22, 5.2308e-11, 1.3356e-22, 1.5748e-23]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1566e-01, 8.7251e-01, 1.1127e-02, 6.9700e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5685e-09, 1.0000e+00, 4.9123e-10, 9.7605e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3417e-12, 1.0000e+00, 3.2383e-14, 2.3767e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "29000 actions: tensor([0, 1, 1])\n", + "loss= tensor(2.9604, grad_fn=) , return= 16007.453125\n", + "discReturns/1000= tensor([6.4064, 6.4707, 5.5306])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1695e-15, 4.3784e-08, 1.6866e-15, 5.3497e-16],\n", + " [1.9010e-22, 1.8783e-11, 4.7697e-23, 5.5883e-24]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5606e-02, 9.0454e-01, 9.1949e-03, 6.5668e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6807e-09, 1.0000e+00, 3.5039e-10, 7.6765e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8114e-13, 1.0000e+00, 2.3749e-14, 1.9406e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "30000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1057e-15, 2.2356e-08, 7.7059e-16, 2.3639e-16],\n", + " [7.3431e-23, 7.0831e-12, 1.6548e-23, 1.8933e-24]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6920e-02, 9.3530e-01, 7.1973e-03, 5.8179e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0711e-09, 1.0000e+00, 2.4896e-10, 6.0438e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2358e-13, 1.0000e+00, 1.6418e-14, 1.4798e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "31000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1040e-16, 1.2096e-08, 3.9133e-16, 1.1752e-16],\n", + " [2.7940e-23, 2.7268e-12, 5.8176e-24, 6.4870e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6236e-02, 9.5781e-01, 5.4622e-03, 4.9332e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9294e-09, 1.0000e+00, 1.7680e-10, 4.7449e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7823e-13, 1.0000e+00, 1.1446e-14, 1.1367e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "32000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.2512e-16, 6.3751e-09, 1.9764e-16, 5.8731e-17],\n", + " [1.0084e-23, 1.0087e-12, 2.0245e-24, 2.2260e-25]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2445e-02, 9.7299e-01, 4.1493e-03, 4.1741e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1523e-09, 1.0000e+00, 1.2314e-10, 3.6802e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1408e-13, 1.0000e+00, 7.7025e-15, 8.5867e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "33000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.8553e-16, 3.7141e-09, 1.0725e-16, 3.1862e-17],\n", + " [3.9733e-24, 4.2814e-13, 7.7330e-25, 8.5693e-26]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.3699e-02, 9.8299e-01, 2.9732e-03, 3.3332e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8968e-10, 1.0000e+00, 8.4996e-11, 2.9097e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2317e-13, 1.0000e+00, 5.2250e-15, 6.8599e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "34000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.0025e-16, 2.0257e-09, 5.6925e-17, 1.7383e-17],\n", + " [1.4567e-24, 1.6482e-13, 2.8472e-25, 3.3344e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5300e-03, 9.9018e-01, 2.0273e-03, 2.5946e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6582e-10, 1.0000e+00, 5.3643e-11, 2.1657e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1696e-14, 1.0000e+00, 3.1936e-15, 5.1250e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "35000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1553e-17, 1.2796e-09, 3.3525e-17, 1.0576e-17],\n", + " [6.3323e-25, 7.8050e-14, 1.2175e-25, 1.5265e-26]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1973e-03, 9.9279e-01, 1.7551e-03, 2.5455e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1528e-10, 1.0000e+00, 5.9251e-11, 2.8249e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7870e-14, 1.0000e+00, 4.0557e-15, 7.9765e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "36000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0994e-17, 6.8067e-10, 2.2813e-17, 7.4994e-18],\n", + " [3.1642e-25, 2.8624e-14, 6.5669e-26, 8.9050e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9267e-03, 9.9566e-01, 1.2145e-03, 1.9928e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6421e-10, 1.0000e+00, 3.7780e-11, 2.1187e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8044e-14, 1.0000e+00, 2.4962e-15, 5.9901e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "37000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3986e-17, 4.2937e-10, 1.3299e-17, 4.5452e-18],\n", + " [1.2932e-25, 1.3555e-14, 2.7740e-26, 4.0568e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4849e-03, 9.9765e-01, 7.2241e-04, 1.3922e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4091e-11, 1.0000e+00, 1.3612e-11, 9.8666e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1952e-15, 1.0000e+00, 6.9753e-16, 2.3141e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "38000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.2673e-17, 3.4871e-10, 6.5552e-18, 2.4656e-18],\n", + " [4.6326e-26, 9.5829e-15, 9.2312e-27, 1.5892e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3101e-03, 9.9767e-01, 8.4527e-04, 1.7901e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7293e-11, 1.0000e+00, 2.7787e-11, 2.2622e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3089e-14, 1.0000e+00, 1.9747e-15, 7.5382e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "39000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.0597e-17, 1.8003e-10, 5.9046e-18, 2.2697e-18],\n", + " [3.3695e-26, 3.3805e-15, 7.8789e-27, 1.4202e-27]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8588e-04, 9.9900e-01, 4.1200e-04, 1.0480e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7074e-11, 1.0000e+00, 7.5580e-12, 7.8085e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1387e-15, 1.0000e+00, 4.0687e-16, 2.0817e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "40000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [6.1889e-18, 1.7629e-10, 3.2308e-18, 1.3122e-18],\n", + " [1.3898e-26, 3.1605e-15, 3.1180e-27, 6.2713e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0990e-04, 9.9903e-01, 4.3681e-04, 1.1960e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1737e-11, 1.0000e+00, 1.2825e-11, 1.4480e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4031e-15, 1.0000e+00, 9.3137e-16, 5.3288e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "41000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.3406e-18, 1.0081e-10, 2.9569e-18, 1.2193e-18],\n", + " [1.0987e-26, 1.3246e-15, 2.8216e-27, 5.8963e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4064e-04, 9.9934e-01, 3.0372e-04, 1.1202e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6588e-12, 1.0000e+00, 3.6420e-12, 6.8190e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0277e-16, 1.0000e+00, 1.5348e-16, 1.6749e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "42000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9000e-18, 8.0850e-11, 9.6885e-19, 4.9184e-19],\n", + " [1.6343e-27, 7.8275e-16, 3.9528e-28, 1.1696e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8178e-04, 9.9945e-01, 2.6597e-04, 1.0324e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8803e-12, 1.0000e+00, 4.5437e-12, 8.9914e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8361e-16, 1.0000e+00, 2.6232e-16, 3.0829e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "43000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.7176e-18, 5.3125e-11, 9.0706e-19, 4.6242e-19],\n", + " [1.7358e-27, 4.6183e-16, 4.5523e-28, 1.3783e-28]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.5037e-04, 9.9951e-01, 2.4435e-04, 9.8391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7690e-12, 1.0000e+00, 5.9524e-12, 1.2235e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0255e-15, 1.0000e+00, 4.6344e-16, 5.7392e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "44000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.5880e-18, 3.5295e-11, 8.5936e-19, 4.3866e-19],\n", + " [1.8794e-27, 2.7572e-16, 5.2266e-28, 1.6075e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3897e-04, 9.9952e-01, 2.4183e-04, 9.9783e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6783e-12, 1.0000e+00, 8.3102e-12, 1.7513e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6344e-15, 1.0000e+00, 8.3137e-16, 1.0685e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "45000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.4949e-18, 2.3949e-11, 8.2259e-19, 4.2013e-19],\n", + " [1.8783e-27, 1.5978e-16, 5.4903e-28, 1.7102e-28]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7100e-04, 9.9931e-01, 3.6235e-04, 1.5864e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0651e-12, 1.0000e+00, 3.5875e-12, 7.5840e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8209e-16, 1.0000e+00, 1.6320e-16, 2.0493e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "46000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [5.2062e-19, 2.1916e-11, 2.1683e-19, 1.0470e-19],\n", + " [2.2877e-28, 1.0246e-16, 4.6113e-29, 1.3226e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3093e-04, 9.9945e-01, 2.9096e-04, 1.2960e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5180e-12, 1.0000e+00, 3.2933e-12, 7.0645e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8415e-16, 1.0000e+00, 1.7893e-16, 2.3057e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "47000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.8947e-19, 1.8226e-11, 2.0618e-19, 9.9295e-20],\n", + " [2.5283e-28, 8.6218e-17, 5.2990e-29, 1.5331e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0591e-04, 9.9954e-01, 2.4488e-04, 1.1067e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3339e-12, 1.0000e+00, 3.2774e-12, 7.1098e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3171e-16, 1.0000e+00, 2.1635e-16, 2.8482e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "48000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6056e-19, 1.4638e-11, 1.9582e-19, 9.3996e-20],\n", + " [2.8178e-28, 6.9162e-17, 6.1076e-29, 1.7792e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1836e-05, 9.9959e-01, 2.1929e-04, 1.0029e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4910e-12, 1.0000e+00, 3.5707e-12, 7.8113e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4168e-16, 1.0000e+00, 2.8820e-16, 3.8595e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "49000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3474e-19, 1.1441e-11, 1.8621e-19, 8.9079e-20],\n", + " [3.1279e-28, 5.3053e-17, 6.9696e-29, 2.0409e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5961e-05, 9.9961e-01, 2.1013e-04, 9.6930e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0257e-12, 1.0000e+00, 4.2387e-12, 9.3257e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4091e-16, 1.0000e+00, 4.1346e-16, 5.6113e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "50000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1360e-19, 8.8351e-12, 1.7815e-19, 8.4970e-20],\n", + " [3.3531e-28, 3.8918e-17, 7.6544e-29, 2.2521e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6876e-05, 9.9960e-01, 2.1569e-04, 1.0005e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0597e-12, 1.0000e+00, 5.4333e-12, 1.2000e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0691e-15, 1.0000e+00, 6.1952e-16, 8.4960e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "51000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9729e-19, 6.8243e-12, 1.7183e-19, 8.1818e-20],\n", + " [3.3263e-28, 2.7039e-17, 7.7632e-29, 2.2953e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0607e-05, 9.9958e-01, 2.2777e-04, 1.0611e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5486e-12, 1.0000e+00, 7.1428e-12, 1.5822e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5769e-15, 1.0000e+00, 9.4119e-16, 1.3012e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "52000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8407e-19, 5.3162e-12, 1.6665e-19, 7.9236e-20],\n", + " [3.2933e-28, 1.8931e-17, 7.8196e-29, 2.3205e-29]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1508e-05, 9.9975e-01, 1.1844e-04, 9.3568e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1663e-13, 1.0000e+00, 1.6288e-13, 1.0591e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1825e-18, 1.0000e+00, 4.3018e-18, 2.3474e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "53000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.9527e-20, 1.0511e-11, 1.4452e-20, 1.1895e-20],\n", + " [4.8520e-30, 3.8872e-17, 1.4115e-30, 9.7495e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([3.3723e-05, 9.9979e-01, 9.8618e-05, 7.8933e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1077e-13, 1.0000e+00, 1.5952e-13, 1.0467e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2282e-18, 1.0000e+00, 5.4193e-18, 3.0158e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "54000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.7200e-20, 8.2827e-12, 1.3394e-20, 1.0981e-20],\n", + " [6.0963e-30, 3.3016e-17, 1.8139e-30, 1.2612e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0493e-05, 9.9981e-01, 9.0659e-05, 7.3363e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2102e-13, 1.0000e+00, 1.7794e-13, 1.1774e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2069e-18, 1.0000e+00, 7.4194e-18, 4.1953e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "55000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.5698e-20, 6.4765e-12, 1.2709e-20, 1.0392e-20],\n", + " [6.8995e-30, 2.5640e-17, 2.0979e-30, 1.4660e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9635e-05, 9.9981e-01, 8.9362e-05, 7.3031e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4451e-13, 1.0000e+00, 2.1626e-13, 1.4426e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1495e-17, 1.0000e+00, 1.0715e-17, 6.1373e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "56000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.4626e-20, 5.0510e-12, 1.2221e-20, 9.9752e-21],\n", + " [7.3764e-30, 1.9020e-17, 2.2802e-30, 1.5981e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0075e-05, 9.9980e-01, 9.1933e-05, 7.5801e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8058e-13, 1.0000e+00, 2.7474e-13, 1.8468e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6533e-17, 1.0000e+00, 1.5789e-17, 9.1363e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "57000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3837e-20, 3.9708e-12, 1.1865e-20, 9.6724e-21],\n", + " [7.6707e-30, 1.3956e-17, 2.3965e-30, 1.6818e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1326e-05, 9.9979e-01, 9.6814e-05, 8.0391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2950e-13, 1.0000e+00, 3.5386e-13, 2.3934e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3738e-17, 1.0000e+00, 2.3117e-17, 1.3486e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "58000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.3243e-20, 3.1733e-12, 1.1596e-20, 9.4458e-21],\n", + " [7.8112e-30, 1.0310e-17, 2.4613e-30, 1.7293e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3119e-05, 9.9978e-01, 1.0313e-04, 8.6070e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9159e-13, 1.0000e+00, 4.5381e-13, 3.0836e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3418e-17, 1.0000e+00, 3.3068e-17, 1.9421e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "59000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2794e-20, 2.5895e-12, 1.1392e-20, 9.2751e-21],\n", + " [7.8004e-30, 7.7323e-18, 2.4788e-30, 1.7444e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5152e-05, 9.9976e-01, 1.1008e-04, 9.2242e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6534e-13, 1.0000e+00, 5.7263e-13, 3.9050e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5727e-17, 1.0000e+00, 4.5846e-17, 2.7076e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "60000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2439e-20, 2.1595e-12, 1.1230e-20, 9.1397e-21],\n", + " [7.7311e-30, 5.9445e-18, 2.4751e-30, 1.7445e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7201e-05, 9.9975e-01, 1.1706e-04, 9.8419e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4838e-13, 1.0000e+00, 7.0698e-13, 4.8360e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0693e-17, 1.0000e+00, 6.1530e-17, 3.6509e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "61000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.2140e-20, 1.8373e-12, 1.1093e-20, 9.0256e-21],\n", + " [7.6722e-30, 4.7038e-18, 2.4718e-30, 1.7445e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9207e-05, 9.9973e-01, 1.2387e-04, 1.0445e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3938e-13, 1.0000e+00, 8.5476e-13, 5.8624e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8274e-17, 1.0000e+00, 8.0113e-17, 4.7731e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "62000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1882e-20, 1.5910e-12, 1.0975e-20, 8.9273e-21],\n", + " [7.6199e-30, 3.8178e-18, 2.4684e-30, 1.7441e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1149e-05, 9.9972e-01, 1.3048e-04, 1.1030e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3723e-13, 1.0000e+00, 1.0144e-12, 6.9729e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8411e-17, 1.0000e+00, 1.0157e-16, 6.0729e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "63000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1661e-20, 1.3992e-12, 1.0874e-20, 8.8429e-21],\n", + " [7.5768e-30, 3.1690e-18, 2.4663e-30, 1.7444e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([4.3010e-05, 9.9970e-01, 1.3682e-04, 1.1592e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4081e-13, 1.0000e+00, 1.1840e-12, 8.1555e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2097e-16, 1.0000e+00, 1.2580e-16, 7.5451e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "64000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1463e-20, 1.2465e-12, 1.0783e-20, 8.7668e-21],\n", + " [7.5362e-30, 2.6801e-18, 2.4635e-30, 1.7439e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4782e-05, 9.9969e-01, 1.4285e-04, 1.2127e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4920e-13, 1.0000e+00, 1.3618e-12, 9.3972e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4584e-16, 1.0000e+00, 1.5266e-16, 9.1813e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "65000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1286e-20, 1.1228e-12, 1.0701e-20, 8.6985e-21],\n", + " [7.5003e-30, 2.3037e-18, 2.4613e-30, 1.7437e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6480e-05, 9.9968e-01, 1.4863e-04, 1.2641e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6227e-13, 1.0000e+00, 1.5478e-12, 1.0698e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7305e-16, 1.0000e+00, 1.8220e-16, 1.0985e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "66000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.1133e-20, 1.0211e-12, 1.0630e-20, 8.6391e-21],\n", + " [7.4732e-30, 2.0079e-18, 2.4606e-30, 1.7443e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8127e-05, 9.9967e-01, 1.5423e-04, 1.3138e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0798e-12, 1.0000e+00, 1.7415e-12, 1.2054e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0245e-16, 1.0000e+00, 2.1427e-16, 1.2947e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "67000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0996e-20, 9.3613e-13, 1.0567e-20, 8.5859e-21],\n", + " [7.4418e-30, 1.7697e-18, 2.4577e-30, 1.7433e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9731e-05, 9.9965e-01, 1.5972e-04, 1.3626e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2018e-12, 1.0000e+00, 1.9436e-12, 1.3471e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3405e-16, 1.0000e+00, 2.4898e-16, 1.5075e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "68000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0870e-20, 8.6389e-13, 1.0509e-20, 8.5380e-21],\n", + " [7.4018e-30, 1.5732e-18, 2.4516e-30, 1.7400e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1271e-05, 9.9964e-01, 1.6501e-04, 1.4098e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3273e-12, 1.0000e+00, 2.1522e-12, 1.4938e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6772e-16, 1.0000e+00, 2.8620e-16, 1.7364e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "69000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0750e-20, 8.0180e-13, 1.0454e-20, 8.4924e-21],\n", + " [7.3621e-30, 1.4104e-18, 2.4453e-30, 1.7365e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2752e-05, 9.9963e-01, 1.7013e-04, 1.4554e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4558e-12, 1.0000e+00, 2.3667e-12, 1.6447e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0336e-16, 1.0000e+00, 3.2581e-16, 1.9805e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "70000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0634e-20, 7.4794e-13, 1.0401e-20, 8.4487e-21],\n", + " [7.3218e-30, 1.2737e-18, 2.4383e-30, 1.7326e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4191e-05, 9.9962e-01, 1.7511e-04, 1.5000e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5877e-12, 1.0000e+00, 2.5876e-12, 1.8003e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4106e-16, 1.0000e+00, 3.6798e-16, 2.2409e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "71000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0525e-20, 7.0083e-13, 1.0352e-20, 8.4083e-21],\n", + " [7.2840e-30, 1.1578e-18, 2.4320e-30, 1.7290e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5587e-05, 9.9961e-01, 1.7994e-04, 1.5432e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7230e-12, 1.0000e+00, 2.8144e-12, 1.9603e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8088e-16, 1.0000e+00, 4.1267e-16, 2.5173e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "72000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0426e-20, 6.5926e-13, 1.0307e-20, 8.3715e-21],\n", + " [7.2504e-30, 1.0586e-18, 2.4268e-30, 1.7261e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6941e-05, 9.9960e-01, 1.8464e-04, 1.5852e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8616e-12, 1.0000e+00, 3.0475e-12, 2.1249e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2289e-16, 1.0000e+00, 4.6003e-16, 2.8106e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "73000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0338e-20, 6.2232e-13, 1.0268e-20, 8.3386e-21],\n", + " [7.2228e-30, 9.7290e-19, 2.4230e-30, 1.7242e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([5.8235e-05, 9.9959e-01, 1.8916e-04, 1.6258e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0022e-12, 1.0000e+00, 3.2847e-12, 2.2927e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6664e-16, 1.0000e+00, 5.0962e-16, 3.1184e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "74000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0255e-20, 5.8940e-13, 1.0231e-20, 8.3079e-21],\n", + " [7.1973e-30, 8.9857e-19, 2.4199e-30, 1.7228e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9513e-05, 9.9958e-01, 1.9362e-04, 1.6659e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1464e-12, 1.0000e+00, 3.5287e-12, 2.4654e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1266e-16, 1.0000e+00, 5.6197e-16, 3.4439e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "75000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0179e-20, 5.5973e-13, 1.0197e-20, 8.2802e-21],\n", + " [7.1748e-30, 8.3324e-19, 2.4175e-30, 1.7218e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0760e-05, 9.9957e-01, 1.9797e-04, 1.7051e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2937e-12, 1.0000e+00, 3.7781e-12, 2.6422e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6072e-16, 1.0000e+00, 6.1683e-16, 3.7856e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "76000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0109e-20, 5.3291e-13, 1.0166e-20, 8.2544e-21],\n", + " [7.1539e-30, 7.7554e-19, 2.4153e-30, 1.7210e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1969e-05, 9.9956e-01, 2.0221e-04, 1.7433e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4431e-12, 1.0000e+00, 4.0321e-12, 2.8225e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1068e-16, 1.0000e+00, 6.7415e-16, 4.1432e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "77000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [2.0040e-20, 5.0854e-13, 1.0136e-20, 8.2301e-21],\n", + " [7.1345e-30, 7.2430e-19, 2.4137e-30, 1.7207e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3138e-05, 9.9955e-01, 2.0634e-04, 1.7805e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5944e-12, 1.0000e+00, 4.2905e-12, 3.0060e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6238e-16, 1.0000e+00, 7.3385e-16, 4.5160e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "78000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9974e-20, 4.8629e-13, 1.0107e-20, 8.2064e-21],\n", + " [7.1153e-30, 6.7852e-19, 2.4121e-30, 1.7202e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4299e-05, 9.9954e-01, 2.1043e-04, 1.8174e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7500e-12, 1.0000e+00, 4.5559e-12, 3.1946e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1663e-16, 1.0000e+00, 7.9653e-16, 4.9080e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "79000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9909e-20, 4.6571e-13, 1.0078e-20, 8.1828e-21],\n", + " [7.0966e-30, 6.3703e-19, 2.4102e-30, 1.7196e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5427e-05, 9.9953e-01, 2.1440e-04, 1.8532e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9065e-12, 1.0000e+00, 4.8230e-12, 3.3846e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7227e-16, 1.0000e+00, 8.6097e-16, 5.3113e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "80000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9847e-20, 4.4699e-13, 1.0051e-20, 8.1599e-21],\n", + " [7.0790e-30, 6.0002e-19, 2.4084e-30, 1.7189e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6548e-05, 9.9953e-01, 2.1836e-04, 1.8890e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0667e-12, 1.0000e+00, 5.0973e-12, 3.5798e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3028e-16, 1.0000e+00, 9.2836e-16, 5.7337e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "81000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9787e-20, 4.2957e-13, 1.0023e-20, 8.1369e-21],\n", + " [7.0611e-30, 5.6623e-19, 2.4062e-30, 1.7179e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7644e-05, 9.9952e-01, 2.2222e-04, 1.9239e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2291e-12, 1.0000e+00, 5.3753e-12, 3.7779e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.9012e-16, 1.0000e+00, 9.9801e-16, 6.1707e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "82000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9727e-20, 4.1344e-13, 9.9960e-21, 8.1147e-21],\n", + " [7.0423e-30, 5.3543e-19, 2.4035e-30, 1.7165e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8694e-05, 9.9951e-01, 2.2590e-04, 1.9572e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3914e-12, 1.0000e+00, 5.6529e-12, 3.9757e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5106e-16, 1.0000e+00, 1.0690e-15, 6.6166e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "83000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9669e-20, 3.9859e-13, 9.9696e-21, 8.0929e-21],\n", + " [7.0243e-30, 5.0760e-19, 2.4009e-30, 1.7152e-30]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([6.9756e-05, 9.9950e-01, 2.2961e-04, 1.9907e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5586e-12, 1.0000e+00, 5.9386e-12, 4.1793e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0148e-15, 1.0000e+00, 1.1433e-15, 7.0831e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "84000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9613e-20, 3.8465e-13, 9.9438e-21, 8.0714e-21],\n", + " [7.0071e-30, 4.8190e-19, 2.3983e-30, 1.7138e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0822e-05, 9.9949e-01, 2.3333e-04, 2.0243e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7300e-12, 1.0000e+00, 6.2320e-12, 4.3885e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0811e-15, 1.0000e+00, 1.2208e-15, 7.5705e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "85000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9558e-20, 3.7153e-13, 9.9181e-21, 8.0501e-21],\n", + " [6.9893e-30, 4.5808e-19, 2.3955e-30, 1.7123e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1818e-05, 9.9949e-01, 2.3681e-04, 2.0558e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8988e-12, 1.0000e+00, 6.5209e-12, 4.5946e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1477e-15, 1.0000e+00, 1.2986e-15, 8.0604e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "86000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9505e-20, 3.5947e-13, 9.8934e-21, 8.0297e-21],\n", + " [6.9727e-30, 4.3655e-19, 2.3928e-30, 1.7107e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2805e-05, 9.9948e-01, 2.4027e-04, 2.0872e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0704e-12, 1.0000e+00, 6.8148e-12, 4.8044e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2161e-15, 1.0000e+00, 1.3785e-15, 8.5637e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "87000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9456e-20, 3.4818e-13, 9.8702e-21, 8.0103e-21],\n", + " [6.9539e-30, 4.1655e-19, 2.3887e-30, 1.7082e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3813e-05, 9.9947e-01, 2.4375e-04, 2.1187e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2473e-12, 1.0000e+00, 7.1167e-12, 5.0199e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2874e-15, 1.0000e+00, 1.4617e-15, 9.0868e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "88000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9409e-20, 3.3748e-13, 9.8478e-21, 7.9916e-21],\n", + " [6.9353e-30, 3.9785e-19, 2.3845e-30, 1.7054e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4810e-05, 9.9946e-01, 2.4721e-04, 2.1499e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4267e-12, 1.0000e+00, 7.4232e-12, 5.2387e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3607e-15, 1.0000e+00, 1.5473e-15, 9.6263e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "89000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9362e-20, 3.2739e-13, 9.8257e-21, 7.9733e-21],\n", + " [6.9167e-30, 3.8047e-19, 2.3802e-30, 1.7027e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5816e-05, 9.9946e-01, 2.5067e-04, 2.1811e-04],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6106e-12, 1.0000e+00, 7.7368e-12, 5.4625e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4369e-15, 1.0000e+00, 1.6362e-15, 1.0186e-15],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "90000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.9317e-20, 3.1781e-13, 9.8039e-21, 7.9551e-21],\n", + " [6.8990e-30, 3.6421e-19, 2.3760e-30, 1.7000e-30]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8372e-06, 9.9995e-01, 2.4608e-05, 1.7789e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5244e-14, 1.0000e+00, 5.9721e-14, 3.2052e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1065e-18, 1.0000e+00, 2.1090e-18, 9.1354e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "91000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6780e-21, 1.2671e-12, 3.0749e-21, 2.2830e-21],\n", + " [1.6216e-31, 1.0021e-18, 8.5878e-32, 5.1462e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8165e-06, 9.9995e-01, 2.4625e-05, 1.7816e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5961e-14, 1.0000e+00, 6.1723e-14, 3.3141e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1732e-18, 1.0000e+00, 2.2529e-18, 9.7769e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "92000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.6212e-21, 1.2134e-12, 3.0413e-21, 2.2571e-21],\n", + " [1.6455e-31, 9.5612e-19, 8.7467e-32, 5.2466e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8445e-06, 9.9995e-01, 2.4813e-05, 1.7971e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7274e-14, 1.0000e+00, 6.5127e-14, 3.4993e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2831e-18, 1.0000e+00, 2.4807e-18, 1.0792e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "93000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.5731e-21, 1.1477e-12, 3.0122e-21, 2.2346e-21],\n", + " [1.6845e-31, 8.9861e-19, 8.9833e-32, 5.3958e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([6.9040e-06, 9.9995e-01, 2.5114e-05, 1.8207e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9055e-14, 1.0000e+00, 6.9667e-14, 3.7455e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4310e-18, 1.0000e+00, 2.7844e-18, 1.2141e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "94000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.5281e-21, 1.0760e-12, 2.9848e-21, 2.2134e-21],\n", + " [1.7295e-31, 8.3451e-19, 9.2516e-32, 5.5644e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9955e-06, 9.9995e-01, 2.5527e-05, 1.8524e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1299e-14, 1.0000e+00, 7.5337e-14, 4.0522e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6192e-18, 1.0000e+00, 3.1697e-18, 1.3852e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "95000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4851e-21, 1.0025e-12, 2.9585e-21, 2.1929e-21],\n", + " [1.7772e-31, 7.6786e-19, 9.5339e-32, 5.7414e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1145e-06, 9.9995e-01, 2.6036e-05, 1.8910e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3967e-14, 1.0000e+00, 8.2046e-14, 4.4148e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8484e-18, 1.0000e+00, 3.6385e-18, 1.5933e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "96000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4438e-21, 9.3082e-13, 2.9331e-21, 2.1731e-21],\n", + " [1.8252e-31, 7.0255e-19, 9.8173e-32, 5.9192e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2494e-06, 9.9995e-01, 2.6604e-05, 1.9338e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6969e-14, 1.0000e+00, 8.9600e-14, 4.8233e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1160e-18, 1.0000e+00, 4.1876e-18, 1.8374e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "97000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.4033e-21, 8.6349e-13, 2.9080e-21, 2.1535e-21],\n", + " [1.8727e-31, 6.4160e-19, 1.0099e-31, 6.0958e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3917e-06, 9.9995e-01, 2.7201e-05, 1.9788e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0217e-14, 1.0000e+00, 9.7803e-14, 5.2669e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4175e-18, 1.0000e+00, 4.8098e-18, 2.1145e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "98000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3653e-21, 8.0237e-13, 2.8848e-21, 2.1354e-21],\n", + " [1.9191e-31, 5.8680e-19, 1.0376e-31, 6.2700e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5373e-06, 9.9994e-01, 2.7813e-05, 2.0250e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3658e-14, 1.0000e+00, 1.0653e-13, 5.7392e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7500e-18, 1.0000e+00, 5.5005e-18, 2.4227e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "99000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.3306e-21, 7.4767e-13, 2.8636e-21, 2.1190e-21],\n", + " [1.9638e-31, 5.3827e-19, 1.0645e-31, 6.4393e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6871e-06, 9.9994e-01, 2.8439e-05, 2.0721e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7273e-14, 1.0000e+00, 1.1572e-13, 6.2364e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1130e-18, 1.0000e+00, 6.2578e-18, 2.7611e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "100000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2975e-21, 6.9885e-13, 2.8435e-21, 2.1033e-21],\n", + " [2.0065e-31, 4.9551e-19, 1.0903e-31, 6.6024e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8361e-06, 9.9994e-01, 2.9062e-05, 2.1190e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1025e-14, 1.0000e+00, 1.2529e-13, 6.7546e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5050e-18, 1.0000e+00, 7.0801e-18, 3.1291e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "101000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2673e-21, 6.5539e-13, 2.8252e-21, 2.0890e-21],\n", + " [2.0486e-31, 4.5803e-19, 1.1158e-31, 6.7631e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9794e-06, 9.9994e-01, 2.9662e-05, 2.1641e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4848e-14, 1.0000e+00, 1.3506e-13, 7.2838e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9210e-18, 1.0000e+00, 7.9564e-18, 3.5218e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "102000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2407e-21, 6.1698e-13, 2.8092e-21, 2.0765e-21],\n", + " [2.0906e-31, 4.2546e-19, 1.1412e-31, 6.9231e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1197e-06, 9.9994e-01, 3.0251e-05, 2.2085e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8762e-14, 1.0000e+00, 1.4511e-13, 7.8285e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3632e-18, 1.0000e+00, 8.8929e-18, 3.9422e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "103000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.2155e-21, 5.8252e-13, 2.7941e-21, 2.0647e-21],\n", + " [2.1313e-31, 3.9664e-19, 1.1659e-31, 7.0795e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([8.2572e-06, 9.9994e-01, 3.0830e-05, 2.2521e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2762e-14, 1.0000e+00, 1.5541e-13, 8.3867e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8316e-18, 1.0000e+00, 9.8893e-18, 4.3902e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "104000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1924e-21, 5.5160e-13, 2.7804e-21, 2.0540e-21],\n", + " [2.1717e-31, 3.7117e-19, 1.1905e-31, 7.2350e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3890e-06, 9.9994e-01, 3.1386e-05, 2.2941e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6791e-14, 1.0000e+00, 1.6582e-13, 8.9514e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3208e-18, 1.0000e+00, 1.0935e-17, 4.8615e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "105000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1705e-21, 5.2386e-13, 2.7675e-21, 2.0439e-21],\n", + " [2.2113e-31, 3.4867e-19, 1.2147e-31, 7.3883e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5201e-06, 9.9994e-01, 3.1936e-05, 2.3356e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0922e-14, 1.0000e+00, 1.7650e-13, 9.5310e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8380e-18, 1.0000e+00, 1.2044e-17, 5.3617e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "106000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1493e-21, 4.9850e-13, 2.7549e-21, 2.0341e-21],\n", + " [2.2495e-31, 3.2831e-19, 1.2381e-31, 7.5363e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6433e-06, 9.9994e-01, 3.2462e-05, 2.3754e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5044e-14, 1.0000e+00, 1.8724e-13, 1.0114e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3708e-18, 1.0000e+00, 1.3196e-17, 5.8822e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "107000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1294e-21, 4.7563e-13, 2.7432e-21, 2.0251e-21],\n", + " [2.2856e-31, 3.1010e-19, 1.2605e-31, 7.6785e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7664e-06, 9.9993e-01, 3.2991e-05, 2.4154e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9267e-14, 1.0000e+00, 1.9828e-13, 1.0715e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9310e-18, 1.0000e+00, 1.4413e-17, 6.4332e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "108000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.1104e-21, 4.5462e-13, 2.7322e-21, 2.0165e-21],\n", + " [2.3202e-31, 2.9349e-19, 1.2821e-31, 7.8163e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.8866e-06, 9.9993e-01, 3.3507e-05, 2.4545e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3508e-14, 1.0000e+00, 2.0939e-13, 1.1319e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5102e-18, 1.0000e+00, 1.5674e-17, 7.0049e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "109000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0920e-21, 4.3548e-13, 2.7213e-21, 2.0081e-21],\n", + " [2.3539e-31, 2.7855e-19, 1.3030e-31, 7.9491e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0049e-06, 9.9993e-01, 3.4016e-05, 2.4931e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7822e-14, 1.0000e+00, 2.2071e-13, 1.1935e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1144e-18, 1.0000e+00, 1.6994e-17, 7.6033e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "110000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0743e-21, 4.1779e-13, 2.7106e-21, 1.9998e-21],\n", + " [2.3865e-31, 2.6487e-19, 1.3232e-31, 8.0772e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.1236e-06, 9.9993e-01, 3.4520e-05, 2.5313e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2241e-14, 1.0000e+00, 2.3228e-13, 1.2564e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7478e-18, 1.0000e+00, 1.8377e-17, 8.2311e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "111000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0570e-21, 4.0131e-13, 2.7002e-21, 1.9917e-21],\n", + " [2.4179e-31, 2.5219e-19, 1.3425e-31, 8.1998e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2338e-06, 9.9993e-01, 3.4989e-05, 2.5669e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6567e-14, 1.0000e+00, 2.4363e-13, 1.3181e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3860e-18, 1.0000e+00, 1.9775e-17, 8.8662e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "112000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0399e-21, 3.8632e-13, 2.6898e-21, 1.9836e-21],\n", + " [2.4474e-31, 2.4079e-19, 1.3608e-31, 8.3165e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.3492e-06, 9.9993e-01, 3.5475e-05, 2.6037e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0106e-13, 1.0000e+00, 2.5540e-13, 1.3822e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0059e-17, 1.0000e+00, 2.1249e-17, 9.5368e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "113000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0230e-21, 3.7220e-13, 2.6795e-21, 1.9757e-21],\n", + " [2.4753e-31, 2.3007e-19, 1.3780e-31, 8.4266e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([9.4618e-06, 9.9993e-01, 3.5948e-05, 2.6395e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0559e-13, 1.0000e+00, 2.6727e-13, 1.4467e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0754e-17, 1.0000e+00, 2.2775e-17, 1.0231e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "114000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [4.0068e-21, 3.5906e-13, 2.6695e-21, 1.9679e-21],\n", + " [2.5027e-31, 2.2021e-19, 1.3950e-31, 8.5348e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.5691e-06, 9.9993e-01, 3.6402e-05, 2.6739e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1012e-13, 1.0000e+00, 2.7920e-13, 1.5116e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1468e-17, 1.0000e+00, 2.4346e-17, 1.0947e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "115000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9909e-21, 3.4681e-13, 2.6598e-21, 1.9604e-21],\n", + " [2.5296e-31, 2.1110e-19, 1.4118e-31, 8.6415e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6712e-06, 9.9993e-01, 3.6831e-05, 2.7064e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1462e-13, 1.0000e+00, 2.9100e-13, 1.5758e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2193e-17, 1.0000e+00, 2.5944e-17, 1.1675e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "116000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9759e-21, 3.3548e-13, 2.6505e-21, 1.9532e-21],\n", + " [2.5566e-31, 2.0279e-19, 1.4284e-31, 8.7474e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.7763e-06, 9.9993e-01, 3.7265e-05, 2.7391e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1925e-13, 1.0000e+00, 3.0309e-13, 1.6414e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2952e-17, 1.0000e+00, 2.7610e-17, 1.2433e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "117000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9613e-21, 3.2477e-13, 2.6413e-21, 1.9461e-21],\n", + " [2.5831e-31, 1.9499e-19, 1.4446e-31, 8.8501e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8826e-06, 9.9992e-01, 3.7702e-05, 2.7721e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2397e-13, 1.0000e+00, 3.1542e-13, 1.7084e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3740e-17, 1.0000e+00, 2.9339e-17, 1.3221e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "118000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9468e-21, 3.1465e-13, 2.6321e-21, 1.9389e-21],\n", + " [2.6086e-31, 1.8764e-19, 1.4601e-31, 8.9486e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.9895e-06, 9.9992e-01, 3.8137e-05, 2.8048e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2877e-13, 1.0000e+00, 3.2790e-13, 1.7761e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4555e-17, 1.0000e+00, 3.1124e-17, 1.4035e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "119000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9328e-21, 3.0510e-13, 2.6231e-21, 1.9319e-21],\n", + " [2.6336e-31, 1.8077e-19, 1.4752e-31, 9.0448e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0089e-05, 9.9992e-01, 3.8548e-05, 2.8357e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3349e-13, 1.0000e+00, 3.4022e-13, 1.8430e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5373e-17, 1.0000e+00, 3.2924e-17, 1.4855e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "120000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9188e-21, 2.9622e-13, 2.6142e-21, 1.9250e-21],\n", + " [2.6576e-31, 1.7443e-19, 1.4898e-31, 9.1371e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0187e-05, 9.9992e-01, 3.8952e-05, 2.8663e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3819e-13, 1.0000e+00, 3.5257e-13, 1.9101e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6205e-17, 1.0000e+00, 3.4764e-17, 1.5695e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "121000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.9049e-21, 2.8787e-13, 2.6054e-21, 1.9182e-21],\n", + " [2.6806e-31, 1.6851e-19, 1.5038e-31, 9.2266e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0282e-05, 9.9992e-01, 3.9354e-05, 2.8966e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4294e-13, 1.0000e+00, 3.6510e-13, 1.9782e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7062e-17, 1.0000e+00, 3.6665e-17, 1.6564e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "122000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8913e-21, 2.7993e-13, 2.5969e-21, 1.9116e-21],\n", + " [2.7033e-31, 1.6293e-19, 1.5178e-31, 9.3159e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0380e-05, 9.9992e-01, 3.9762e-05, 2.9274e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4785e-13, 1.0000e+00, 3.7802e-13, 2.0483e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7958e-17, 1.0000e+00, 3.8655e-17, 1.7473e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "123000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8778e-21, 2.7228e-13, 2.5884e-21, 1.9050e-21],\n", + " [2.7255e-31, 1.5755e-19, 1.5315e-31, 9.4032e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.0480e-05, 9.9992e-01, 4.0176e-05, 2.9585e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5286e-13, 1.0000e+00, 3.9123e-13, 2.1200e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8886e-17, 1.0000e+00, 4.0716e-17, 1.8414e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "124000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8644e-21, 2.6496e-13, 2.5799e-21, 1.8985e-21],\n", + " [2.7466e-31, 1.5242e-19, 1.5446e-31, 9.4863e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0577e-05, 9.9992e-01, 4.0582e-05, 2.9891e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5785e-13, 1.0000e+00, 4.0442e-13, 2.1917e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9826e-17, 1.0000e+00, 4.2812e-17, 1.9373e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "125000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8510e-21, 2.5805e-13, 2.5715e-21, 1.8920e-21],\n", + " [2.7670e-31, 1.4763e-19, 1.5573e-31, 9.5674e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0663e-05, 9.9992e-01, 4.0949e-05, 3.0169e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6262e-13, 1.0000e+00, 4.1709e-13, 2.2605e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0745e-17, 1.0000e+00, 4.4872e-17, 2.0317e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "126000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8389e-21, 2.5173e-13, 2.5638e-21, 1.8861e-21],\n", + " [2.7871e-31, 1.4327e-19, 1.5698e-31, 9.6476e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0750e-05, 9.9992e-01, 4.1324e-05, 3.0453e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6751e-13, 1.0000e+00, 4.3013e-13, 2.3314e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1699e-17, 1.0000e+00, 4.7019e-17, 2.1301e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "127000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8269e-21, 2.4562e-13, 2.5563e-21, 1.8802e-21],\n", + " [2.8067e-31, 1.3906e-19, 1.5821e-31, 9.7264e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0836e-05, 9.9992e-01, 4.1698e-05, 3.0736e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7244e-13, 1.0000e+00, 4.4333e-13, 2.4032e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2675e-17, 1.0000e+00, 4.9223e-17, 2.2312e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "128000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8151e-21, 2.3976e-13, 2.5489e-21, 1.8745e-21],\n", + " [2.8257e-31, 1.3505e-19, 1.5941e-31, 9.8029e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0921e-05, 9.9992e-01, 4.2068e-05, 3.1017e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7738e-13, 1.0000e+00, 4.5660e-13, 2.4754e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3667e-17, 1.0000e+00, 5.1472e-17, 2.3345e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "129000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.8032e-21, 2.3417e-13, 2.5415e-21, 1.8687e-21],\n", + " [2.8439e-31, 1.3124e-19, 1.6057e-31, 9.8771e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1008e-05, 9.9992e-01, 4.2449e-05, 3.1305e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8246e-13, 1.0000e+00, 4.7027e-13, 2.5497e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4698e-17, 1.0000e+00, 5.3816e-17, 2.4421e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "130000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7918e-21, 2.2879e-13, 2.5344e-21, 1.8633e-21],\n", + " [2.8625e-31, 1.2759e-19, 1.6175e-31, 9.9531e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1097e-05, 9.9991e-01, 4.2838e-05, 3.1600e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8762e-13, 1.0000e+00, 4.8421e-13, 2.6256e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5759e-17, 1.0000e+00, 5.6237e-17, 2.5534e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "131000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7811e-21, 2.2366e-13, 2.5279e-21, 1.8582e-21],\n", + " [2.8815e-31, 1.2415e-19, 1.6296e-31, 1.0030e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1187e-05, 9.9991e-01, 4.3231e-05, 3.1898e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9288e-13, 1.0000e+00, 4.9844e-13, 2.7031e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6854e-17, 1.0000e+00, 5.8739e-17, 2.6685e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "132000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7705e-21, 2.1870e-13, 2.5213e-21, 1.8531e-21],\n", + " [2.9001e-31, 1.2082e-19, 1.6415e-31, 1.0107e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1274e-05, 9.9991e-01, 4.3617e-05, 3.2191e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9821e-13, 1.0000e+00, 5.1288e-13, 2.7816e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7980e-17, 1.0000e+00, 6.1315e-17, 2.7869e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "133000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7619e-21, 2.1400e-13, 2.5161e-21, 1.8490e-21],\n", + " [2.9208e-31, 1.1770e-19, 1.6544e-31, 1.0189e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.1356e-05, 9.9991e-01, 4.3981e-05, 3.2468e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0343e-13, 1.0000e+00, 5.2705e-13, 2.8587e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9106e-17, 1.0000e+00, 6.3896e-17, 2.9057e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "134000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7540e-21, 2.0958e-13, 2.5113e-21, 1.8452e-21],\n", + " [2.9423e-31, 1.1481e-19, 1.6678e-31, 1.0274e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1431e-05, 9.9991e-01, 4.4321e-05, 3.2728e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0847e-13, 1.0000e+00, 5.4086e-13, 2.9340e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0214e-17, 1.0000e+00, 6.6456e-17, 3.0237e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "135000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7468e-21, 2.0546e-13, 2.5070e-21, 1.8417e-21],\n", + " [2.9639e-31, 1.1214e-19, 1.6813e-31, 1.0360e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1506e-05, 9.9991e-01, 4.4665e-05, 3.2991e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1363e-13, 1.0000e+00, 5.5502e-13, 3.0112e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1358e-17, 1.0000e+00, 6.9106e-17, 3.1458e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "136000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7404e-21, 2.0147e-13, 2.5033e-21, 1.8388e-21],\n", + " [2.9858e-31, 1.0956e-19, 1.6950e-31, 1.0446e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1581e-05, 9.9991e-01, 4.5011e-05, 3.3254e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1884e-13, 1.0000e+00, 5.6936e-13, 3.0894e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2529e-17, 1.0000e+00, 7.1827e-17, 3.2713e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "137000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7345e-21, 1.9765e-13, 2.4999e-21, 1.8361e-21],\n", + " [3.0082e-31, 1.0711e-19, 1.7091e-31, 1.0536e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1659e-05, 9.9991e-01, 4.5364e-05, 3.3523e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2419e-13, 1.0000e+00, 5.8408e-13, 3.1696e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3743e-17, 1.0000e+00, 7.4648e-17, 3.4015e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "138000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7288e-21, 1.9393e-13, 2.4967e-21, 1.8335e-21],\n", + " [3.0308e-31, 1.0473e-19, 1.7232e-31, 1.0626e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1737e-05, 9.9991e-01, 4.5717e-05, 3.3791e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2961e-13, 1.0000e+00, 5.9900e-13, 3.2509e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4988e-17, 1.0000e+00, 7.7550e-17, 3.5355e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "139000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7231e-21, 1.9033e-13, 2.4935e-21, 1.8309e-21],\n", + " [3.0534e-31, 1.0244e-19, 1.7374e-31, 1.0716e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1811e-05, 9.9991e-01, 4.6061e-05, 3.4054e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3495e-13, 1.0000e+00, 6.1378e-13, 3.3315e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6231e-17, 1.0000e+00, 8.0457e-17, 3.6698e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "140000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7183e-21, 1.8695e-13, 2.4909e-21, 1.8288e-21],\n", + " [3.0765e-31, 1.0031e-19, 1.7519e-31, 1.0808e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1886e-05, 9.9991e-01, 4.6407e-05, 3.4318e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4035e-13, 1.0000e+00, 6.2878e-13, 3.4134e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7503e-17, 1.0000e+00, 8.3442e-17, 3.8079e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "141000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7140e-21, 1.8369e-13, 2.4886e-21, 1.8269e-21],\n", + " [3.1001e-31, 9.8266e-20, 1.7667e-31, 1.0902e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1963e-05, 9.9991e-01, 4.6759e-05, 3.4587e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.4588e-13, 1.0000e+00, 6.4413e-13, 3.4973e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8817e-17, 1.0000e+00, 8.6527e-17, 3.9506e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "142000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7098e-21, 1.8051e-13, 2.4864e-21, 1.8251e-21],\n", + " [3.1239e-31, 9.6279e-20, 1.7815e-31, 1.0996e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2041e-05, 9.9991e-01, 4.7123e-05, 3.4865e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5157e-13, 1.0000e+00, 6.5999e-13, 3.5840e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0177e-17, 1.0000e+00, 8.9729e-17, 4.0989e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "143000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7060e-21, 1.7740e-13, 2.4844e-21, 1.8234e-21],\n", + " [3.1471e-31, 9.4326e-20, 1.7960e-31, 1.1088e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.2121e-05, 9.9991e-01, 4.7490e-05, 3.5146e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.5736e-13, 1.0000e+00, 6.7615e-13, 3.6725e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1578e-17, 1.0000e+00, 9.3032e-17, 4.2519e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "144000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.7025e-21, 1.7438e-13, 2.4826e-21, 1.8220e-21],\n", + " [3.1708e-31, 9.2442e-20, 1.8107e-31, 1.1182e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2200e-05, 9.9990e-01, 4.7860e-05, 3.5429e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6325e-13, 1.0000e+00, 6.9261e-13, 3.7625e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3014e-17, 1.0000e+00, 9.6428e-17, 4.4094e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "145000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6991e-21, 1.7145e-13, 2.4810e-21, 1.8206e-21],\n", + " [3.1945e-31, 9.0614e-20, 1.8255e-31, 1.1276e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2281e-05, 9.9990e-01, 4.8236e-05, 3.5718e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.6925e-13, 1.0000e+00, 7.0943e-13, 3.8546e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4491e-17, 1.0000e+00, 9.9924e-17, 4.5717e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "146000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6959e-21, 1.6860e-13, 2.4794e-21, 1.8193e-21],\n", + " [3.2177e-31, 8.8829e-20, 1.8400e-31, 1.1368e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2362e-05, 9.9990e-01, 4.8615e-05, 3.6009e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.7531e-13, 1.0000e+00, 7.2647e-13, 3.9480e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5998e-17, 1.0000e+00, 1.0350e-16, 4.7380e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "147000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6926e-21, 1.6582e-13, 2.4777e-21, 1.8179e-21],\n", + " [3.2406e-31, 8.7103e-20, 1.8543e-31, 1.1460e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2442e-05, 9.9990e-01, 4.8986e-05, 3.6295e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8136e-13, 1.0000e+00, 7.4352e-13, 4.0415e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7520e-17, 1.0000e+00, 1.0713e-16, 4.9066e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "148000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6892e-21, 1.6315e-13, 2.4761e-21, 1.8166e-21],\n", + " [3.2634e-31, 8.5449e-20, 1.8686e-31, 1.1551e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2507e-05, 9.9990e-01, 4.9304e-05, 3.6540e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.8688e-13, 1.0000e+00, 7.5918e-13, 4.1275e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8934e-17, 1.0000e+00, 1.1053e-16, 5.0645e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "149000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6865e-21, 1.6074e-13, 2.4748e-21, 1.8155e-21],\n", + " [3.2847e-31, 8.3964e-20, 1.8820e-31, 1.1636e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2573e-05, 9.9990e-01, 4.9621e-05, 3.6785e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9245e-13, 1.0000e+00, 7.7502e-13, 4.2143e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0373e-17, 1.0000e+00, 1.1399e-16, 5.2257e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "150000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6841e-21, 1.5840e-13, 2.4738e-21, 1.8146e-21],\n", + " [3.3057e-31, 8.2518e-20, 1.8954e-31, 1.1721e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2639e-05, 9.9990e-01, 4.9939e-05, 3.7030e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.9809e-13, 1.0000e+00, 7.9108e-13, 4.3025e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1844e-17, 1.0000e+00, 1.1753e-16, 5.3908e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "151000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6816e-21, 1.5611e-13, 2.4727e-21, 1.8137e-21],\n", + " [3.3268e-31, 8.1110e-20, 1.9087e-31, 1.1807e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2704e-05, 9.9990e-01, 5.0254e-05, 3.7273e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0377e-13, 1.0000e+00, 8.0723e-13, 4.3911e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3337e-17, 1.0000e+00, 1.2113e-16, 5.5584e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "152000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6795e-21, 1.5390e-13, 2.4718e-21, 1.8129e-21],\n", + " [3.3481e-31, 7.9752e-20, 1.9221e-31, 1.1892e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2770e-05, 9.9990e-01, 5.0573e-05, 3.7519e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.0958e-13, 1.0000e+00, 8.2375e-13, 4.4818e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4871e-17, 1.0000e+00, 1.2483e-16, 5.7310e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "153000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6781e-21, 1.5174e-13, 2.4713e-21, 1.8124e-21],\n", + " [3.3692e-31, 7.8419e-20, 1.9354e-31, 1.1977e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.2836e-05, 9.9990e-01, 5.0891e-05, 3.7764e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.1541e-13, 1.0000e+00, 8.4040e-13, 4.5732e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6429e-17, 1.0000e+00, 1.2860e-16, 5.9067e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "154000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6767e-21, 1.4964e-13, 2.4709e-21, 1.8120e-21],\n", + " [3.3902e-31, 7.7126e-20, 1.9487e-31, 1.2062e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2902e-05, 9.9990e-01, 5.1212e-05, 3.8011e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2132e-13, 1.0000e+00, 8.5730e-13, 4.6660e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8021e-17, 1.0000e+00, 1.3246e-16, 6.0869e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "155000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6753e-21, 1.4759e-13, 2.4704e-21, 1.8115e-21],\n", + " [3.4115e-31, 7.5869e-20, 1.9621e-31, 1.2148e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2969e-05, 9.9990e-01, 5.1538e-05, 3.8263e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.2733e-13, 1.0000e+00, 8.7450e-13, 4.7606e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9651e-17, 1.0000e+00, 1.3642e-16, 6.2719e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "156000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6739e-21, 1.4558e-13, 2.4699e-21, 1.8111e-21],\n", + " [3.4328e-31, 7.4644e-20, 1.9757e-31, 1.2234e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3038e-05, 9.9990e-01, 5.1870e-05, 3.8519e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3345e-13, 1.0000e+00, 8.9205e-13, 4.8570e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1323e-17, 1.0000e+00, 1.4050e-16, 6.4622e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "157000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6725e-21, 1.4361e-13, 2.4695e-21, 1.8106e-21],\n", + " [3.4539e-31, 7.3441e-20, 1.9890e-31, 1.2320e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3107e-05, 9.9990e-01, 5.2204e-05, 3.8777e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.3968e-13, 1.0000e+00, 9.0991e-13, 4.9552e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3039e-17, 1.0000e+00, 1.4467e-16, 6.6574e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "158000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6712e-21, 1.4167e-13, 2.4691e-21, 1.8102e-21],\n", + " [3.4751e-31, 7.2261e-20, 2.0024e-31, 1.2405e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3177e-05, 9.9990e-01, 5.2541e-05, 3.9037e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.4602e-13, 1.0000e+00, 9.2804e-13, 5.0548e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4792e-17, 1.0000e+00, 1.4894e-16, 6.8567e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "159000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6700e-21, 1.3978e-13, 2.4687e-21, 1.8098e-21],\n", + " [3.4958e-31, 7.1104e-20, 2.0154e-31, 1.2488e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3245e-05, 9.9989e-01, 5.2870e-05, 3.9291e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5229e-13, 1.0000e+00, 9.4606e-13, 5.1540e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6543e-17, 1.0000e+00, 1.5322e-16, 7.0569e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "160000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6688e-21, 1.3795e-13, 2.4682e-21, 1.8094e-21],\n", + " [3.5161e-31, 6.9993e-20, 2.0282e-31, 1.2570e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3309e-05, 9.9989e-01, 5.3182e-05, 3.9532e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5840e-13, 1.0000e+00, 9.6367e-13, 5.2509e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8275e-17, 1.0000e+00, 1.5746e-16, 7.2550e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "161000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6675e-21, 1.3621e-13, 2.4679e-21, 1.8090e-21],\n", + " [3.5363e-31, 6.8944e-20, 2.0410e-31, 1.2651e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3374e-05, 9.9989e-01, 5.3493e-05, 3.9772e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6460e-13, 1.0000e+00, 9.8147e-13, 5.3487e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0043e-17, 1.0000e+00, 1.6178e-16, 7.4572e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "162000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6665e-21, 1.3451e-13, 2.4676e-21, 1.8087e-21],\n", + " [3.5567e-31, 6.7920e-20, 2.0539e-31, 1.2733e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3440e-05, 9.9989e-01, 5.3806e-05, 4.0014e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7089e-13, 1.0000e+00, 9.9951e-13, 5.4479e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1846e-17, 1.0000e+00, 1.6619e-16, 7.6634e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "163000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6654e-21, 1.3284e-13, 2.4673e-21, 1.8084e-21],\n", + " [3.5767e-31, 6.6916e-20, 2.0665e-31, 1.2814e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.3507e-05, 9.9989e-01, 5.4124e-05, 4.0258e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7731e-13, 1.0000e+00, 1.0179e-12, 5.5489e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3697e-17, 1.0000e+00, 1.7070e-16, 7.8746e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "164000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6643e-21, 1.3119e-13, 2.4670e-21, 1.8080e-21],\n", + " [3.5965e-31, 6.5921e-20, 2.0789e-31, 1.2893e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3575e-05, 9.9989e-01, 5.4447e-05, 4.0506e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.8385e-13, 1.0000e+00, 1.0366e-12, 5.6517e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5588e-17, 1.0000e+00, 1.7532e-16, 8.0909e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "165000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6633e-21, 1.2957e-13, 2.4667e-21, 1.8077e-21],\n", + " [3.6156e-31, 6.4942e-20, 2.0910e-31, 1.2970e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3645e-05, 9.9989e-01, 5.4771e-05, 4.0755e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9050e-13, 1.0000e+00, 1.0556e-12, 5.7561e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7526e-17, 1.0000e+00, 1.8005e-16, 8.3121e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "166000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6624e-21, 1.2798e-13, 2.4664e-21, 1.8074e-21],\n", + " [3.6349e-31, 6.3982e-20, 2.1032e-31, 1.3048e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3715e-05, 9.9989e-01, 5.5094e-05, 4.1002e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9726e-13, 1.0000e+00, 1.0749e-12, 5.8615e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9509e-17, 1.0000e+00, 1.8488e-16, 8.5377e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "167000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6615e-21, 1.2642e-13, 2.4662e-21, 1.8071e-21],\n", + " [3.6543e-31, 6.3042e-20, 2.1153e-31, 1.3126e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3787e-05, 9.9989e-01, 5.5422e-05, 4.1252e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.0416e-13, 1.0000e+00, 1.0944e-12, 5.9684e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1529e-17, 1.0000e+00, 1.8979e-16, 8.7671e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "168000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6607e-21, 1.2489e-13, 2.4659e-21, 1.8068e-21],\n", + " [3.6723e-31, 6.2109e-20, 2.1267e-31, 1.3199e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3864e-05, 9.9989e-01, 5.5764e-05, 4.1509e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1131e-13, 1.0000e+00, 1.1145e-12, 6.0784e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3610e-17, 1.0000e+00, 1.9485e-16, 9.0033e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "169000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6599e-21, 1.2338e-13, 2.4657e-21, 1.8065e-21],\n", + " [3.6882e-31, 6.1163e-20, 2.1369e-31, 1.3265e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3942e-05, 9.9989e-01, 5.6109e-05, 4.1769e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1860e-13, 1.0000e+00, 1.1350e-12, 6.1904e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.5746e-17, 1.0000e+00, 2.0003e-16, 9.2453e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "170000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6591e-21, 1.2189e-13, 2.4654e-21, 1.8062e-21],\n", + " [3.7039e-31, 6.0232e-20, 2.1471e-31, 1.3331e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4021e-05, 9.9989e-01, 5.6454e-05, 4.2028e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.2596e-13, 1.0000e+00, 1.1557e-12, 6.3030e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.7915e-17, 1.0000e+00, 2.0528e-16, 9.4902e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "171000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6584e-21, 1.2043e-13, 2.4651e-21, 1.8059e-21],\n", + " [3.7194e-31, 5.9326e-20, 2.1570e-31, 1.3395e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4099e-05, 9.9989e-01, 5.6794e-05, 4.2284e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3330e-13, 1.0000e+00, 1.1762e-12, 6.4152e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0096e-17, 1.0000e+00, 2.1057e-16, 9.7369e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "172000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6577e-21, 1.1903e-13, 2.4649e-21, 1.8057e-21],\n", + " [3.7349e-31, 5.8454e-20, 2.1670e-31, 1.3459e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4176e-05, 9.9989e-01, 5.7134e-05, 4.2539e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4070e-13, 1.0000e+00, 1.1970e-12, 6.5286e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.2311e-17, 1.0000e+00, 2.1595e-16, 9.9882e-17],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "173000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6569e-21, 1.1765e-13, 2.4646e-21, 1.8054e-21],\n", + " [3.7504e-31, 5.7602e-20, 2.1769e-31, 1.3523e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4254e-05, 9.9989e-01, 5.7473e-05, 4.2794e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.4819e-13, 1.0000e+00, 1.2181e-12, 6.6434e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4571e-17, 1.0000e+00, 2.2144e-16, 1.0244e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "174000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6562e-21, 1.1629e-13, 2.4643e-21, 1.8051e-21],\n", + " [3.7660e-31, 5.6765e-20, 2.1869e-31, 1.3588e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4321e-05, 9.9988e-01, 5.7772e-05, 4.3019e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.5514e-13, 1.0000e+00, 1.2377e-12, 6.7503e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.6708e-17, 1.0000e+00, 2.2666e-16, 1.0488e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "175000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6555e-21, 1.1503e-13, 2.4641e-21, 1.8048e-21],\n", + " [3.7815e-31, 5.6003e-20, 2.1969e-31, 1.3652e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4380e-05, 9.9988e-01, 5.8039e-05, 4.3220e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6166e-13, 1.0000e+00, 1.2561e-12, 6.8509e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.8747e-17, 1.0000e+00, 2.3164e-16, 1.0722e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "176000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6548e-21, 1.1385e-13, 2.4638e-21, 1.8045e-21],\n", + " [3.7971e-31, 5.5301e-20, 2.2069e-31, 1.3717e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4437e-05, 9.9988e-01, 5.8296e-05, 4.3414e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6809e-13, 1.0000e+00, 1.2743e-12, 6.9503e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0078e-16, 1.0000e+00, 2.3662e-16, 1.0955e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "177000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6541e-21, 1.1271e-13, 2.4636e-21, 1.8042e-21],\n", + " [3.8127e-31, 5.4624e-20, 2.2170e-31, 1.3782e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4490e-05, 9.9988e-01, 5.8538e-05, 4.3597e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.7432e-13, 1.0000e+00, 1.2921e-12, 7.0469e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0276e-16, 1.0000e+00, 2.4151e-16, 1.1184e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "178000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6534e-21, 1.1162e-13, 2.4633e-21, 1.8040e-21],\n", + " [3.8279e-31, 5.3980e-20, 2.2268e-31, 1.3845e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4546e-05, 9.9988e-01, 5.8786e-05, 4.3783e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8074e-13, 1.0000e+00, 1.3101e-12, 7.1453e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0481e-16, 1.0000e+00, 2.4651e-16, 1.1417e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "179000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6530e-21, 1.1054e-13, 2.4633e-21, 1.8038e-21],\n", + " [3.8432e-31, 5.3343e-20, 2.2365e-31, 1.3908e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4602e-05, 9.9988e-01, 5.9039e-05, 4.3972e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.8727e-13, 1.0000e+00, 1.3285e-12, 7.2455e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0690e-16, 1.0000e+00, 2.5161e-16, 1.1656e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "180000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6529e-21, 1.0948e-13, 2.4633e-21, 1.8038e-21],\n", + " [3.8588e-31, 5.2716e-20, 2.2464e-31, 1.3972e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4659e-05, 9.9988e-01, 5.9292e-05, 4.4162e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9388e-13, 1.0000e+00, 1.3472e-12, 7.3471e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.0903e-16, 1.0000e+00, 2.5682e-16, 1.1899e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "181000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6527e-21, 1.0843e-13, 2.4634e-21, 1.8037e-21],\n", + " [3.8743e-31, 5.2096e-20, 2.2562e-31, 1.4035e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4716e-05, 9.9988e-01, 5.9546e-05, 4.4352e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0056e-13, 1.0000e+00, 1.3661e-12, 7.4499e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1119e-16, 1.0000e+00, 2.6211e-16, 1.2146e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "182000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6526e-21, 1.0740e-13, 2.4635e-21, 1.8037e-21],\n", + " [3.8895e-31, 5.1484e-20, 2.2659e-31, 1.4097e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4774e-05, 9.9988e-01, 5.9798e-05, 4.4540e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0736e-13, 1.0000e+00, 1.3851e-12, 7.5533e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1340e-16, 1.0000e+00, 2.6747e-16, 1.2397e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "183000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6525e-21, 1.0637e-13, 2.4636e-21, 1.8037e-21],\n", + " [3.9050e-31, 5.0881e-20, 2.2757e-31, 1.4160e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.4833e-05, 9.9988e-01, 6.0053e-05, 4.4731e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.1419e-13, 1.0000e+00, 1.4042e-12, 7.6573e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1562e-16, 1.0000e+00, 2.7289e-16, 1.2649e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "184000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6525e-21, 1.0537e-13, 2.4637e-21, 1.8036e-21],\n", + " [3.9199e-31, 5.0292e-20, 2.2851e-31, 1.4220e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4893e-05, 9.9988e-01, 6.0317e-05, 4.4928e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2117e-13, 1.0000e+00, 1.4238e-12, 7.7638e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.1790e-16, 1.0000e+00, 2.7843e-16, 1.2908e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "185000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6524e-21, 1.0439e-13, 2.4637e-21, 1.8036e-21],\n", + " [3.9343e-31, 4.9704e-20, 2.2941e-31, 1.4278e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4955e-05, 9.9988e-01, 6.0586e-05, 4.5129e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2827e-13, 1.0000e+00, 1.4437e-12, 7.8722e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2022e-16, 1.0000e+00, 2.8408e-16, 1.3172e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "186000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6523e-21, 1.0341e-13, 2.4639e-21, 1.8036e-21],\n", + " [3.9482e-31, 4.9121e-20, 2.3029e-31, 1.4335e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5017e-05, 9.9988e-01, 6.0853e-05, 4.5329e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3542e-13, 1.0000e+00, 1.4638e-12, 7.9811e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2257e-16, 1.0000e+00, 2.8980e-16, 1.3439e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "187000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6522e-21, 1.0245e-13, 2.4639e-21, 1.8035e-21],\n", + " [3.9621e-31, 4.8550e-20, 2.3118e-31, 1.4392e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5078e-05, 9.9988e-01, 6.1114e-05, 4.5524e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4255e-13, 1.0000e+00, 1.4837e-12, 8.0890e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2493e-16, 1.0000e+00, 2.9552e-16, 1.3706e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "188000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6523e-21, 1.0151e-13, 2.4641e-21, 1.8035e-21],\n", + " [3.9764e-31, 4.7997e-20, 2.3206e-31, 1.4449e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5141e-05, 9.9988e-01, 6.1377e-05, 4.5718e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4984e-13, 1.0000e+00, 1.5038e-12, 8.1981e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2734e-16, 1.0000e+00, 3.0133e-16, 1.3976e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "189000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6524e-21, 1.0059e-13, 2.4641e-21, 1.8035e-21],\n", + " [3.9903e-31, 4.7449e-20, 2.3292e-31, 1.4504e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5204e-05, 9.9988e-01, 6.1642e-05, 4.5914e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.5725e-13, 1.0000e+00, 1.5242e-12, 8.3087e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.2981e-16, 1.0000e+00, 3.0725e-16, 1.4251e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "190000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6526e-21, 9.9670e-14, 2.4643e-21, 1.8035e-21],\n", + " [4.0042e-31, 4.6907e-20, 2.3378e-31, 1.4558e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5269e-05, 9.9988e-01, 6.1910e-05, 4.6113e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6478e-13, 1.0000e+00, 1.5450e-12, 8.4211e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3232e-16, 1.0000e+00, 3.1329e-16, 1.4533e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "191000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6527e-21, 9.8764e-14, 2.4644e-21, 1.8034e-21],\n", + " [4.0179e-31, 4.6370e-20, 2.3462e-31, 1.4612e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5335e-05, 9.9988e-01, 6.2182e-05, 4.6314e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.7242e-13, 1.0000e+00, 1.5661e-12, 8.5353e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3488e-16, 1.0000e+00, 3.1945e-16, 1.4820e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "192000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6528e-21, 9.7867e-14, 2.4645e-21, 1.8034e-21],\n", + " [4.0314e-31, 4.5839e-20, 2.3546e-31, 1.4666e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5400e-05, 9.9988e-01, 6.2455e-05, 4.6516e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8012e-13, 1.0000e+00, 1.5873e-12, 8.6503e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.3748e-16, 1.0000e+00, 3.2569e-16, 1.5110e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "193000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6529e-21, 9.6985e-14, 2.4646e-21, 1.8034e-21],\n", + " [4.0450e-31, 4.5318e-20, 2.3629e-31, 1.4719e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.5466e-05, 9.9988e-01, 6.2729e-05, 4.6719e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.8790e-13, 1.0000e+00, 1.6088e-12, 8.7667e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4011e-16, 1.0000e+00, 3.3204e-16, 1.5406e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "194000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6531e-21, 9.6114e-14, 2.4647e-21, 1.8033e-21],\n", + " [4.0585e-31, 4.4804e-20, 2.3713e-31, 1.4773e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5532e-05, 9.9987e-01, 6.3005e-05, 4.6923e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9579e-13, 1.0000e+00, 1.6306e-12, 8.8845e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4280e-16, 1.0000e+00, 3.3851e-16, 1.5707e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "195000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6532e-21, 9.5252e-14, 2.4648e-21, 1.8033e-21],\n", + " [4.0721e-31, 4.4298e-20, 2.3797e-31, 1.4826e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5599e-05, 9.9987e-01, 6.3281e-05, 4.7128e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0378e-13, 1.0000e+00, 1.6526e-12, 9.0039e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4553e-16, 1.0000e+00, 3.4509e-16, 1.6014e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "196000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6533e-21, 9.4398e-14, 2.4649e-21, 1.8033e-21],\n", + " [4.0856e-31, 4.3796e-20, 2.3881e-31, 1.4880e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5665e-05, 9.9987e-01, 6.3557e-05, 4.7332e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1180e-13, 1.0000e+00, 1.6748e-12, 9.1240e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.4830e-16, 1.0000e+00, 3.5176e-16, 1.6324e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "197000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6535e-21, 9.3558e-14, 2.4650e-21, 1.8032e-21],\n", + " [4.0992e-31, 4.3306e-20, 2.3965e-31, 1.4934e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5731e-05, 9.9987e-01, 6.3832e-05, 4.7535e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.1987e-13, 1.0000e+00, 1.6970e-12, 9.2445e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5109e-16, 1.0000e+00, 3.5849e-16, 1.6638e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "198000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6536e-21, 9.2734e-14, 2.4651e-21, 1.8032e-21],\n", + " [4.1128e-31, 4.2826e-20, 2.4049e-31, 1.4988e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5798e-05, 9.9987e-01, 6.4109e-05, 4.7740e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2803e-13, 1.0000e+00, 1.7196e-12, 9.3667e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5394e-16, 1.0000e+00, 3.6536e-16, 1.6957e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "199000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6537e-21, 9.1919e-14, 2.4652e-21, 1.8032e-21],\n", + " [4.1263e-31, 4.2350e-20, 2.4132e-31, 1.5041e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5867e-05, 9.9987e-01, 6.4396e-05, 4.7954e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.3641e-13, 1.0000e+00, 1.7427e-12, 9.4919e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5684e-16, 1.0000e+00, 3.7235e-16, 1.7283e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "200000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6539e-21, 9.1110e-14, 2.4653e-21, 1.8032e-21],\n", + " [4.1381e-31, 4.1869e-20, 2.4206e-31, 1.5088e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5937e-05, 9.9987e-01, 6.4686e-05, 4.8170e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4491e-13, 1.0000e+00, 1.7662e-12, 9.6190e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.5979e-16, 1.0000e+00, 3.7947e-16, 1.7615e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "201000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6540e-21, 9.0310e-14, 2.4654e-21, 1.8032e-21],\n", + " [4.1497e-31, 4.1393e-20, 2.4280e-31, 1.5135e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6008e-05, 9.9987e-01, 6.4974e-05, 4.8383e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5346e-13, 1.0000e+00, 1.7896e-12, 9.7460e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6278e-16, 1.0000e+00, 3.8665e-16, 1.7949e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "202000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6542e-21, 8.9526e-14, 2.4656e-21, 1.8031e-21],\n", + " [4.1615e-31, 4.0928e-20, 2.4353e-31, 1.5181e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6078e-05, 9.9987e-01, 6.5258e-05, 4.8594e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.6207e-13, 1.0000e+00, 1.8131e-12, 9.8731e-13],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6580e-16, 1.0000e+00, 3.9388e-16, 1.8285e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "203000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6543e-21, 8.8757e-14, 2.4657e-21, 1.8031e-21],\n", + " [4.1734e-31, 4.0475e-20, 2.4427e-31, 1.5228e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.6149e-05, 9.9987e-01, 6.5542e-05, 4.8802e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7071e-13, 1.0000e+00, 1.8366e-12, 1.0000e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6885e-16, 1.0000e+00, 4.0117e-16, 1.8624e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "204000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6546e-21, 8.8005e-14, 2.4658e-21, 1.8031e-21],\n", + " [4.1853e-31, 4.0033e-20, 2.4500e-31, 1.5275e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6216e-05, 9.9987e-01, 6.5808e-05, 4.8998e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.7906e-13, 1.0000e+00, 1.8594e-12, 1.0123e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7182e-16, 1.0000e+00, 4.0826e-16, 1.8953e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "205000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6548e-21, 8.7287e-14, 2.4659e-21, 1.8031e-21],\n", + " [4.1971e-31, 3.9616e-20, 2.4574e-31, 1.5322e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6280e-05, 9.9987e-01, 6.6065e-05, 4.9187e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8725e-13, 1.0000e+00, 1.8816e-12, 1.0243e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7476e-16, 1.0000e+00, 4.1528e-16, 1.9279e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "206000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6550e-21, 8.6595e-14, 2.4660e-21, 1.8031e-21],\n", + " [4.2091e-31, 3.9217e-20, 2.4648e-31, 1.5369e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6346e-05, 9.9987e-01, 6.6328e-05, 4.9380e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.9555e-13, 1.0000e+00, 1.9042e-12, 1.0364e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7773e-16, 1.0000e+00, 4.2237e-16, 1.9608e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "207000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6552e-21, 8.5915e-14, 2.4661e-21, 1.8030e-21],\n", + " [4.2199e-31, 3.8818e-20, 2.4715e-31, 1.5412e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6413e-05, 9.9987e-01, 6.6591e-05, 4.9573e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.0379e-13, 1.0000e+00, 1.9266e-12, 1.0485e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8067e-16, 1.0000e+00, 4.2940e-16, 1.9934e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "208000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6554e-21, 8.5257e-14, 2.4663e-21, 1.8030e-21],\n", + " [4.2296e-31, 3.8430e-20, 2.4777e-31, 1.5451e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6479e-05, 9.9987e-01, 6.6856e-05, 4.9768e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.1211e-13, 1.0000e+00, 1.9492e-12, 1.0607e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8365e-16, 1.0000e+00, 4.3651e-16, 2.0265e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "209000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6556e-21, 8.4607e-14, 2.4663e-21, 1.8030e-21],\n", + " [4.2393e-31, 3.8046e-20, 2.4838e-31, 1.5490e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6547e-05, 9.9987e-01, 6.7127e-05, 4.9968e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2057e-13, 1.0000e+00, 1.9722e-12, 1.0731e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8668e-16, 1.0000e+00, 4.4378e-16, 2.0602e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "210000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6558e-21, 8.3963e-14, 2.4664e-21, 1.8030e-21],\n", + " [4.2489e-31, 3.7666e-20, 2.4898e-31, 1.5528e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6615e-05, 9.9987e-01, 6.7399e-05, 5.0169e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2911e-13, 1.0000e+00, 1.9954e-12, 1.0857e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8976e-16, 1.0000e+00, 4.5116e-16, 2.0945e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "211000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6560e-21, 8.3323e-14, 2.4666e-21, 1.8030e-21],\n", + " [4.2583e-31, 3.7289e-20, 2.4958e-31, 1.5566e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6685e-05, 9.9987e-01, 6.7679e-05, 5.0376e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.3783e-13, 1.0000e+00, 2.0192e-12, 1.0986e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9290e-16, 1.0000e+00, 4.5866e-16, 2.1294e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "212000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6561e-21, 8.2689e-14, 2.4667e-21, 1.8029e-21],\n", + " [4.2665e-31, 3.6909e-20, 2.5010e-31, 1.5599e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6756e-05, 9.9986e-01, 6.7964e-05, 5.0587e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.4669e-13, 1.0000e+00, 2.0433e-12, 1.1116e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9608e-16, 1.0000e+00, 4.6630e-16, 2.1648e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "213000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6563e-21, 8.2059e-14, 2.4667e-21, 1.8029e-21],\n", + " [4.2742e-31, 3.6529e-20, 2.5059e-31, 1.5630e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.6827e-05, 9.9986e-01, 6.8250e-05, 5.0798e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5565e-13, 1.0000e+00, 2.0677e-12, 1.1248e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9931e-16, 1.0000e+00, 4.7404e-16, 2.2008e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "214000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6565e-21, 8.1436e-14, 2.4668e-21, 1.8029e-21],\n", + " [4.2819e-31, 3.6155e-20, 2.5108e-31, 1.5662e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6899e-05, 9.9986e-01, 6.8537e-05, 5.1011e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.6472e-13, 1.0000e+00, 2.0924e-12, 1.1381e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0261e-16, 1.0000e+00, 4.8192e-16, 2.2374e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "215000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6567e-21, 8.0816e-14, 2.4669e-21, 1.8029e-21],\n", + " [4.2895e-31, 3.5783e-20, 2.5157e-31, 1.5693e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.6971e-05, 9.9986e-01, 6.8825e-05, 5.1224e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7390e-13, 1.0000e+00, 2.1174e-12, 1.1516e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0594e-16, 1.0000e+00, 4.8992e-16, 2.2745e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "216000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6569e-21, 8.0202e-14, 2.4670e-21, 1.8029e-21],\n", + " [4.2973e-31, 3.5416e-20, 2.5207e-31, 1.5724e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7043e-05, 9.9986e-01, 6.9114e-05, 5.1437e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.8315e-13, 1.0000e+00, 2.1426e-12, 1.1652e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0933e-16, 1.0000e+00, 4.9803e-16, 2.3122e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "217000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6570e-21, 7.9595e-14, 2.4671e-21, 1.8029e-21],\n", + " [4.3050e-31, 3.5055e-20, 2.5257e-31, 1.5756e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7115e-05, 9.9986e-01, 6.9403e-05, 5.1650e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9248e-13, 1.0000e+00, 2.1679e-12, 1.1789e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1275e-16, 1.0000e+00, 5.0624e-16, 2.3503e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "218000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6572e-21, 7.8995e-14, 2.4672e-21, 1.8028e-21],\n", + " [4.3127e-31, 3.4699e-20, 2.5307e-31, 1.5788e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7187e-05, 9.9986e-01, 6.9692e-05, 5.1864e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.0191e-13, 1.0000e+00, 2.1936e-12, 1.1928e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1623e-16, 1.0000e+00, 5.1458e-16, 2.3891e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "219000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6574e-21, 7.8400e-14, 2.4673e-21, 1.8028e-21],\n", + " [4.3205e-31, 3.4346e-20, 2.5356e-31, 1.5819e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7260e-05, 9.9986e-01, 6.9983e-05, 5.2078e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1141e-13, 1.0000e+00, 2.2194e-12, 1.2068e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1975e-16, 1.0000e+00, 5.2301e-16, 2.4283e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "220000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6576e-21, 7.7812e-14, 2.4674e-21, 1.8028e-21],\n", + " [4.3283e-31, 3.4000e-20, 2.5406e-31, 1.5851e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7331e-05, 9.9986e-01, 7.0269e-05, 5.2290e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.2092e-13, 1.0000e+00, 2.2453e-12, 1.2207e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2330e-16, 1.0000e+00, 5.3151e-16, 2.4678e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "221000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6577e-21, 7.7232e-14, 2.4675e-21, 1.8028e-21],\n", + " [4.3360e-31, 3.3658e-20, 2.5456e-31, 1.5883e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7403e-05, 9.9986e-01, 7.0553e-05, 5.2500e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3052e-13, 1.0000e+00, 2.2714e-12, 1.2349e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2689e-16, 1.0000e+00, 5.4011e-16, 2.5078e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "222000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6579e-21, 7.6658e-14, 2.4676e-21, 1.8028e-21],\n", + " [4.3438e-31, 3.3322e-20, 2.5506e-31, 1.5914e-31]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.7475e-05, 9.9986e-01, 7.0841e-05, 5.2713e-05],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.4024e-13, 1.0000e+00, 2.2978e-12, 1.2491e-12],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3053e-16, 1.0000e+00, 5.4886e-16, 2.5484e-16],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "223000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [3.6580e-21, 7.6089e-14, 2.4677e-21, 1.8028e-21],\n", + " [4.3511e-31, 3.2987e-20, 2.5554e-31, 1.5945e-31]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([1.8739e-06, 9.9998e-01, 7.0537e-06, 6.8039e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9040e-15, 1.0000e+00, 1.2036e-14, 1.0447e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5162e-19, 1.0000e+00, 7.5110e-19, 6.2954e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "224000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.2021e-21, 4.5933e-13, 7.8373e-22, 7.0525e-22],\n", + " [8.1138e-32, 4.3242e-19, 4.6045e-32, 4.0010e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8663e-06, 9.9998e-01, 7.0431e-06, 6.7994e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9302e-15, 1.0000e+00, 1.2138e-14, 1.0544e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.5623e-19, 1.0000e+00, 7.6402e-19, 6.4125e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "225000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1977e-21, 4.5339e-13, 7.8135e-22, 7.0310e-22],\n", + " [8.1264e-32, 4.2575e-19, 4.6184e-32, 4.0152e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8642e-06, 9.9998e-01, 7.0533e-06, 6.8151e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9906e-15, 1.0000e+00, 1.2326e-14, 1.0717e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.6409e-19, 1.0000e+00, 7.8409e-19, 6.5903e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "226000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1933e-21, 4.4577e-13, 7.7898e-22, 7.0096e-22],\n", + " [8.1395e-32, 4.1677e-19, 4.6330e-32, 4.0301e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8691e-06, 9.9998e-01, 7.0904e-06, 6.8572e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.0938e-15, 1.0000e+00, 1.2621e-14, 1.0984e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.7604e-19, 1.0000e+00, 8.1320e-19, 6.8448e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "227000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1890e-21, 4.3630e-13, 7.7663e-22, 6.9884e-22],\n", + " [8.1523e-32, 4.0522e-19, 4.6474e-32, 4.0448e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.8814e-06, 9.9998e-01, 7.1556e-06, 6.9265e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.2430e-15, 1.0000e+00, 1.3033e-14, 1.1352e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([3.9249e-19, 1.0000e+00, 8.5230e-19, 7.1842e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "228000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1847e-21, 4.2513e-13, 7.7428e-22, 6.9672e-22],\n", + " [8.1646e-32, 3.9137e-19, 4.6614e-32, 4.0593e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9022e-06, 9.9998e-01, 7.2516e-06, 7.0259e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.4421e-15, 1.0000e+00, 1.3566e-14, 1.1827e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.1345e-19, 1.0000e+00, 9.0124e-19, 7.6070e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "229000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1808e-21, 4.1273e-13, 7.7210e-22, 6.9477e-22],\n", + " [8.1574e-32, 3.7531e-19, 4.6643e-32, 4.0635e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9293e-06, 9.9998e-01, 7.3706e-06, 7.1480e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6820e-15, 1.0000e+00, 1.4201e-14, 1.2393e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.3840e-19, 1.0000e+00, 9.5914e-19, 8.1063e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "230000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1770e-21, 3.9964e-13, 7.6999e-22, 6.9287e-22],\n", + " [8.1382e-32, 3.5814e-19, 4.6605e-32, 4.0615e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9604e-06, 9.9998e-01, 7.5044e-06, 7.2844e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.9534e-15, 1.0000e+00, 1.4916e-14, 1.3028e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.6684e-19, 1.0000e+00, 1.0248e-18, 8.6724e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "231000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1732e-21, 3.8635e-13, 7.6788e-22, 6.9097e-22],\n", + " [8.1192e-32, 3.4096e-19, 4.6562e-32, 4.0592e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([1.9944e-06, 9.9998e-01, 7.6485e-06, 7.4306e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.2497e-15, 1.0000e+00, 1.5693e-14, 1.3719e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([4.9824e-19, 1.0000e+00, 1.0973e-18, 9.2965e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "232000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1696e-21, 3.7325e-13, 7.6584e-22, 6.8912e-22],\n", + " [8.1002e-32, 3.2425e-19, 4.6517e-32, 4.0567e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.0293e-06, 9.9998e-01, 7.7958e-06, 7.5801e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.5607e-15, 1.0000e+00, 1.6510e-14, 1.4445e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.3169e-19, 1.0000e+00, 1.1745e-18, 9.9625e-19],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "233000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1661e-21, 3.6068e-13, 7.6383e-22, 6.8732e-22],\n", + " [8.0817e-32, 3.0845e-19, 4.6472e-32, 4.0539e-32]],\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------\n", + "probs= tensor([2.0649e-06, 9.9998e-01, 7.9456e-06, 7.7319e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8864e-15, 1.0000e+00, 1.7364e-14, 1.5205e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([5.6721e-19, 1.0000e+00, 1.2566e-18, 1.0670e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "234000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1627e-21, 3.4864e-13, 7.6191e-22, 6.8558e-22],\n", + " [8.0629e-32, 2.9353e-19, 4.6420e-32, 4.0505e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1010e-06, 9.9998e-01, 8.0969e-06, 7.8850e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2241e-15, 1.0000e+00, 1.8251e-14, 1.5992e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.0458e-19, 1.0000e+00, 1.3430e-18, 1.1415e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "235000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1593e-21, 3.3718e-13, 7.6001e-22, 6.8386e-22],\n", + " [8.0442e-32, 2.7955e-19, 4.6366e-32, 4.0469e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1371e-06, 9.9998e-01, 8.2483e-06, 8.0383e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.5704e-15, 1.0000e+00, 1.9161e-14, 1.6802e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.4349e-19, 1.0000e+00, 1.4331e-18, 1.2194e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "236000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1561e-21, 3.2638e-13, 7.5817e-22, 6.8219e-22],\n", + " [8.0260e-32, 2.6656e-19, 4.6314e-32, 4.0435e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.1741e-06, 9.9998e-01, 8.4019e-06, 8.1937e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.9308e-15, 1.0000e+00, 2.0104e-14, 1.7641e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([6.8451e-19, 1.0000e+00, 1.5279e-18, 1.3012e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "237000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1530e-21, 3.1609e-13, 7.5634e-22, 6.8054e-22],\n", + " [8.0087e-32, 2.5438e-19, 4.6259e-32, 4.0396e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2119e-06, 9.9998e-01, 8.5570e-06, 8.3502e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.3033e-15, 1.0000e+00, 2.1076e-14, 1.8505e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.2746e-19, 1.0000e+00, 1.6269e-18, 1.3867e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "238000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1500e-21, 3.0635e-13, 7.5454e-22, 6.7890e-22],\n", + " [7.9921e-32, 2.4300e-19, 4.6200e-32, 4.0353e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2493e-06, 9.9998e-01, 8.7101e-06, 8.5046e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6830e-15, 1.0000e+00, 2.2065e-14, 1.9383e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([7.7184e-19, 1.0000e+00, 1.7289e-18, 1.4748e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "239000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1472e-21, 2.9719e-13, 7.5282e-22, 6.7733e-22],\n", + " [7.9756e-32, 2.3244e-19, 4.6137e-32, 4.0305e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.2852e-06, 9.9998e-01, 8.8569e-06, 8.6527e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.0607e-15, 1.0000e+00, 2.3049e-14, 2.0259e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.1668e-19, 1.0000e+00, 1.8323e-18, 1.5641e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "240000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1444e-21, 2.8863e-13, 7.5112e-22, 6.7577e-22],\n", + " [7.9594e-32, 2.2273e-19, 4.6076e-32, 4.0259e-32]],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([2.3208e-06, 9.9998e-01, 9.0035e-06, 8.8009e-06],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([9.4438e-15, 1.0000e+00, 2.4051e-14, 2.1151e-14],\n", + " grad_fn=)\n", + "------------------------------\n", + "probs= tensor([8.6263e-19, 1.0000e+00, 1.9387e-18, 1.6561e-18],\n", + " grad_fn=)\n", + "--------------------------------------------------\n", + "241000 actions: tensor([1, 1, 1])\n", + "loss= tensor(2.9637, grad_fn=) , return= 16061.75\n", + "discReturns/1000= tensor([6.4135, 6.5111, 5.5493])\n", + "actionProbs tensor([[1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00],\n", + " [1.1417e-21, 2.8058e-13, 7.4950e-22, 6.7429e-22],\n", + " [7.9413e-32, 2.1366e-19, 4.6005e-32, 4.0204e-32]],\n", + " grad_fn=)\n" + ] + } + ], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "advModeNames=\"\"\n", + "for i in range(len(adversaryProbs)):\n", + " if adversaryProbs[i]!=0:\n", + " tmp=\"{:.1f}\".format(adversaryProbs[i])\n", + " advModeNames+=f\"{(AdversaryModes(i)).name}-{tmp}-\"\n", + " \n", + "name=f\"ep {algorithm.numberEpisodes}, {advModeNames}, {game.advHistoryNum} hist, {neuralNet.lr} lr\"\n", + "neuralNet.save(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T\n", + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0),columns=['entry'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "loss = pd.DataFrame(algorithm.loss.mean(axis = 0),columns=['entry'])\n", + "loss.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "demandPotential.plot()\n", + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 16041.703125\n", + "1 11864.703125\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05112.2500004160.250000
15361.5625003937.562500
25567.8906253766.890625
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5112.250000 4160.250000\n", + "1 5361.562500 3937.562500\n", + "2 5567.890625 3766.890625" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()\n", + "profits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0128.500135.500
1128.250133.750
2130.625132.375
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 128.500 135.500\n", + "1 128.250 133.750\n", + "2 130.625 132.375" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()\n", + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAV6ElEQVR4nO3de5Cd9X3f8ffXWl3ANiAkkcGIWjhYDSAIscTFQ6FcSkwcbBEbammE0dhM5FJHk8YpLZShJLU9A8QeUmDqAkHcGi4y5qIaY9kYc7HjSl1qHEuWFZaLywJjrUARl0ZgiW//OL+Fo/3t6qyO9iLtvl8zZ86j7/N7nvP7Ys9+9rmcZyMzkSSp2XtGewKSpN2P4SBJqhgOkqSK4SBJqhgOkqRKx2hPoF3Tp0/PWbNmjfY0JGmP8sQTT2zMzBmtxu2x4TBr1iw6OztHexqStEeJiF8NZpynlSRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJlT32ew7t2vxPv+F3//J7oz0NSWrbL798BlMmThjWzxh3Rw4Gg6Q93e9c+t1h/4xxFw6SpNYMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSpWU4RMSyiNgQEWv61JdGxPqIWBsRV5ba6RHxRET8vLyf2jR+bql3RcTVERGlPjki7ir1VRExa4h7lCTtpMEcOdwMnNFciIhTgPnAUZl5BPC1smoj8InMPBJYDNzWtNk3gCXAh8urd5/nA5sy81DgKuCKtjqRJA2ZluGQmY8Br/QpXwBcnplvljEbyvtPM/PFMmYtMKUcGRwI7JOZP8nMBG4Fzirj5gO3lOW7gdN6jyokSaOj3WsOs4ETy2mgRyPimH7GfBr4aQmQg4DupnXdpUZ5fx4gM7cCm4Fp/X1oRCyJiM6I6Ozp6Wlz6pKkVtoNhw5gKnA8cCGwvPm3/Yg4gsbpoS/0lvrZRw5i3fbFzOszc15mzpsxY0abU5cktdJuOHQD92TDauBtYDpARMwE7gXOy8ynm8bPbNp+JvBi07qDy7YdwL7Up7EkSSOo3XC4DzgVICJmA5OAjRGxH/AAcHFm/rh3cGa+BLwWEceXI4zzgPvL6hU0Ll4DnA08XK5LSJJGyWBuZb0D+AnwzyOiOyLOB5YBHyq3t94JLC4/0P8EOBS4NCKeLK8Dyq4uAP4G6AKeBh4s9RuBaRHRBXwJuGjo2pMktaOj1YDMXDjAqnP7GfsV4CsD7KcTmNNPfQtwTqt5SJJGjt+QliRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUqVlOETEsojYEBFr+tSXRsT6iFgbEVeW2rSI+GFEvB4R1/YZ/0gZ/2R5HVDqkyPirojoiohVETFrCPuTJLWhYxBjbgauBW7tLUTEKcB84KjMfLP3Bz2wBbgUmFNefS3KzM4+tfOBTZl5aEQsAK4APrNTXUiShlTLI4fMfAx4pU/5AuDyzHyzjNlQ3t/IzB/RCInBmg/cUpbvBk6LiNiJ7SVJQ6zdaw6zgRPLaaBHI+KYQW53UzmldGlTABwEPA+QmVuBzcC0/jaOiCUR0RkRnT09PW1OXZLUSrvh0AFMBY4HLgSWD+K3/UWZeSRwYnl9ttT72y7720FmXp+Z8zJz3owZM9qbuSSppXbDoRu4JxtWA28D03e0QWa+UN5fA24Hjm3a18EAEdEB7Et9GkuSNILaDYf7gFMBImI2MAnYONDgiOiIiOlleSJwJtB799MKYHFZPht4ODP7PXKQJI2MlncrRcQdwMnA9IjoBi4DlgHLyu2tbwGLe3+gR8RzwD7ApIg4C/h94FfAyhIME4CHgBvKR9wI3BYRXTSOGBYMVXOSpPa0DIfMXDjAqnMHGD9rgPFzBxi/BTin1TwkSSPHb0hLkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySp0jIcImJZRGyIiDV96ksjYn1ErI2IK0ttWkT8MCJej4hr+4yfGxE/j4iuiLg6IqLUJ0fEXaW+KiJmDWF/kqQ2DObI4WbgjOZCRJwCzAeOyswjgK+VVVuAS4F/389+vgEsAT5cXr37PB/YlJmHAlcBV+xcC5KkodYyHDLzMeCVPuULgMsz880yZkN5fyMzf0QjJN4REQcC+2TmTzIzgVuBs8rq+cAtZflu4LTeowpJ0uho95rDbODEchro0Yg4psX4g4Dupn93l1rvuucBMnMrsBmY1t9OImJJRHRGRGdPT0+bU5cktdJuOHQAU4HjgQuB5S1+2+9vXQ5i3fbFzOszc15mzpsxY8bOzFeStBPaDYdu4J5sWA28DUxvMX5m079nAi82rTsYICI6gH2pT2NJkkZQu+FwH3AqQETMBiYBGwcanJkvAa9FxPHlCOM84P6yegWwuCyfDTxcrktIkkZJR6sBEXEHcDIwPSK6gcuAZcCycnvrW8Di3h/oEfEcsA8wKSLOAn4/M39B4yL2zcBewIPlBXAjcFtEdNE4YlgwRL1JktrUMhwyc+EAq84dYPysAeqdwJx+6luAc1rNQ5I0cvyGtCSpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySpYjhIkiqGgySp0jIcImJZRGyIiDV96ksjYn1ErI2IK5vqF0dEV1n3sab6I6X2ZHkdUOqTI+Kuss2qiJg1hP1JktrQMYgxNwPXArf2FiLiFGA+cFRmvtn0g/5wYAFwBPAB4KGImJ2Z28qmizKzs8/+zwc2ZeahEbEAuAL4zC70JEnaRS2PHDLzMeCVPuULgMsz880yZkOpzwfuzMw3M/NZoAs4tsVHzAduKct3A6dFRAxy/pKkYdDuNYfZwInlNNCjEXFMqR8EPN80rrvUet1UTild2hQA72yTmVuBzcC0/j40IpZERGdEdPb09LQ5dUlSK+2GQwcwFTgeuBBYXn7Y9/cbf5b3RZl5JHBieX221He0zfbFzOszc15mzpsxY0abU5cktdJuOHQD92TDauBtYHqpH9w0bibwIkBmvlDeXwNu593TTe9sExEdwL7Up7EkSSOo3XC4DzgVICJmA5OAjcAKYEG5A+kQ4MPA6ojoiIjpZfxE4Eyg9+6nFcDisnw28HBm9nvkIEkaGS3vVoqIO4CTgekR0Q1cBiwDlpXbW98CFpcf6GsjYjnwC2Ar8MXM3BYR7wVWlmCYADwE3FA+4kbgtojoonHEsGAoG5Qk7byW4ZCZCwdYde4A478KfLVP7Q1g7gDjtwDntJqHJGnk+A1pSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVVqGQ0Qsi4gNEbGmT31pRKyPiLURcWVT/eKI6CrrPtZUnxsRPy/rro6IKPXJEXFXqa+KiFlD2J8kqQ2DOXK4GTijuRARpwDzgaMy8wjga6V+OLAAOKJs898iYkLZ7BvAEuDD5dW7z/OBTZl5KHAVcMUu9CNJGgItwyEzHwNe6VO+ALg8M98sYzaU+nzgzsx8MzOfBbqAYyPiQGCfzPxJZiZwK3BW0za3lOW7gdN6jyokSaOj3WsOs4ETy2mgRyPimFI/CHi+aVx3qR1UlvvWt9smM7cCm4Fp/X1oRCyJiM6I6Ozp6Wlz6pKkVtoNhw5gKnA8cCGwvPy2399v/LmDOi3WbV/MvD4z52XmvBkzZuz8rCVJg9JuOHQD92TDauBtYHqpH9w0bibwYqnP7KdO8zYR0QHsS30aS5I0gtoNh/uAUwEiYjYwCdgIrAAWlDuQDqFx4Xl1Zr4EvBYRx5cjjPOA+8u+VgCLy/LZwMPluoQkaZR0tBoQEXcAJwPTI6IbuAxYBiwrt7e+BSwuP9DXRsRy4BfAVuCLmbmt7OoCGnc+7QU8WF4ANwK3RUQXjSOGBUPTmiSpXS3DITMXDrDq3AHGfxX4aj/1TmBOP/UtwDmt5iFJGjl+Q1qSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEmVll+Ck6Q93T6T38PS46bywf0mEv0+63PPs27duh2unzJlCjNnzmTixIlt7d9wkDTmLT1uKh/57Q/Qsff7GSt/LuawmfsNuC4zefnll+nu7uaQQw5pa/+eVpI05n1wv4ljKhhaiQimTZvGli1b2t6H4SBpzAti3ARDr13t13CQJFUMB0nazTz83Qd4+h9+OapzMBwkaTfzw5UP8MxT6/tdt3Xr1hGZg3crSRpXbnj8GZ7teWNI93nIjPfyxyd+aIdjvn3PXdy+7Hq2/uYt5vzeXC756tc54fAPsujzX+CxH6xk8pS9+K83/i3P/+pZHvn+g3Su+jE3XP01vn7drfzFhUv53bnH8mTnKo494SRWfPN2nn26i4kTJ/Lqq69y1FFH8dRTT7V922p/PHKQpGH2zFPrWfk/7+WWe7/L8pWPM+E9E/jOvd/kn/7fGxz5kXl883s/Yu5xH+Vbt9/K0fOO4+TT/4AvXfJfWL7ycQ6e1bgV9bVXN7Ps7gf4N3/2H/noCSfxwAMPAHDnnXfy6U9/ekiDATxykDTOtPoNfzis+vGjrPv7n7HozFMB2LJlC/tPn8HESZP4l//qDAAOO/Jo/tfjjwy4j4994lPvLH/m3MXcdP01nHXWWdx0003ccMMNQz5nw0GShlkmfOKcBfzpRZdtV7/lumvfueV0woQJbNvB9YS99t77neV5x32UL/+nP+fRRx9l27ZtzJlT/QXmXeZpJUkaZsedcBIPPbCClzf2ALB50yZe7P6/A47f+33v443XX9/hPs877zwWLlzI5z73uSGday/DQZKG2W/P/h2+eOElXLDoU5x9+gl8YdEfsXHDrwccf8YnP8Ut113Dvz7jJJ5/7tlqfQQsWrSITZs2sXDhwmGZc2TmsOx4uM2bNy87Ozt3ers1L2zmzGt+NAwzkrS7uuGTB/Jb/2zkrzUMlzkf2Jd77vkW999/P7fddtuA49atW8dhhx22XS0insjMea0+Y9xdc5hz0L48d/kfjvY0JI2gdevW7fBBdXuapUuX8uCDD/Kd73xn2D5j3IWDJO3prrnmmmH/DK85SBoX9tRT6O3a1X4NB0lj3pQpU3j55ZfHTUD0/j2HKVOmtL0PTytJGvNmzpxJd3c3PT09oz2VEdP7l+DaZThIGvMmTpzY9l9EG69anlaKiGURsSEi1jTV/iIiXoiIJ8vr46U+KSJuioifR8TPIuLkpm0eiYj1TdscUOqTI+KuiOiKiFURMWvIu5Qk7ZTBXHO4GTijn/pVmXl0efXeT/XHAJl5JHA68PWIaP6MRU3bbCi184FNmXkocBVwRTuNSJKGTstwyMzHgFcGub/DgR+U7TYA/wi0+rLFfOCWsnw3cFqMt7/nJ0m7mV255vAnEXEe0An8eWZuAn4GzI+IO4GDgbnlfXXZ5qaI2AZ8C/hKNm4dOAh4HiAzt0bEZmAasLHvB0bEEmBJ+efrEdH/X8NobXp/+x/j7Hl8sOfxYVd6/uBgBrUbDt8Avgxkef868HlgGXAYjcD4FfB3QO9jBhdl5gsR8X4a4fBZ4Fagv6OEfu83y8zrgevbnPM7IqJzMF8fH0vseXyw5/FhJHpu63sOmfnrzNyWmW8DNwDHlvrWzPyzck1hPrAf8FRZ90J5fw24vXcboJvG0QUR0QHsy+BPY0mShkFb4RARBzb984+ANaW+d0S8tyyfDmzNzF9EREdETC/1icCZvdsAK4DFZfls4OEcL99UkaTdVMvTShFxB3AyMD0iuoHLgJMj4mgap3+eA75Qhh8ArIyIt4EXaJw6Aphc6hOBCcBDNI44AG4EbouILhpHDAt2uavWdvnU1B7InscHex4fhr3nPfaR3ZKk4eOzlSRJFcNBklQZd+EQEWeUx3h0RcRFoz2fVgZ4fMn+EfH9iHiqvE9tWndx6W19RHysqT63PNakKyKu7v2i4Y4eXxIRi8tnPBURvTcNDLuIODgifhgR6yJibUT86VjvOyKmRMTq8tiZtRHxl2O95/K5EyLipxHx7XHS73Nlrk9GROdu3XNmjpsXjYvhTwMfAibR+NLe4aM9rxZzPgn4CLCmqXYlcFFZvgi4oiwfXnqaDBxSep1Q1q0GPkrjeyUPAn9Q6v8W+O9leQFwV1neH3imvE8ty1NHqOcDgY+U5fcD/1B6G7N9l/m9ryxPBFYBx4/lnstnf4nGre3fHif/334OmN6ntlv2POz/MXanV/mPubLp3xcDF4/2vAYx71lsHw7rgQPL8oHA+v76AVaWng8EftlUXwhc1zymLHfQ+NZlNI8p664DFo5S//fTeFbXuOgb2Bv4P8BxY7lnYCaNx+2cyrvhMGb7LZ/1HHU47JY9j7fTSu88qqPoLrU9zW9l5ksA5f2AUh+ov4PKct/6dttk5lag9/Elu8V/q3JY/Hs0fpMe032XUyxPAhuA72fmWO/5r4H/ALzdVBvL/ULj9v/vRcQT0XgcEOymPY+3v+cw6Ed17KEG6m9HfbezzYiIiPfReNTKv8vMV2Pg5zGOib4zcxtwdETsB9wbEXN2MHyP7jkizgQ2ZOYT0fRo/x1t0k9tj+m3yQmZ+WI0/mTB9yPilzsYO6o9j7cjh3ce1VHMBF4cpbnsil9H+ZZ6ee99/PlA/XWX5b717baJ7R9fMqr/raLxhclvAX+bmfeU8pjvGyAz/xF4hMaj8sdqzycAn4yI54A7gVMj4n8wdvsFIDNfLO8bgHtpPEZo9+x5JM6z7S4vGkdKz9C4uNN7QfqI0Z7XIOY9i+2vOfwV21/AurIsH8H2F7Ce4d0LWP+bxgXO3gtYHy/1L7L9BazlZXl/4FkaF6+mluX9R6jfoPFQxr/uUx+zfQMzgP3K8l7A4zQeMzNme27q/WTeveYwZvsF3gu8v2n572j8ArBb9jwi/+PvTi/g4zTufnkauGS05zOI+d4BvAT8hkb6n0/jHOIPaDzU8AfN/yMDl5Te1lPuYCj1eTSeZ/U0cC3vfjt+CvBNoIvGHRAfatrm86XeBXxuBHv+FzQOef8eeLK8Pj6W+waOAn5ael4D/OdSH7M9N332ybwbDmO2Xxp3Sf6svNZSfv7srj37+AxJUmW8XXOQJA2C4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqTK/wcdAfGf2QDgowAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# pricelearning = pd.DataFrame(game.prices.mean(axis = 0))\n", + "# pricelearning.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "learning_1 = learning.to_numpy()\n", + "learning_2 = [0]*len(learning)\n", + "for i in range(len(learning_1)):\n", + " learning_2[i] = learning_1[i][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "avg_learning = np.convolve(learning_2, np.ones(1000)/1000, mode = 'valid')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(avg_learning)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidIndexError", + "evalue": "(slice(None, None, None), None)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3621\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3620\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 3621\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3622\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:136\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\_libs\\index.pyx:142\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: '(slice(None, None, None), None)' is an invalid key", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mInvalidIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [18]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlearning\u001b[49m\u001b[43m,\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\pyplot.py:2757\u001b[0m, in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 2755\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mplot)\n\u001b[0;32m 2756\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot\u001b[39m(\u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, scaley\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m-> 2757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m gca()\u001b[38;5;241m.\u001b[39mplot(\n\u001b[0;32m 2758\u001b[0m \u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39mscalex, scaley\u001b[38;5;241m=\u001b[39mscaley,\n\u001b[0;32m 2759\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m\"\u001b[39m: data} \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {}), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_axes.py:1632\u001b[0m, in \u001b[0;36mAxes.plot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1391\u001b[0m \u001b[38;5;124;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[0;32m 1392\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1629\u001b[0m \u001b[38;5;124;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[0;32m 1630\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1631\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m cbook\u001b[38;5;241m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[38;5;241m.\u001b[39mLine2D)\n\u001b[1;32m-> 1632\u001b[0m lines \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_lines(\u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39mdata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)]\n\u001b[0;32m 1633\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[0;32m 1634\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_line(line)\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:312\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[1;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m 310\u001b[0m this \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m0\u001b[39m],\n\u001b[0;32m 311\u001b[0m args \u001b[38;5;241m=\u001b[39m args[\u001b[38;5;241m1\u001b[39m:]\n\u001b[1;32m--> 312\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\axes\\_base.py:487\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[1;34m(self, tup, kwargs, return_kwargs)\u001b[0m\n\u001b[0;32m 484\u001b[0m kw[prop_name] \u001b[38;5;241m=\u001b[39m val\n\u001b[0;32m 486\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(xy) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[1;32m--> 487\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43m_check_1d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxy\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 488\u001b[0m y \u001b[38;5;241m=\u001b[39m _check_1d(xy[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m 489\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\matplotlib\\cbook\\__init__.py:1327\u001b[0m, in \u001b[0;36m_check_1d\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m warnings\u001b[38;5;241m.\u001b[39mcatch_warnings(record\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m w:\n\u001b[0;32m 1322\u001b[0m warnings\u001b[38;5;241m.\u001b[39mfilterwarnings(\n\u001b[0;32m 1323\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1324\u001b[0m category\u001b[38;5;241m=\u001b[39m\u001b[38;5;167;01mWarning\u001b[39;00m,\n\u001b[0;32m 1325\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSupport for multi-dimensional indexing\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m-> 1327\u001b[0m ndim \u001b[38;5;241m=\u001b[39m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mndim\n\u001b[0;32m 1328\u001b[0m \u001b[38;5;66;03m# we have definitely hit a pandas index or series object\u001b[39;00m\n\u001b[0;32m 1329\u001b[0m \u001b[38;5;66;03m# cast to a numpy array.\u001b[39;00m\n\u001b[0;32m 1330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(w) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\frame.py:3505\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 3503\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m 3504\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[1;32m-> 3505\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3506\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[0;32m 3507\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:3628\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m 3623\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[0;32m 3624\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[0;32m 3625\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[0;32m 3626\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[0;32m 3627\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m-> 3628\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_check_indexing_error\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3629\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m 3631\u001b[0m \u001b[38;5;66;03m# GH#42269\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\Anaconda\\lib\\site-packages\\pandas\\core\\indexes\\base.py:5637\u001b[0m, in \u001b[0;36mIndex._check_indexing_error\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 5633\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_check_indexing_error\u001b[39m(\u001b[38;5;28mself\u001b[39m, key):\n\u001b[0;32m 5634\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_scalar(key):\n\u001b[0;32m 5635\u001b[0m \u001b[38;5;66;03m# if key is not a scalar, directly raise an error (the code below\u001b[39;00m\n\u001b[0;32m 5636\u001b[0m \u001b[38;5;66;03m# would convert to numpy arrays and raise later any way) - GH29926\u001b[39;00m\n\u001b[1;32m-> 5637\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n", + "\u001b[1;31mInvalidIndexError\u001b[0m: (slice(None, None, None), None)" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAANQklEQVR4nO3cX4il9X3H8fenuxEak0aJk5DurmRb1pi90KITI6VpTUObXXuxBLxQQ6QSWKQx5FIpNLnwprkohKBmWWSR3GQvGkk2ZRMplMSCNd1Z8N8qynSlOl3BNYYUDFRWv704p51hnHWenXNmZp3v+wUD85znNzPf+TH73mfPznlSVUiStr7f2ewBJEkbw+BLUhMGX5KaMPiS1ITBl6QmDL4kNbFq8JMcSfJakmfPcz5JvptkPsnTSa6b/piSpEkNucJ/GNj3Huf3A3vGbweB700+liRp2lYNflU9BrzxHksOAN+vkSeAy5J8YloDSpKmY/sUPscO4JUlxwvjx15dvjDJQUb/CuDSSy+9/uqrr57Cl5ekPk6ePPl6Vc2s5WOnEfys8NiK92uoqsPAYYDZ2dmam5ubwpeXpD6S/OdaP3Yav6WzAOxacrwTODOFzytJmqJpBP8YcMf4t3VuBH5TVe96OkeStLlWfUonyQ+Am4ArkiwA3wI+AFBVh4DjwM3APPBb4M71GlaStHarBr+qblvlfAFfm9pEkqR14SttJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJamJQ8JPsS/JCkvkk965w/iNJfpLkqSSnktw5/VElSZNYNfhJtgEPAPuBvcBtSfYuW/Y14Lmquha4CfiHJJdMeVZJ0gSGXOHfAMxX1emqegs4ChxYtqaADycJ8CHgDeDcVCeVJE1kSPB3AK8sOV4YP7bU/cCngTPAM8A3quqd5Z8oycEkc0nmzp49u8aRJUlrMST4WeGxWnb8ReBJ4PeBPwLuT/J77/qgqsNVNVtVszMzMxc4qiRpEkOCvwDsWnK8k9GV/FJ3Ao/UyDzwEnD1dEaUJE3DkOCfAPYk2T3+j9hbgWPL1rwMfAEgyceBTwGnpzmoJGky21dbUFXnktwNPApsA45U1akkd43PHwLuAx5O8gyjp4DuqarX13FuSdIFWjX4AFV1HDi+7LFDS94/A/zldEeTJE2Tr7SVpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDUxKPhJ9iV5Icl8knvPs+amJE8mOZXkF9MdU5I0qe2rLUiyDXgA+AtgATiR5FhVPbdkzWXAg8C+qno5ycfWaV5J0hoNucK/AZivqtNV9RZwFDiwbM3twCNV9TJAVb023TElSZMaEvwdwCtLjhfGjy11FXB5kp8nOZnkjpU+UZKDSeaSzJ09e3ZtE0uS1mRI8LPCY7XseDtwPfBXwBeBv0ty1bs+qOpwVc1W1ezMzMwFDytJWrtVn8NndEW/a8nxTuDMCmter6o3gTeTPAZcC7w4lSklSRMbcoV/AtiTZHeSS4BbgWPL1vwY+FyS7Uk+CHwWeH66o0qSJrHqFX5VnUtyN/AosA04UlWnktw1Pn+oqp5P8jPgaeAd4KGqenY9B5ckXZhULX86fmPMzs7W3NzcpnxtSXq/SnKyqmbX8rG+0laSmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmBgU/yb4kLySZT3Lve6z7TJK3k9wyvRElSdOwavCTbAMeAPYDe4Hbkuw9z7pvA49Oe0hJ0uSGXOHfAMxX1emqegs4ChxYYd3XgR8Cr01xPknSlAwJ/g7glSXHC+PH/l+SHcCXgEPv9YmSHEwyl2Tu7NmzFzqrJGkCQ4KfFR6rZcffAe6pqrff6xNV1eGqmq2q2ZmZmYEjSpKmYfuANQvAriXHO4Ezy9bMAkeTAFwB3JzkXFX9aBpDSpImNyT4J4A9SXYD/wXcCty+dEFV7f6/95M8DPyTsZeki8uqwa+qc0nuZvTbN9uAI1V1Ksld4/Pv+by9JOniMOQKn6o6Dhxf9tiKoa+qv558LEnStPlKW0lqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSE4OCn2RfkheSzCe5d4XzX07y9Pjt8STXTn9USdIkVg1+km3AA8B+YC9wW5K9y5a9BPxZVV0D3AccnvagkqTJDLnCvwGYr6rTVfUWcBQ4sHRBVT1eVb8eHz4B7JzumJKkSQ0J/g7glSXHC+PHzuerwE9XOpHkYJK5JHNnz54dPqUkaWJDgp8VHqsVFyafZxT8e1Y6X1WHq2q2qmZnZmaGTylJmtj2AWsWgF1LjncCZ5YvSnIN8BCwv6p+NZ3xJEnTMuQK/wSwJ8nuJJcAtwLHli5IciXwCPCVqnpx+mNKkia16hV+VZ1LcjfwKLANOFJVp5LcNT5/CPgm8FHgwSQA56pqdv3GliRdqFSt+HT8upudna25ublN+dqS9H6V5ORaL6h9pa0kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNGHxJasLgS1ITBl+SmjD4ktSEwZekJgy+JDVh8CWpCYMvSU0YfElqwuBLUhMGX5KaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrC4EtSEwZfkpow+JLUhMGXpCYMviQ1YfAlqQmDL0lNDAp+kn1JXkgyn+TeFc4nyXfH559Oct30R5UkTWLV4CfZBjwA7Af2Arcl2bts2X5gz/jtIPC9Kc8pSZrQkCv8G4D5qjpdVW8BR4EDy9YcAL5fI08AlyX5xJRnlSRNYPuANTuAV5YcLwCfHbBmB/Dq0kVJDjL6FwDA/yR59oKm3bquAF7f7CEuEu7FIvdikXux6FNr/cAhwc8Kj9Ua1lBVh4HDAEnmqmp2wNff8tyLRe7FIvdikXuxKMncWj92yFM6C8CuJcc7gTNrWCNJ2kRDgn8C2JNkd5JLgFuBY8vWHAPuGP+2zo3Ab6rq1eWfSJK0eVZ9SqeqziW5G3gU2AYcqapTSe4anz8EHAduBuaB3wJ3Dvjah9c89dbjXixyLxa5F4vci0Vr3otUveupdknSFuQrbSWpCYMvSU2se/C9LcOiAXvx5fEePJ3k8STXbsacG2G1vViy7jNJ3k5yy0bOt5GG7EWSm5I8meRUkl9s9IwbZcCfkY8k+UmSp8Z7MeT/C993khxJ8tr5Xqu05m5W1bq9MfpP3v8A/gC4BHgK2Ltszc3ATxn9Lv+NwC/Xc6bNehu4F38MXD5+f3/nvViy7l8Y/VLALZs99yb+XFwGPAdcOT7+2GbPvYl78bfAt8fvzwBvAJds9uzrsBd/ClwHPHue82vq5npf4XtbhkWr7kVVPV5Vvx4fPsHo9Qxb0ZCfC4CvAz8EXtvI4TbYkL24HXikql4GqKqtuh9D9qKADycJ8CFGwT+3sWOuv6p6jNH3dj5r6uZ6B/98t1y40DVbwYV+n19l9Df4VrTqXiTZAXwJOLSBc22GIT8XVwGXJ/l5kpNJ7tiw6TbWkL24H/g0oxd2PgN8o6re2ZjxLipr6uaQWytMYmq3ZdgCBn+fST7PKPh/sq4TbZ4he/Ed4J6qent0MbdlDdmL7cD1wBeA3wX+LckTVfXieg+3wYbsxReBJ4E/B/4Q+Ock/1pV/73Os11s1tTN9Q6+t2VYNOj7THIN8BCwv6p+tUGzbbQhezELHB3H/grg5iTnqupHGzLhxhn6Z+T1qnoTeDPJY8C1wFYL/pC9uBP4+xo9kT2f5CXgauDfN2bEi8aaurneT+l4W4ZFq+5FkiuBR4CvbMGrt6VW3Yuq2l1Vn6yqTwL/CPzNFow9DPsz8mPgc0m2J/kgo7vVPr/Bc26EIXvxMqN/6ZDk44zuHHl6Q6e8OKypm+t6hV/rd1uG952Be/FN4KPAg+Mr23O1Be8QOHAvWhiyF1X1fJKfAU8D7wAPVdWWu7X4wJ+L+4CHkzzD6GmNe6pqy902OckPgJuAK5IsAN8CPgCTddNbK0hSE77SVpKaMPiS1ITBl6QmDL4kNWHwJakJgy9JTRh8SWrifwHXe3WluIZOawAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(learning,loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/learningAgents/pdfs/CoSAC_vs_CoPPO.pdf b/learningAgents/pdfs/CoSAC_vs_CoPPO.pdf new file mode 100644 index 0000000..61d43e0 Binary files /dev/null and b/learningAgents/pdfs/CoSAC_vs_CoPPO.pdf differ diff --git a/learningAgents/pdfs/DQN_lower_lr_better_performance.pdf b/learningAgents/pdfs/DQN_lower_lr_better_performance.pdf new file mode 100644 index 0000000..37c3089 Binary files /dev/null and b/learningAgents/pdfs/DQN_lower_lr_better_performance.pdf differ diff --git a/learningAgents/pdfs/DQN_short_onehot_failed.pdf b/learningAgents/pdfs/DQN_short_onehot_failed.pdf new file mode 100644 index 0000000..5798f9d Binary files /dev/null and b/learningAgents/pdfs/DQN_short_onehot_failed.pdf differ diff --git a/learningAgents/pdfs/PPO_lower_lr_better_performance.pdf b/learningAgents/pdfs/PPO_lower_lr_better_performance.pdf new file mode 100644 index 0000000..83593e4 Binary files /dev/null and b/learningAgents/pdfs/PPO_lower_lr_better_performance.pdf differ diff --git a/learningAgents/pdfs/PPO_short_onehot_failed.pdf b/learningAgents/pdfs/PPO_short_onehot_failed.pdf new file mode 100644 index 0000000..0fde51e Binary files /dev/null and b/learningAgents/pdfs/PPO_short_onehot_failed.pdf differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/CoPPO_population_game.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/CoPPO_population_game.py new file mode 100644 index 0000000..bc975d6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/CoPPO_population_game.py @@ -0,0 +1,222 @@ + +import classes as cl +import globals as gl +from environments import ConPricingGame +import gymnasium as gym +from gymnasium import spaces +import numpy as np +from stable_baselines3 import PPO +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys + + + +alg = PPO +env_class = ConPricingGame + +alg_name = "CoPPO" +num_rounds = 10 + + +def training(env_class, costs, adv_mixed_strategy, target_payoff, num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows = [] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + + equilibria = [] + gl.initialize() + + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694305175") + strtH2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694433350") + strtH3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694840414") + strtH4 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695061323") + strtH5 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695181113") + strtH6 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695297225") + strtH7 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695349867") + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694948003") + strtL2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695021123") + strtL3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695101545") + + low_cost_strategies=[strt1, strt2, strt3,strtL1,strtL2,strtL3] + high_cost_strategies=[strt1, strt2, strt3, strtH1, strtH2,strtH3,strtH4,strtH5,strtH6,strtH7] + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=low_cost_strategies, high_cost_strategies=high_cost_strategies, env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/bimatrix.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/classes.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/classes.py new file mode 100644 index 0000000..8942871 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/classes.py @@ -0,0 +1,441 @@ +from enum import Enum +import numpy as np +import globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open("game.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + with open('progress.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + path = 'results.xlsx' if (file_name is None) else file_name + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel('results.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel('trained_agents.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/columnprint.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/environments.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/environments.py new file mode 100644 index 0000000..ee64d39 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/environments.py @@ -0,0 +1,178 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (price_pair[1-player] - price)/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/game.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/game.txt new file mode 100644 index 0000000..7254114 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/game.txt @@ -0,0 +1,16 @@ +6 14 + + 140 139 139 129 130 131 118 118 117 117 123 117 121 120 + 139 128 128 119 121 122 96 98 96 95 108 95 102 100 + 155 169 142 147 148 148 142 143 141 141 146 141 143 145 + 160 183 146 148 149 149 136 138 135 134 142 134 138 138 + 152 163 151 141 142 142 129 129 129 128 135 128 132 131 + 165 197 145 153 154 155 141 144 140 139 147 139 144 144 + + 94 95 95 102 101 101 109 109 109 110 106 110 107 108 + 95 104 104 110 109 108 129 127 128 129 119 129 124 125 + 80 69 79 83 83 83 80 82 81 80 82 81 82 82 + 76 58 84 83 82 82 89 88 90 90 86 90 88 88 + 83 75 84 91 90 90 97 97 98 98 94 98 96 96 + 69 46 79 76 75 75 81 80 82 82 79 82 80 80 + diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694784544.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694784544.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694784544.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694785129.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694785129.txt new file mode 100644 index 0000000..f98a86d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694785129.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 129 + 155 169 142 150 + 168 219 117 143 + + 94 95 95 98 + 95 104 104 102 + 80 69 79 82 + 58 19 67 58 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694889064.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694889064.txt new file mode 100644 index 0000000..dca14e4 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1694889064.txt @@ -0,0 +1,15 @@ +3 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695021123.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695021123.txt new file mode 100644 index 0000000..4950237 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695021123.txt @@ -0,0 +1,17 @@ +4 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + 160 183 146 148 149 149 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + 76 58 84 83 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695101544.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695101544.txt new file mode 100644 index 0000000..c835b38 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695101544.txt @@ -0,0 +1,19 @@ +5 7 + + 140 139 139 129 130 131 118 + 139 128 128 119 121 121 96 + 155 169 142 147 148 148 141 + 160 183 146 148 149 149 136 + 152 163 151 141 142 142 129 + + 94 95 95 102 101 101 109 + 95 104 104 110 109 108 129 + 80 69 79 83 83 83 81 + 76 58 84 83 82 82 89 + 83 75 84 91 90 90 97 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695258416.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695258416.txt new file mode 100644 index 0000000..72d87fe --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695258416.txt @@ -0,0 +1,21 @@ +6 8 + + 140 139 139 129 130 131 118 118 + 139 128 128 119 121 121 96 98 + 155 169 142 147 148 148 141 143 + 160 183 146 148 149 149 136 138 + 152 163 151 141 142 142 129 130 + 165 197 145 153 154 155 141 144 + + 94 95 95 102 101 101 109 109 + 95 104 104 110 109 108 129 127 + 80 69 79 83 83 83 81 82 + 76 58 84 83 82 82 89 88 + 83 75 84 91 90 90 97 97 + 69 46 79 76 75 75 82 80 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695324369.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695324369.txt new file mode 100644 index 0000000..0c013d6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695324369.txt @@ -0,0 +1,21 @@ +6 9 + + 140 139 139 129 130 131 118 118 118 + 139 128 128 119 121 121 96 98 96 + 155 169 142 147 148 148 141 143 141 + 160 183 146 148 149 149 136 138 135 + 152 163 151 141 142 142 129 130 129 + 165 197 145 153 154 155 141 144 141 + + 94 95 95 102 101 101 109 109 109 + 95 104 104 110 109 108 129 127 128 + 80 69 79 83 83 83 81 82 81 + 76 58 84 83 82 82 89 88 90 + 83 75 84 91 90 90 97 97 98 + 69 46 79 76 75 75 82 80 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695374974.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695374974.txt new file mode 100644 index 0000000..757b20c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_game1695374974.txt @@ -0,0 +1,21 @@ +6 10 + + 140 139 139 129 130 131 118 118 118 117 + 139 128 128 119 121 121 96 98 96 95 + 155 169 142 147 148 148 141 143 141 140 + 160 183 146 148 149 149 136 138 135 134 + 152 163 151 141 142 142 129 130 129 128 + 165 197 145 153 154 155 141 144 141 140 + + 94 95 95 102 101 101 109 109 109 110 + 95 104 104 110 109 108 129 127 128 129 + 80 69 79 83 83 83 81 82 81 80 + 76 58 84 83 82 82 89 88 90 90 + 83 75 84 91 90 90 97 97 98 98 + 69 46 79 76 75 75 82 80 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694241560.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694241560.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694241560.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694368541.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694368541.txt new file mode 100644 index 0000000..e7210b2 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694368541.txt @@ -0,0 +1,15 @@ +3 4 + + 140 139 139 129 + 139 128 128 119 + 155 169 142 147 + + 94 95 95 102 + 95 104 104 110 + 80 69 79 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694496686.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694496686.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/CoPPO_games_game1694496686.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694784544.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694784544.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694784544.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694889064.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694889064.txt new file mode 100644 index 0000000..dca14e4 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1694889064.txt @@ -0,0 +1,15 @@ +3 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695021123.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695021123.txt new file mode 100644 index 0000000..4950237 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695021123.txt @@ -0,0 +1,17 @@ +4 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + 160 183 146 148 149 149 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + 76 58 84 83 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695101544.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695101544.txt new file mode 100644 index 0000000..c835b38 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695101544.txt @@ -0,0 +1,19 @@ +5 7 + + 140 139 139 129 130 131 118 + 139 128 128 119 121 121 96 + 155 169 142 147 148 148 141 + 160 183 146 148 149 149 136 + 152 163 151 141 142 142 129 + + 94 95 95 102 101 101 109 + 95 104 104 110 109 108 129 + 80 69 79 83 83 83 81 + 76 58 84 83 82 82 89 + 83 75 84 91 90 90 97 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695258416.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695258416.txt new file mode 100644 index 0000000..72d87fe --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695258416.txt @@ -0,0 +1,21 @@ +6 8 + + 140 139 139 129 130 131 118 118 + 139 128 128 119 121 121 96 98 + 155 169 142 147 148 148 141 143 + 160 183 146 148 149 149 136 138 + 152 163 151 141 142 142 129 130 + 165 197 145 153 154 155 141 144 + + 94 95 95 102 101 101 109 109 + 95 104 104 110 109 108 129 127 + 80 69 79 83 83 83 81 82 + 76 58 84 83 82 82 89 88 + 83 75 84 91 90 90 97 97 + 69 46 79 76 75 75 82 80 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695324369.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695324369.txt new file mode 100644 index 0000000..0c013d6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695324369.txt @@ -0,0 +1,21 @@ +6 9 + + 140 139 139 129 130 131 118 118 118 + 139 128 128 119 121 121 96 98 96 + 155 169 142 147 148 148 141 143 141 + 160 183 146 148 149 149 136 138 135 + 152 163 151 141 142 142 129 130 129 + 165 197 145 153 154 155 141 144 141 + + 94 95 95 102 101 101 109 109 109 + 95 104 104 110 109 108 129 127 128 + 80 69 79 83 83 83 81 82 81 + 76 58 84 83 82 82 89 88 90 + 83 75 84 91 90 90 97 97 98 + 69 46 79 76 75 75 82 80 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695374974.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695374974.txt new file mode 100644 index 0000000..757b20c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695374974.txt @@ -0,0 +1,21 @@ +6 10 + + 140 139 139 129 130 131 118 118 118 117 + 139 128 128 119 121 121 96 98 96 95 + 155 169 142 147 148 148 141 143 141 140 + 160 183 146 148 149 149 136 138 135 134 + 152 163 151 141 142 142 129 130 129 128 + 165 197 145 153 154 155 141 144 141 140 + + 94 95 95 102 101 101 109 109 109 110 + 95 104 104 110 109 108 129 127 128 129 + 80 69 79 83 83 83 81 82 81 80 + 76 58 84 83 82 82 89 88 90 90 + 83 75 84 91 90 90 97 97 98 98 + 69 46 79 76 75 75 82 80 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695515551.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695515551.txt new file mode 100644 index 0000000..2ce84f8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695515551.txt @@ -0,0 +1,21 @@ +6 10 + + 140 139 139 129 130 131 118 118 117 117 + 139 128 128 119 121 122 96 98 96 95 + 155 169 142 147 148 148 142 143 141 141 + 160 183 146 148 149 149 136 138 135 134 + 152 163 151 141 142 142 129 129 129 128 + 165 197 145 153 154 155 141 144 140 139 + + 94 95 95 102 101 101 109 109 109 110 + 95 104 104 110 109 108 129 127 128 129 + 80 69 79 83 83 83 80 82 81 80 + 76 58 84 83 82 82 89 88 90 90 + 83 75 84 91 90 90 97 97 98 98 + 69 46 79 76 75 75 81 80 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695625529.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695625529.txt new file mode 100644 index 0000000..709e19e --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695625529.txt @@ -0,0 +1,21 @@ +6 11 + + 140 139 139 129 130 131 118 118 117 117 123 + 139 128 128 119 121 122 96 98 96 95 108 + 155 169 142 147 148 148 142 143 141 141 146 + 160 183 146 148 149 149 136 138 135 134 142 + 152 163 151 141 142 142 129 129 129 128 135 + 165 197 145 153 154 155 141 144 140 139 147 + + 94 95 95 102 101 101 109 109 109 110 106 + 95 104 104 110 109 108 129 127 128 129 119 + 80 69 79 83 83 83 80 82 81 80 82 + 76 58 84 83 82 82 89 88 90 90 86 + 83 75 84 91 90 90 97 97 98 98 94 + 69 46 79 76 75 75 81 80 82 82 79 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 CoPPO-1695573220 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695712792.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695712792.txt new file mode 100644 index 0000000..c9050a9 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695712792.txt @@ -0,0 +1,21 @@ +6 12 + + 140 139 139 129 130 131 118 118 117 117 123 117 + 139 128 128 119 121 122 96 98 96 95 108 95 + 155 169 142 147 148 148 142 143 141 141 146 141 + 160 183 146 148 149 149 136 138 135 134 142 134 + 152 163 151 141 142 142 129 129 129 128 135 128 + 165 197 145 153 154 155 141 144 140 139 147 139 + + 94 95 95 102 101 101 109 109 109 110 106 110 + 95 104 104 110 109 108 129 127 128 129 119 129 + 80 69 79 83 83 83 80 82 81 80 82 81 + 76 58 84 83 82 82 89 88 90 90 86 90 + 83 75 84 91 90 90 97 97 98 98 94 98 + 69 46 79 76 75 75 81 80 82 82 79 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 CoPPO-1695573220 CoPPO-1695668978 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695801243.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695801243.txt new file mode 100644 index 0000000..7fc4a16 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695801243.txt @@ -0,0 +1,21 @@ +6 13 + + 140 139 139 129 130 131 118 118 117 117 123 117 121 + 139 128 128 119 121 122 96 98 96 95 108 95 102 + 155 169 142 147 148 148 142 143 141 141 146 141 143 + 160 183 146 148 149 149 136 138 135 134 142 134 138 + 152 163 151 141 142 142 129 129 129 128 135 128 132 + 165 197 145 153 154 155 141 144 140 139 147 139 144 + + 94 95 95 102 101 101 109 109 109 110 106 110 107 + 95 104 104 110 109 108 129 127 128 129 119 129 124 + 80 69 79 83 83 83 80 82 81 80 82 81 82 + 76 58 84 83 82 82 89 88 90 90 86 90 88 + 83 75 84 91 90 90 97 97 98 98 94 98 96 + 69 46 79 76 75 75 81 80 82 82 79 82 80 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 CoPPO-1695573220 CoPPO-1695668978 CoPPO-1695756008 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695883502.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695883502.txt new file mode 100644 index 0000000..9d1a79d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/game1695883502.txt @@ -0,0 +1,21 @@ +6 14 + + 140 139 139 129 130 131 118 118 117 117 123 117 121 120 + 139 128 128 119 121 122 96 98 96 95 108 95 102 100 + 155 169 142 147 148 148 142 143 141 141 146 141 143 145 + 160 183 146 148 149 149 136 138 135 134 142 134 138 138 + 152 163 151 141 142 142 129 129 129 128 135 128 132 131 + 165 197 145 153 154 155 141 144 140 139 147 139 144 144 + + 94 95 95 102 101 101 109 109 109 110 106 110 107 108 + 95 104 104 110 109 108 129 127 128 129 119 129 124 125 + 80 69 79 83 83 83 80 82 81 80 82 81 82 82 + 76 58 84 83 82 82 89 88 90 90 86 90 88 88 + 83 75 84 91 90 90 97 97 98 98 94 98 96 96 + 69 46 79 76 75 75 81 80 82 82 79 82 80 80 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 CoPPO-1695101545 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 CoPPO-1695181113 CoPPO-1695297225 CoPPO-1695349867 CoPPO-1695573220 CoPPO-1695668978 CoPPO-1695756008 CoPPO-1695843678 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694241560.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694241560.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694241560.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694368541.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694368541.txt new file mode 100644 index 0000000..e7210b2 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694368541.txt @@ -0,0 +1,15 @@ +3 4 + + 140 139 139 129 + 139 128 128 119 + 155 169 142 147 + + 94 95 95 102 + 95 104 104 110 + 80 69 79 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694496686.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694496686.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/games/games_game1694496686.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/globals.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/globals.py new file mode 100644 index 0000000..3208ca6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 3 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=8 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/lemke.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/results.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoPPO/results.xlsx new file mode 100644 index 0000000..bc94c71 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoPPO/results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_game.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_game.txt new file mode 100644 index 0000000..a7afb67 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_game.txt @@ -0,0 +1,16 @@ +6 10 + + 140 139 139 129 130 131 118 118 118 117 + 139 128 128 119 121 121 96 98 96 95 + 155 169 142 147 148 148 141 143 141 140 + 160 183 146 148 149 149 136 138 135 134 + 152 163 151 141 142 142 129 130 129 128 + 165 197 145 153 154 155 141 144 141 140 + + 94 95 95 102 101 101 109 109 109 110 + 95 104 104 110 109 108 129 127 128 129 + 80 69 79 83 83 83 81 82 81 80 + 76 58 84 83 82 82 89 88 90 90 + 83 75 84 91 90 90 97 97 98 98 + 69 46 79 76 75 75 82 80 82 82 + diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_progress.txt b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_progress.txt new file mode 100644 index 0000000..67664d2 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_progress.txt @@ -0,0 +1,41 @@ + + +Sat Sep 9 07:39:21 2023 +-------------------------------------------------- + +Round 0 of 10 +equi: [0.00, 0.00, 1.00], [1.00, 0.00, 0.00], 155.00, 79.67 +high-cost player CoPPO-1694305175 , payoff= 82.74 added, trained against [0, 0, 1.0], payoff=79.67 +Round 1 of 10 +equi: [0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00], 147.41, 82.74 +high-cost player CoPPO-1694433350 , payoff= 82.91 added, trained against [0, 0, 1.0], payoff=82.74 +Round 2 of 10 +equi: [0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00, 0.00], 147.41, 82.74 + +Fri Sep 15 14:29:05 2023 +-------------------------------------------------- + +Round 0 of 10 +equi: [0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00, 0.00], 147.45, 82.80 +high-cost player CoPPO-1694840414 , payoff= 83.19 added, trained against [0, 0, 1.0], payoff=82.80 +Round 1 of 10 +equi: [0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00, 0.00, 0.00], 147.45, 82.80 +Round 2 of 10 +equi: [0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00, 0.00, 0.00], 147.45, 82.80 +low-cost player CoPPO-1694948003 , payoff= 147.83 added, trained against [0, 0, 0, 1.0, 0, 0], payoff=147.45 +Round 3 of 10 +equi: [0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 1.00, 0.00, 0.00, 0.00], 146.32, 83.74 +low-cost player CoPPO-1695021123 , payoff= 151.26 added, trained against [0, 0, 1.0, 0, 0, 0], payoff=146.32 +high-cost player CoPPO-1695061323 , payoff= 89.19 added, trained against [0, 0, 0, 1.0], payoff=83.74 +Round 4 of 10 +equi: [0.00, 0.00, 0.75, 0.25, 0.00], [0.00, 0.00, 0.00, 0.83, 0.00, 0.00, 0.17], 146.28, 82.83 +low-cost player CoPPO-1695101545 , payoff= 151.12 added, trained against [0, 0, 0, 0.8333333333333334, 0, 0, 0.16666666666666666], payoff=146.28 +high-cost player CoPPO-1695181113 , payoff= 83.54 added, trained against [0, 0, 0.75, 0.25, 0], payoff=82.83 +Round 5 of 10 +equi: [0.00, 0.00, 0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00], 141.12, 81.61 +high-cost player CoPPO-1695297225 , payoff= 81.84 added, trained against [0, 0, 0, 0, 0, 1.0], payoff=81.61 +Round 6 of 10 +equi: [0.00, 0.00, 0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00], 140.53, 81.84 +high-cost player CoPPO-1695349867 , payoff= 82.15 added, trained against [0, 0, 0, 0, 0, 1.0], payoff=81.84 +Round 7 of 10 +equi: [0.00, 0.00, 0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00], 139.54, 82.15 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_results.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_results.xlsx new file mode 100644 index 0000000..3945a27 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_trained_agents.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_trained_agents.xlsx new file mode 100644 index 0000000..ad6069f Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/CoPPO_trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/Population_game.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/Population_game.py new file mode 100644 index 0000000..13687e9 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/temp/Population_game.py @@ -0,0 +1,220 @@ + +import classes as cl +import globals as gl +from environments import ConPricingGame +import gymnasium as gym +from gymnasium import spaces +import numpy as np +from stable_baselines3 import PPO +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys +sys.path.append('../jahanis/modules') + + +alg = PPO +env_class = ConPricingGame + +alg_name = "CoPPO" +num_rounds = 10 + + +def training(env_class, costs, adv_mixed_strategy, target_payoff, num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows = [] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694305175") + strtH2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694433350") + strtH3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694840414") + strtH4 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695061323") + strtH5 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695181113") + strtH6 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695297225") + strtH7 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695349867") + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694948003") + strtL2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695021123") + strtL3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1695101545") + + low_cost_strategies=[strt1, strt2, strt3,strtL1,strtL2,strtL3] + high_cost_strategies=[strt1, strt2, strt3, strtH1, strtH2,strtH3,strtH4,strtH5,strtH6,strtH7] + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=low_cost_strategies, high_cost_strategies=high_cost_strategies, env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/trained_agents.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoPPO/trained_agents.xlsx new file mode 100644 index 0000000..3014b25 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoPPO/trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoPPO/utils.py b/learningAgents/sb3_checkpoint_Oct2/CoPPO/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoPPO/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/3adv.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/3adv.py new file mode 100644 index 0000000..61ca628 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/3adv.py @@ -0,0 +1,99 @@ +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import gymnasium as gym +import numpy as np +import globals as gl +import classes as cl +import time +import os +# from gymnasium_env import ContinousPricingGame +from Environment import ConPricingGame +import torch + + +def run(lr=None): + seed=int(time.time()) + + iter_name = f"{model_name}-{str(seed)}" + models_dir = os.path.join("models", iter_name) + log_dir = os.path.join("logs", iter_name) + + if not os.path.exists(models_dir): + os.makedirs(models_dir) + + if not os.path.exists(log_dir): + os.makedirs(log_dir) + + train_env = make_vec_env(ConPricingGame, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv,env_kwargs=\ + dict(tuple_costs = costs,adversary_mixed_strategy = adv_mixed_strategy)) +# train_env = make_vec_env(ContinousPricingGame, n_envs=num_procs, seed=0, vec_env_cls=SubprocVecEnv,\ +# env_kwargs=dict(tuple_cost=costs)) + + lr_=(gl.LR if (lr is None) else lr) +# train_env = ContinousPricingGame() +# train_env.reset() + +# train_env.reset() + model_ = model('MlpPolicy', train_env,learning_rate=lr_,verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start=time.time() + for i in range(num_timesteps): + model_.learn(total_timesteps=timesteps, + reset_num_timesteps=False,tb_log_name=iter_name) + model_.save(os.path.join(models_dir, str(timesteps*i))) + running_time=time.time()- start + + # test and write results + env = ConPricingGame(tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + for iter in range(gl.NUM_STOCHASTIC_ITER): + + obs,_ = env.reset() + done = False + + actions = [] + while not done: + action, _states = model_.predict(obs) + obs, reward, done,trunc, info = env.step(action) + + actions.append(int(action)) + # name ep costs adversary agent_returnC:\Users\sjaha\Desktop\RL\Gym\stableBaseline3\environment.py adv_return agent_rewards actions agent_prices \ + # adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma \ + # stae_onehot seed num_procs running_time + data=[iter_name, timesteps*num_timesteps,("L" if (costs[0] 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + gl.initialize() + + + equilibria = [] + + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694164525") + strtL2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694655185") + strtL3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694966441") + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694461629") + strtH2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1695131273") + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3, strtL1,strtL2,strtL3], high_cost_strategies=[strt1, strt2, strt3, strtH1,strtH2], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/bimatrix.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/classes.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/classes.py new file mode 100644 index 0000000..8942871 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/classes.py @@ -0,0 +1,441 @@ +from enum import Enum +import numpy as np +import globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open("game.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + with open('progress.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + path = 'results.xlsx' if (file_name is None) else file_name + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel('results.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel('trained_agents.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/columnprint.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/environments.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/environments.py new file mode 100644 index 0000000..ee64d39 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/environments.py @@ -0,0 +1,178 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (price_pair[1-player] - price)/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/game.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/game.txt new file mode 100644 index 0000000..29769a6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/game.txt @@ -0,0 +1,16 @@ +6 5 + + 140 139 139 134 87 + 139 128 128 129 34 + 155 169 142 149 110 + 169 226 114 137 102 + 175 301 88 158 104 + 178 298 98 159 105 + + 94 95 95 98 118 + 95 104 104 103 173 + 80 69 79 81 59 + 53 15 64 62 67 + 33 -50 31 36 41 + 34 -47 44 38 46 + diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694164525.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694164525.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694164525.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694655184.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694655184.txt new file mode 100644 index 0000000..58add9d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694655184.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694966440.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694966440.txt new file mode 100644 index 0000000..788061a --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1694966440.txt @@ -0,0 +1,19 @@ +5 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + 175 297 88 159 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + 33 -47 31 36 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1695291046.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1695291046.txt new file mode 100644 index 0000000..b22665c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/._games_game1695291046.txt @@ -0,0 +1,21 @@ +6 5 + + 140 139 139 134 87 + 139 128 128 128 32 + 155 169 142 150 110 + 167 224 113 140 101 + 175 297 88 159 104 + 178 297 96 162 108 + + 94 95 95 98 118 + 95 104 104 103 175 + 80 69 79 82 59 + 56 16 67 59 69 + 33 -47 31 36 39 + 34 -47 40 37 44 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 CoSAC-1694966441 +high-cost strategies: + myopic const guess CoSAC-1694461629 CoSAC-1695131273 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_game1694785129.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_game1694785129.txt new file mode 100644 index 0000000..f98a86d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_game1694785129.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 129 + 155 169 142 150 + 168 219 117 143 + + 94 95 95 98 + 95 104 104 102 + 80 69 79 82 + 58 19 67 58 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694164525.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694164525.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694164525.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694655184.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694655184.txt new file mode 100644 index 0000000..58add9d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694655184.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694966440.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694966440.txt new file mode 100644 index 0000000..788061a --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1694966440.txt @@ -0,0 +1,19 @@ +5 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + 175 297 88 159 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + 33 -47 31 36 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1695291046.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1695291046.txt new file mode 100644 index 0000000..b22665c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/CoSAC_games_game1695291046.txt @@ -0,0 +1,21 @@ +6 5 + + 140 139 139 134 87 + 139 128 128 128 32 + 155 169 142 150 110 + 167 224 113 140 101 + 175 297 88 159 104 + 178 297 96 162 108 + + 94 95 95 98 118 + 95 104 104 103 175 + 80 69 79 82 59 + 56 16 67 59 69 + 33 -47 31 36 39 + 34 -47 40 37 44 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 CoSAC-1694966441 +high-cost strategies: + myopic const guess CoSAC-1694461629 CoSAC-1695131273 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1694785129.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1694785129.txt new file mode 100644 index 0000000..f98a86d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1694785129.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 129 + 155 169 142 150 + 168 219 117 143 + + 94 95 95 98 + 95 104 104 102 + 80 69 79 82 + 58 19 67 58 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1695515142.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1695515142.txt new file mode 100644 index 0000000..60eeea5 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1695515142.txt @@ -0,0 +1,21 @@ +6 5 + + 140 139 139 132 88 + 139 128 128 129 34 + 155 169 142 149 108 + 169 236 115 137 100 + 175 301 85 156 105 + 178 298 90 162 105 + + 94 95 95 99 119 + 95 104 104 102 174 + 80 69 79 81 59 + 51 6 63 59 74 + 32 -50 29 36 40 + 34 -47 36 38 46 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 CoSAC-1694966441 +high-cost strategies: + myopic const guess CoSAC-1694461629 CoSAC-1695131273 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1696944031.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1696944031.txt new file mode 100644 index 0000000..ba3e472 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/games/game1696944031.txt @@ -0,0 +1,21 @@ +6 5 + + 140 139 139 134 87 + 139 128 128 129 34 + 155 169 142 149 110 + 169 226 114 137 102 + 175 301 88 158 104 + 178 298 98 159 105 + + 94 95 95 98 118 + 95 104 104 103 173 + 80 69 79 81 59 + 53 15 64 62 67 + 33 -50 31 36 41 + 34 -47 44 38 46 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 CoSAC-1694966441 +high-cost strategies: + myopic const guess CoSAC-1694461629 CoSAC-1695131273 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/globals.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/globals.py new file mode 100644 index 0000000..eb320cc --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 3 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 1_500_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=6 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/lemke.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/requirements.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/requirements.txt new file mode 100644 index 0000000..615c480 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/requirements.txt @@ -0,0 +1 @@ +stable-baselines3 diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/results-previous.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoSAC/results-previous.xlsx new file mode 100644 index 0000000..8642ed0 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoSAC/results-previous.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/results.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoSAC/results.xlsx new file mode 100644 index 0000000..071039e Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoSAC/results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_game.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_game.txt new file mode 100644 index 0000000..6703df3 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_game.txt @@ -0,0 +1,16 @@ +6 5 + + 140 139 139 134 87 + 139 128 128 128 32 + 155 169 142 150 110 + 167 224 113 140 101 + 175 297 88 159 104 + 178 297 96 162 108 + + 94 95 95 98 118 + 95 104 104 103 175 + 80 69 79 82 59 + 56 16 67 59 69 + 33 -47 31 36 39 + 34 -47 40 37 44 + diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_progress.txt b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_progress.txt new file mode 100644 index 0000000..084c7ae --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_progress.txt @@ -0,0 +1,24 @@ + + +Fri Sep 8 10:15:25 2023 +-------------------------------------------------- + +Round 0 of 10 +equi: [0.00, 0.00, 1.00], [1.00, 0.00, 0.00], 155.00, 79.67 +low-cost player CoSAC-1694164525 , payoff= 167.25 added, trained against [1.0, 0, 0], payoff=155.00 +high-cost player CoSAC-1694461629 , payoff= 81.91 added, trained against [0, 0, 1.0], payoff=79.67 +Round 1 of 10 +equi: [0.00, 0.00, 1.00, 0.00], [0.00, 0.00, 0.00, 1.00], 149.58, 81.91 + +Fri Sep 15 14:38:50 2023 +-------------------------------------------------- + +Round 0 of 10 +equi: [0.00, 0.00, 1.00, 0.00], [0.00, 0.00, 0.00, 1.00], 149.51, 81.66 +low-cost player CoSAC-1694655185 , payoff= 158.76 added, trained against [0, 0, 0, 1.0], payoff=149.58 +Round 2 of 10 +equi: [0.00, 0.00, 0.00, 0.00, 1.00], [0.00, 0.00, 0.00, 1.00], 158.76, 35.74 +low-cost player CoSAC-1694966441 , payoff= 161.55 added, trained against [0, 0, 0, 1.0], payoff=158.76 +high-cost player CoSAC-1695131273 , payoff= 39.10 added, trained against [0, 0, 0, 0, 1.0], payoff=35.74 +Round 3 of 10 +equi: [0.00, 0.00, 0.50, 0.00, 0.00, 0.50], [0.00, 0.00, 0.21, 0.79, 0.00], 147.94, 59.37 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_results.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_results.xlsx new file mode 100644 index 0000000..071039e Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_trained_agents.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_trained_agents.xlsx new file mode 100644 index 0000000..08b31be Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/CoSAC_trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/PPO_Population_game.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/PPO_Population_game.py new file mode 100644 index 0000000..3ef73a8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/PPO_Population_game.py @@ -0,0 +1,200 @@ + +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +import numpy as np +from Environment import ConPricingGame +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import os + +alg = SAC +env_class= ConPricingGame + +alg_name = "CoSAC" +num_rounds = 10 + + + +def training(env_class, costs, adv_mixed_strategy, target_payoff): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=gl.NUM_PROCESS, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes,tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows=[] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data=[model_name, number_episodes,("L" if (costs[0] target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, gl.NUM_PROCESS, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3], high_cost_strategies=[strt1, strt2, strt3], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n"+ time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=\ + high_mixed_strat, target_payoff=\ + equi["low_cost_payoff"]) + if acceptable: + new_low=True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + #train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=\ + low_mixed_strat, target_payoff=\ + equi["high_cost_payoff"]) + if acceptable: + new_high=True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs,agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE + + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/Population_game.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/Population_game.py new file mode 100644 index 0000000..ed67c44 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/temp/Population_game.py @@ -0,0 +1,207 @@ + +import gymnasium as gym +from gymnasium import spaces +import numpy as np +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys +sys.path.append('../jahanis/modules') +from environments import ConPricingGame +import globals as gl +import classes as cl + + +alg = SAC +env_class = ConPricingGame + +alg_name = "CoSAC" +num_rounds = 10 + + +def training(env_class, costs, adv_mixed_strategy, target_payoff, num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows = [] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694164525") + strtL2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694655185") + strtL3 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694966441") + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694461629") + strtH2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1695131273") + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3, strtL1,strtL2,strtL3], high_cost_strategies=[strt1, strt2, strt3, strtH1,strtH2], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/test.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/test.py new file mode 100644 index 0000000..8d596c4 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/test.py @@ -0,0 +1,14 @@ +import classes as cl +import globals as gl +from environments import ConPricingGame +import gymnasium as gym +from gymnasium import spaces +import numpy as np +from stable_baselines3 import SAC + +names = ["CoSAC-1694966441", "CoSAC-1695131273", "CoSAC-1695131273", "CoSAC-1694966441", "CoSAC-1694966441", "CoSAC-1694655185", "CoSAC-1694655185", + "CoSAC-1694655185", "CoSAC-1694461629", "CoSAC-1694461629", "CoSAC-1694461629", "CoSAC-1694164525", "CoSAC-1694164525", "CoSAC-1694164525", "CoSAC-1695131273"] +for name in names: + policy= (SAC.load("models/"+name,env=ConPricingGame)).predict + + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/trained_agents.xlsx b/learningAgents/sb3_checkpoint_Oct2/CoSAC/trained_agents.xlsx new file mode 100644 index 0000000..c99919c Binary files /dev/null and b/learningAgents/sb3_checkpoint_Oct2/CoSAC/trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Oct2/CoSAC/utils.py b/learningAgents/sb3_checkpoint_Oct2/CoSAC/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Oct2/CoSAC/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/sb3_checkpoint_Sep19/._games_game1694164525.txt b/learningAgents/sb3_checkpoint_Sep19/._games_game1694164525.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/._games_game1694164525.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/._games_game1694655184.txt b/learningAgents/sb3_checkpoint_Sep19/._games_game1694655184.txt new file mode 100644 index 0000000..58add9d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/._games_game1694655184.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/._games_game1694966440.txt b/learningAgents/sb3_checkpoint_Sep19/._games_game1694966440.txt new file mode 100644 index 0000000..788061a --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/._games_game1694966440.txt @@ -0,0 +1,19 @@ +5 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + 175 297 88 159 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + 33 -47 31 36 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 CoSAC-1694655185 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/CoSAC_MP-3adv.py b/learningAgents/sb3_checkpoint_Sep19/CoSAC_MP-3adv.py new file mode 100644 index 0000000..61ca628 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/CoSAC_MP-3adv.py @@ -0,0 +1,99 @@ +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import gymnasium as gym +import numpy as np +import globals as gl +import classes as cl +import time +import os +# from gymnasium_env import ContinousPricingGame +from Environment import ConPricingGame +import torch + + +def run(lr=None): + seed=int(time.time()) + + iter_name = f"{model_name}-{str(seed)}" + models_dir = os.path.join("models", iter_name) + log_dir = os.path.join("logs", iter_name) + + if not os.path.exists(models_dir): + os.makedirs(models_dir) + + if not os.path.exists(log_dir): + os.makedirs(log_dir) + + train_env = make_vec_env(ConPricingGame, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv,env_kwargs=\ + dict(tuple_costs = costs,adversary_mixed_strategy = adv_mixed_strategy)) +# train_env = make_vec_env(ContinousPricingGame, n_envs=num_procs, seed=0, vec_env_cls=SubprocVecEnv,\ +# env_kwargs=dict(tuple_cost=costs)) + + lr_=(gl.LR if (lr is None) else lr) +# train_env = ContinousPricingGame() +# train_env.reset() + +# train_env.reset() + model_ = model('MlpPolicy', train_env,learning_rate=lr_,verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start=time.time() + for i in range(num_timesteps): + model_.learn(total_timesteps=timesteps, + reset_num_timesteps=False,tb_log_name=iter_name) + model_.save(os.path.join(models_dir, str(timesteps*i))) + running_time=time.time()- start + + # test and write results + env = ConPricingGame(tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + for iter in range(gl.NUM_STOCHASTIC_ITER): + + obs,_ = env.reset() + done = False + + actions = [] + while not done: + action, _states = model_.predict(obs) + obs, reward, done,trunc, info = env.step(action) + + actions.append(int(action)) + # name ep costs adversary agent_returnC:\Users\sjaha\Desktop\RL\Gym\stableBaseline3\environment.py adv_return agent_rewards actions agent_prices \ + # adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma \ + # stae_onehot seed num_procs running_time + data=[iter_name, timesteps*num_timesteps,("L" if (costs[0] 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (price_pair[1-player] - price)/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/Environment.py b/learningAgents/sb3_checkpoint_Sep19/PPO/Environment.py new file mode 100644 index 0000000..ee64d39 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/Environment.py @@ -0,0 +1,178 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (price_pair[1-player] - price)/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/Population_game.py b/learningAgents/sb3_checkpoint_Sep19/PPO/Population_game.py new file mode 100644 index 0000000..c175d07 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/Population_game.py @@ -0,0 +1,208 @@ + +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +import numpy as np +from Environment import ConPricingGame +from stable_baselines3 import PPO +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys + + + +alg = PPO +env_class= ConPricingGame + +alg_name = "CoPPO" +num_rounds = 10 + + + +def training(env_class, costs, adv_mixed_strategy, target_payoff,num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes,tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows=[] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data=[model_name, number_episodes,("L" if (costs[0] target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694305175") + strtH2 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=PPO, name="CoPPO-1694433350") + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3], high_cost_strategies=[strt1, strt2, strt3,strtH1,strtH2], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs= gl.NUM_PROCESS if (len(sys.argv)<2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n"+ time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=\ + high_mixed_strat, target_payoff=\ + equi["low_cost_payoff"],num_procs=num_procs) + if acceptable: + new_low=True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + #train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=\ + low_mixed_strat, target_payoff=\ + equi["high_cost_payoff"],num_procs=num_procs) + if acceptable: + new_high=True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs,agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE + + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/bimatrix.py b/learningAgents/sb3_checkpoint_Sep19/PPO/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/classes.py b/learningAgents/sb3_checkpoint_Sep19/PPO/classes.py new file mode 100644 index 0000000..8942871 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/classes.py @@ -0,0 +1,441 @@ +from enum import Enum +import numpy as np +import globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open("game.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + with open('progress.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + path = 'results.xlsx' if (file_name is None) else file_name + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel('results.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel('trained_agents.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/columnprint.py b/learningAgents/sb3_checkpoint_Sep19/PPO/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/game.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/game.txt new file mode 100644 index 0000000..c003c84 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/game.txt @@ -0,0 +1,14 @@ +5 7 + + 140 139 139 129 130 131 118 + 139 128 128 119 121 121 96 + 155 169 142 147 148 148 141 + 160 183 146 148 149 149 136 + 152 163 151 141 142 142 129 + + 94 95 95 102 101 101 109 + 95 104 104 110 109 108 129 + 80 69 79 83 83 83 81 + 76 58 84 83 82 82 89 + 83 75 84 91 90 90 97 + diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694784544.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694784544.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694784544.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694889064.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694889064.txt new file mode 100644 index 0000000..dca14e4 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1694889064.txt @@ -0,0 +1,15 @@ +3 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695021123.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695021123.txt new file mode 100644 index 0000000..4950237 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695021123.txt @@ -0,0 +1,17 @@ +4 6 + + 140 139 139 129 130 131 + 139 128 128 119 121 121 + 155 169 142 147 148 148 + 160 183 146 148 149 149 + + 94 95 95 102 101 101 + 95 104 104 110 109 108 + 80 69 79 83 83 83 + 76 58 84 83 82 82 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695101544.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695101544.txt new file mode 100644 index 0000000..c835b38 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games/game1695101544.txt @@ -0,0 +1,19 @@ +5 7 + + 140 139 139 129 130 131 118 + 139 128 128 119 121 121 96 + 155 169 142 147 148 148 141 + 160 183 146 148 149 149 136 + 152 163 151 141 142 142 129 + + 94 95 95 102 101 101 109 + 95 104 104 110 109 108 129 + 80 69 79 83 83 83 81 + 76 58 84 83 82 82 89 + 83 75 84 91 90 90 97 + + +low-cost strategies: + myopic const guess CoPPO-1694948003 CoPPO-1695021123 +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 CoPPO-1694840414 CoPPO-1695061323 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694241560.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694241560.txt new file mode 100644 index 0000000..085b1d8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694241560.txt @@ -0,0 +1,15 @@ +3 3 + + 140 139 139 + 139 128 128 + 155 169 142 + + 94 95 95 + 95 104 104 + 80 69 79 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694368541.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694368541.txt new file mode 100644 index 0000000..e7210b2 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694368541.txt @@ -0,0 +1,15 @@ +3 4 + + 140 139 139 129 + 139 128 128 119 + 155 169 142 147 + + 94 95 95 102 + 95 104 104 110 + 80 69 79 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694496686.txt b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694496686.txt new file mode 100644 index 0000000..2cbec46 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/games_game1694496686.txt @@ -0,0 +1,15 @@ +3 5 + + 140 139 139 129 130 + 139 128 128 119 121 + 155 169 142 147 148 + + 94 95 95 102 101 + 95 104 104 110 109 + 80 69 79 83 83 + + +low-cost strategies: + myopic const guess +high-cost strategies: + myopic const guess CoPPO-1694305175 CoPPO-1694433350 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/globals.py b/learningAgents/sb3_checkpoint_Sep19/PPO/globals.py new file mode 100644 index 0000000..b568144 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 3 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=12 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/lemke.py b/learningAgents/sb3_checkpoint_Sep19/PPO/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/results.xlsx b/learningAgents/sb3_checkpoint_Sep19/PPO/results.xlsx new file mode 100644 index 0000000..ada9892 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Sep19/PPO/results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/trained_agents.xlsx b/learningAgents/sb3_checkpoint_Sep19/PPO/trained_agents.xlsx new file mode 100644 index 0000000..3733665 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Sep19/PPO/trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO/utils.py b/learningAgents/sb3_checkpoint_Sep19/PPO/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/sb3_checkpoint_Sep19/PPO_Population_game.py b/learningAgents/sb3_checkpoint_Sep19/PPO_Population_game.py new file mode 100644 index 0000000..3ef73a8 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/PPO_Population_game.py @@ -0,0 +1,200 @@ + +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +import numpy as np +from Environment import ConPricingGame +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import os + +alg = SAC +env_class= ConPricingGame + +alg_name = "CoSAC" +num_rounds = 10 + + + +def training(env_class, costs, adv_mixed_strategy, target_payoff): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=gl.NUM_PROCESS, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes,tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows=[] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data=[model_name, number_episodes,("L" if (costs[0] target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, gl.NUM_PROCESS, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3], high_cost_strategies=[strt1, strt2, strt3], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n"+ time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=\ + high_mixed_strat, target_payoff=\ + equi["low_cost_payoff"]) + if acceptable: + new_low=True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + #train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=\ + low_mixed_strat, target_payoff=\ + equi["high_cost_payoff"]) + if acceptable: + new_high=True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs,agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE + + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/Population_game.py b/learningAgents/sb3_checkpoint_Sep19/Population_game.py new file mode 100644 index 0000000..bebedf5 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/Population_game.py @@ -0,0 +1,200 @@ + +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +import numpy as np +from Environment import ConPricingGame +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys + + +alg = SAC +env_class = ConPricingGame + +alg_name = "CoSAC" +num_rounds = 10 + + +def training(env_class, costs, adv_mixed_strategy, target_payoff, num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows = [] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694164525") + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694461629") + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3, strtL1], high_cost_strategies=[strt1, strt2, strt3, strtH1], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/sb3_checkpoint_Sep19/bimatrix.py b/learningAgents/sb3_checkpoint_Sep19/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/sb3_checkpoint_Sep19/classes.py b/learningAgents/sb3_checkpoint_Sep19/classes.py new file mode 100644 index 0000000..8942871 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/classes.py @@ -0,0 +1,441 @@ +from enum import Enum +import numpy as np +import globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open("game.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + with open('progress.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + path = 'results.xlsx' if (file_name is None) else file_name + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel('results.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel('trained_agents.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/columnprint.py b/learningAgents/sb3_checkpoint_Sep19/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/sb3_checkpoint_Sep19/game.txt b/learningAgents/sb3_checkpoint_Sep19/game.txt new file mode 100644 index 0000000..07d1fbf --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/game.txt @@ -0,0 +1,14 @@ +5 4 + + 140 139 139 134 + 139 128 128 128 + 155 169 142 150 + 167 224 113 140 + 175 297 88 159 + + 94 95 95 98 + 95 104 104 103 + 80 69 79 82 + 56 16 67 59 + 33 -47 31 36 + diff --git a/learningAgents/sb3_checkpoint_Sep19/games/game1694785129.txt b/learningAgents/sb3_checkpoint_Sep19/games/game1694785129.txt new file mode 100644 index 0000000..f98a86d --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/games/game1694785129.txt @@ -0,0 +1,17 @@ +4 4 + + 140 139 139 134 + 139 128 128 129 + 155 169 142 150 + 168 219 117 143 + + 94 95 95 98 + 95 104 104 102 + 80 69 79 82 + 58 19 67 58 + + +low-cost strategies: + myopic const guess CoSAC-1694164525 +high-cost strategies: + myopic const guess CoSAC-1694461629 \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/globals.py b/learningAgents/sb3_checkpoint_Sep19/globals.py new file mode 100644 index 0000000..3208ca6 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 3 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=8 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/sb3_checkpoint_Sep19/lemke.py b/learningAgents/sb3_checkpoint_Sep19/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/sb3_checkpoint_Sep19/requirements.txt b/learningAgents/sb3_checkpoint_Sep19/requirements.txt new file mode 100644 index 0000000..615c480 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/requirements.txt @@ -0,0 +1 @@ +stable-baselines3 diff --git a/learningAgents/sb3_checkpoint_Sep19/results-previous.xlsx b/learningAgents/sb3_checkpoint_Sep19/results-previous.xlsx new file mode 100644 index 0000000..8642ed0 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Sep19/results-previous.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Sep19/results.xlsx b/learningAgents/sb3_checkpoint_Sep19/results.xlsx new file mode 100644 index 0000000..d919e1c Binary files /dev/null and b/learningAgents/sb3_checkpoint_Sep19/results.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Sep19/trained_agents.xlsx b/learningAgents/sb3_checkpoint_Sep19/trained_agents.xlsx new file mode 100644 index 0000000..423c060 Binary files /dev/null and b/learningAgents/sb3_checkpoint_Sep19/trained_agents.xlsx differ diff --git a/learningAgents/sb3_checkpoint_Sep19/utils.py b/learningAgents/sb3_checkpoint_Sep19/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/sb3_checkpoint_Sep19/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/src/LearningAgent Simulations.ipynb b/learningAgents/src/LearningAgent Simulations.ipynb deleted file mode 100644 index c1a21e8..0000000 --- a/learningAgents/src/LearningAgent Simulations.ipynb +++ /dev/null @@ -1,984 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from learningAgents import Model, ReinforceAlgorithm" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "game = Model(totalDemand = 400, \n", - " tupleCosts = (50, 50),\n", - " totalStages = 25,\n", - " initState = [400/2,0])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(tensor([200., 0.]), 0, False)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "game.reset()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "125.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "game.adversaryChoosePrice()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "from torch.distributions import Categorical\n", - "\n", - "# Hyperparameters\n", - "lr = .003\n", - "gamma = 1\n", - "num_episodes = 20\n", - "\n", - "nn_ = 100\n", - "\n", - "policy = nn.Sequential(nn.Linear(2, nn_), \n", - " nn.ReLU(),\n", - " nn.Linear(nn_,nn_),\n", - " nn.ReLU(),\n", - " nn.Linear(nn_,15), \n", - " nn.Softmax(dim=0))\n", - "\n", - "\n", - "optim = torch.optim.Adam(policy.parameters(), lr=lr)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "algorithm = ReinforceAlgorithm(game, policy, optim, 10)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(65514.2227, grad_fn=)\n", - "tensor(269222.2500, grad_fn=)\n", - "tensor(138142.5781, grad_fn=)\n", - "tensor(57994.0820, grad_fn=)\n", - "tensor(67315.9062, grad_fn=)\n", - "tensor(65234.2383, grad_fn=)\n", - "tensor(60009.5508, grad_fn=)\n", - "tensor(52406.2695, grad_fn=)\n", - "tensor(48306.6250, grad_fn=)\n", - "tensor(38886.1523, grad_fn=)\n" - ] - } - ], - "source": [ - "algorithm.solver()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "profits = pd.DataFrame(game.profit).T\n", - "prices = pd.DataFrame(game.prices).T\n", - "demandPotential = pd.DataFrame(game.demandPotential).T" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
01
0200.000000200.000000
1205.000000195.000000
2207.500000192.500000
3208.750000191.250000
4209.375000190.625000
5209.687500190.312500
6209.843750190.156250
7209.921875190.078125
8209.960938190.039062
9209.980469190.019531
10209.990234190.009766
11209.995117190.004883
12209.997559190.002441
13209.998779190.001221
14209.999390190.000610
15209.999695190.000305
16209.999847190.000153
17209.999924190.000076
18209.999962190.000038
19209.999981190.000019
20209.999990190.000010
21209.999995190.000005
22209.999998190.000002
23209.999999190.000001
24209.999999190.000001
\n", - "
" - ], - "text/plain": [ - " 0 1\n", - "0 200.000000 200.000000\n", - "1 205.000000 195.000000\n", - "2 207.500000 192.500000\n", - "3 208.750000 191.250000\n", - "4 209.375000 190.625000\n", - "5 209.687500 190.312500\n", - "6 209.843750 190.156250\n", - "7 209.921875 190.078125\n", - "8 209.960938 190.039062\n", - "9 209.980469 190.019531\n", - "10 209.990234 190.009766\n", - "11 209.995117 190.004883\n", - "12 209.997559 190.002441\n", - "13 209.998779 190.001221\n", - "14 209.999390 190.000610\n", - "15 209.999695 190.000305\n", - "16 209.999847 190.000153\n", - "17 209.999924 190.000076\n", - "18 209.999962 190.000038\n", - "19 209.999981 190.000019\n", - "20 209.999990 190.000010\n", - "21 209.999995 190.000005\n", - "22 209.999998 190.000002\n", - "23 209.999999 190.000001\n", - "24 209.999999 190.000001" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "demandPotential" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGdCAYAAAAbudkLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKAUlEQVR4nO3de3wU9b3/8dduLpsEko2BXAgkEEQJiqJGCKktBUlJsEdNwdNSQcBGaG2CR3K0/cVTL/QWL7+femwRT1sUraKWVkRpSw8Nt6IBJBoV0QgIBswFBLJLEnLd+f2xZGElXJZsMsnm/Xw85rGzM9+Z+ey6bd7MfOc7FsMwDEREREQCkNXsAkRERES6ioKOiIiIBCwFHREREQlYCjoiIiISsBR0REREJGAp6IiIiEjAUtARERGRgKWgIyIiIgEr2OwCuovL5aKyspLIyEgsFovZ5YiIiMh5MAyDY8eOkZiYiNXq+/mZPhN0KisrSUpKMrsMERERuQD79+9nyJAhPm/XZ4JOZGQk4P6ioqKiTK5GREREzofT6SQpKcnzd9xXfSbotF+uioqKUtARERHpZS6024k6I4uIiEjAUtARERGRgKWgIyIiIgFLQUdEREQCloKOiIiIBCwFHREREQlYCjoiIiISsBR0REREJGAp6IiIiEjA8inoFBUVMXbsWCIjI4mLiyMnJ4fy8nKvNr/73e+YOHEiUVFRWCwWamtrT9vPkSNHmDlzJlFRUURHR5Obm0tdXd1Zj93Y2EheXh4DBgygf//+TJ8+nZqaGl/KFxERkT7Gp6CzceNG8vLy2LJlC2vXrqWlpYUpU6ZQX1/vadPQ0EB2djb33XffGfczc+ZMPvroI9auXcvq1avZtGkT8+fPP+uxFy5cyJtvvsmKFSvYuHEjlZWVTJs2zZfyRUREpI+xGIZhXOjGhw4dIi4ujo0bNzJhwgSvdRs2bGDSpEkcPXqU6Ohoz/KPP/6Yyy67jHfeeYdrr70WgDVr1nDDDTdw4MABEhMTTzuOw+EgNjaW5cuXc8sttwDwySefMGrUKEpKShg/fvw5a3U6ndjtdhwOh551JSIi0kt09u93px7q6XA4AIiJiTnvbUpKSoiOjvaEHIDMzEysVitbt27lO9/5zmnblJaW0tLSQmZmpmdZamoqycnJZww6TU1NNDU1ed47nc7zrlGkJzMMg1aXQZvLoKXNdeLV+32ry0Wry6C1zTjx6l7uMtzbtxnueZdhYBgGLhe0tc+fWN7mMjBOzLsMcLmMk/OGgeEuBsP9gnFivv0YtC/HOPGKZ3/tn6P9n1nt69zzJ7dtX9f+pv1fZe37Pa2d1/d0yvxX1579LWf699+Z/ll4pn8tXvg/Izs6hh93JtJFBva3kTdphNlleLngoONyubj77ru57rrrGD169HlvV11dTVxcnHcRwcHExMRQXV19xm1CQ0O9zgwBxMfHn3GboqIiFi1adN51iVwowzCoa2rFcbyF2oYWnI0tNLa00dji8n5tdc83tbSdXN7aRtOJ11PbNrW6X5tbXSfDzIlw0+bSHzwR6ZmGx/YLnKCTl5fHjh072Lx5sz/r8ZvCwkIKCgo8751OJ0lJSSZWJD1dm8vAebyF2uMt1DY0U3u8BUeDe95xvJXa483u919Z7zjeQmsPCB8hQRaCrBZCrFaCgiwEW60EWy0EB1kItrrXWS3uyWIBq6V9GVgs7tcgq8Uz377+1PcntwUL7nnLiXlOtLHQvsy9XwvAiTbWU9q3b+tueXKb9nn3mo7Wtc913O5Up749bd1XFnxldQcLTmc5j0ZfPe6Z99W9zrcuEV9cFBFqdgmnuaCgk5+f7+lEPGTIEJ+2TUhI4ODBg17LWltbOXLkCAkJCWfcprm5mdraWq+zOjU1NWfcxmazYbPZfKpNApthGBw61sS+ww18friezw83sO9wPRVHGqg40kBtQ0un9h8abCU6PISo8BDCQ4IIC7ESFhKELfjkfFiIlbDgoJPzIUHYQoIIC25ff0rb4CBCg62eoBIcdCK4WE+EmPZgE2T1hBUREfHmU9AxDIMFCxawcuVKNmzYQEpKis8HzMjIoLa2ltLSUtLS0gBYt24dLpeL9PT0DrdJS0sjJCSE4uJipk+fDkB5eTkVFRVkZGT4XIMErjaXQZXjOBWHGzyBZt+JUPP54QaOt7Sdcx/9bcHYw0OIjjgxhYcS1f7+xKs9PNRrfXRECGEhQd3wCUVExBc+BZ28vDyWL1/OqlWriIyM9PSPsdvthIeHA+7+NNXV1ezevRuADz/8kMjISJKTk4mJiWHUqFFkZ2czb948nnnmGVpaWsjPz2fGjBmeO66++OILJk+ezAsvvMC4ceOw2+3k5uZSUFBATEwMUVFRLFiwgIyMjPO640oCT2NLG+9WHGVXTd2JEOMONPuPHKe5zXXG7awWSIwOZ9iAfgwdEOF5TR4QwcD+NuzhIYQEaRxNEZFA4VPQWbJkCQATJ070Wv7cc88xd+5cAJ555hmvTsDtt52f2uall14iPz+fyZMnY7VamT59Ok899ZRnm5aWFsrLy2loaPAse+KJJzxtm5qayMrK4umnn/alfOnFDMNg75f1bPz0EJs+PUTJZ4dpbOk40IQEWUi6KIKhAyIY+pVAM+SiCEKDFWRERPqKTo2j05toHJ3e51hjC2/vOcymTw+x8dNDHDh63Gt9bKSNq5KiGXYi0LSHmcTocIKs6q8iIhIITB1HR8SfXC6DnVVOz1mb0s+Pet3NFBJkYeywGCZcGss3L40lNSFSHXBFROSsFHTEVIfrmvjXri/Z9OkhNu06xJd1zV7rhw6I4JuXxjLhklgyLh5AP5t+siIicv70V0O6VWubi/f217Kx3H05akelw2v02IjQIL528QAmnAg3wwb2M69YERHp9RR0pFu4XAZvvF/JY/8o54ta7742owZFMeHSgXzz0ljShl6ELVi3aYuIiH8o6EiX27b3CL/6607eP+B+Npo9POTEGZuBTLg0lvioMJMrFBGRQKWgI11m75f1PPz3j/nHRzUA9AsN4seTRpD79RQNriciIt1CQUf8rrahmaeKd/PHLftoaTOwWmDGuGQWZl5KbKQeyyEiIt1HQUf8prnVxQsl+/jNut04jrufGzVxZCz33TCKS+MjTa5ORET6IgUd6TTDMFizo5qH13zC54fdo1mnJkTyX98exTcuiTW5OhER6csUdKRTyvbX8qu/7uSdfUcB92jF90y5lFvSkjQ6sYiImE5BRy7IgaMNPLqmnDferwQgLMTK/AkX88MJwzWon4iI9Bj6iyQ+cTa28PT6PTz71l6aW11YLDD9miHcM2UkCXbdJi4iIj2Lgo6cl9Y2Fy+/s58n137K4Xr3Yxq+dvEA7rthFKMH202uTkREpGMKOnJO7+w7QuFrH7L7YB0Aw2P7cd/UUUweFaeHaoqISI+moCNnVba/ltlLt3G8pY2YfqEszLyEGeOSCQmyml2aiIjIOSnoyBnt/bKeHyx7h+MtbXzjkoEsnnkNUWEhZpclIiJy3hR0pEOHjjUx+9mtHKlv5orBdp6Zlaa7qUREpNfR9Qc5TV1TK7cv28b+I8cZOiCCZ+eOVcgREZFeSUFHvDS3urjzxVJ2fOFkQL9Qnr99nJ5PJSIivZaCjngYhsH/+csH/GvXl4SHBPHs3LEMG9jP7LJEREQumIKOeDyyppzX3vuCIKuFp2ddw5ikaLNLEhER6RQFHQFg2Vt7eWbjHgAennYFk0bGmVyRiIhI5ynoCH/9oIpFq3cCcG/WSP792iSTKxIREfEPBZ0+bstnh1n4ahmGAbeNH8qPJ15sdkkiIiJ+o6DTh31S7WTeC9tpbnORfXkCD910uR7pICIiAUVBp4+qrD3O3Gff4VhjK2OHXcSTM64iyKqQIyIigUVBpw+qbWhmzrPbqHY2cklcf/4weyxhIUFmlyUiIuJ3Cjp9TGNLG/Ne2M6ug3UkRIXx/A/GYY/Q86tERCQwKej0IW0ug/945T3e2XeUyLBgnv/BOBKjw80uS0REpMso6PQRhmHw0Bsf8Y+PaggNtvL72dcyMiHS7LJERES6lIJOH/H0hj38ccvnWCzw39+7ivHDB5hdkoiISJfzKegUFRUxduxYIiMjiYuLIycnh/Lycq82jY2N5OXlMWDAAPr378/06dOpqanxrF+2bBkWi6XD6eDBg2c89rBhw05r//DDD/v4cfumP23fz2P/cP93eujGy5l6xSCTKxIREekeFsMwjPNtnJ2dzYwZMxg7diytra3cd9997Nixg507d9Kvn/vhj3feeSd//etfWbZsGXa7nfz8fKxWK2+99RYAx48fx+FweO137ty5NDY2smHDhjMee9iwYeTm5jJv3jzPssjISM9xz8XpdGK323E4HERFRZ3vR+711n9ykDte2E6by+DOiRfz0+xUs0sSERE5b539+x3sS+M1a9Z4vV+2bBlxcXGUlpYyYcIEHA4HS5cuZfny5Vx//fUAPPfcc4waNYotW7Ywfvx4wsPDCQ8/2QH20KFDrFu3jqVLl57z+JGRkSQkJPhScp9Wtr+WH7/0Lm0ug2nXDOYnWSPNLklERKRbdaqPTvuZmZiYGABKS0tpaWkhMzPT0yY1NZXk5GRKSko63McLL7xAREQEt9xyyzmP9/DDDzNgwACuvvpqHnvsMVpbW8/YtqmpCafT6TX1JZ8frucHy97heEsbEy6N5ZHpV2rUYxER6XN8OqNzKpfLxd133811113H6NGjAaiuriY0NJTo6GivtvHx8VRXV3e4n6VLl3Lrrbd6neXpyF133cU111xDTEwMb7/9NoWFhVRVVfH444932L6oqIhFixb5/sECxC//+jFH6pu5YrCdJTOvISRI/c5FRKTvueCgk5eXx44dO9i8efMFH7ykpISPP/6YP/7xj+dsW1BQ4Jm/8sorCQ0N5Yc//CFFRUXYbLbT2hcWFnpt43Q6SUrqG0/l3vtlPf/82N0B/InvjaGf7YL/M4uIiPRqF/TP/Pz8fFavXs369esZMmSIZ3lCQgLNzc3U1tZ6ta+pqemwb80f/vAHrrrqKtLS0nyuIT09ndbWVvbt29fhepvNRlRUlNfUVzy7eS+GAdenxjEiTmPliIhI3+VT0DEMg/z8fFauXMm6detISUnxWp+WlkZISAjFxcWeZeXl5VRUVJCRkeHVtq6ujj/96U/k5uZeUOFlZWVYrVbi4uIuaPtAdbS+mRWl+wG44xsp52gtIiIS2Hy6ppGXl8fy5ctZtWoVkZGRnn43drud8PBw7HY7ubm5FBQUEBMTQ1RUFAsWLCAjI4Px48d77evVV1+ltbWVWbNmnXacbdu2MXv2bIqLixk8eDAlJSVs3bqVSZMmERkZSUlJCQsXLmTWrFlcdNFFnfj4gWf5tgoaW1xcNiiKDA0KKCIifZxPQWfJkiUATJw40Wv5c889x9y5cwF44oknsFqtTJ8+naamJrKysnj66adP29fSpUuZNm3aaR2XARoaGigvL6elpQVwX4Z65ZVXeOihh2hqaiIlJYWFCxd69cERaGptY9nb+wCYNyFFd1mJiEif59OAgb1ZXxgw8M+lB7hnxfvER9n410+uJzRYd1qJiEjv1tm/3/pLGCAMw+AP//oMgLlfS1HIERERQUEnYLy1+zCfVB8jIjSIW8clm12OiIhIj6CgEyB+f+JsznevTcIeEWJyNSIiIj2Dgk4A+LTmGBs/PYTFArdfN8zsckRERHoMBZ0AsPRfewHIuiyBoQPO72nuIiIifYGCTi936FgTK8u+ADRAoIiIyFcp6PRyf9zyOc2tLq5KiiZtqAZPFBEROZWCTi/W2NLGi1s+B9xnczRAoIiIiDcFnV7stXe/4Eh9M4Ojw8m+/PSHpoqIiPR1Cjq9lMtlsHSz+5by268bRnCQ/lOKiIh8lf469lIbPj3InkP1RNqC+d7YJLPLERER6ZEUdHqpP5y4pXzGuCQiwzRAoIiISEcUdHqhjyodvL3nMEFWC3Ov0y3lIiIiZ6Kg0wu1DxB4wxWDGBwdbnI1IiIiPZeCTi9T7WjkjfcrAZinAQJFRETOSkGnl3m+ZB+tLoNxw2K4cki02eWIiIj0aAo6vUh9UysvnTJAoIiIiJydgk4v8ufSAzgbWxk2IILJo+LNLkdERKTHU9DpJdpcBks3uzsh5349hSCrHvcgIiJyLgo6vcTanTVUHGnAHh7C9LQhZpcjIiLSKyjo9BJ/+Jf7cQ+zxicTERpscjUiIiK9g4JOL/BexVG2f36UkCALszOGmV2OiIhIr6Gg0wv84UTfnJvGDCY+KszkakRERHoPBZ0ebv+RBv7+YRXg7oQsIiIi509Bp4db9vY+XAZcN2IAlyVGmV2OiIhIr6Kg04M5G1t49Z39ANzxjeEmVyMiItL7KOj0YK9u209dUysj4vrzzUtizS5HRESk11HQ6aFa21w895a7E/IdX0/BqgECRUREfKag00P9bUc1lY5GBvQLJefqwWaXIyIi0isp6PRAhmF4Bgi8LWMoYSFBJlckIiLSOyno9EDv7DvKBwcchAZbmTV+qNnliIiI9Fo+BZ2ioiLGjh1LZGQkcXFx5OTkUF5e7tWmsbGRvLw8BgwYQP/+/Zk+fTo1NTVebSwWy2nTK6+8ctZjHzlyhJkzZxIVFUV0dDS5ubnU1dX5Un6v0X42Z/o1gxnY32ZyNSIiIr2XT0Fn48aN5OXlsWXLFtauXUtLSwtTpkyhvr7e02bhwoW8+eabrFixgo0bN1JZWcm0adNO29dzzz1HVVWVZ8rJyTnrsWfOnMlHH33E2rVrWb16NZs2bWL+/Pm+lN8r7P2ynrUfu4OhBggUERHpHIthGMaFbnzo0CHi4uLYuHEjEyZMwOFwEBsby/Lly7nlllsA+OSTTxg1ahQlJSWMHz/efVCLhZUrV54z3LT7+OOPueyyy3jnnXe49tprAVizZg033HADBw4cIDEx8Zz7cDqd2O12HA4HUVE9d+C9B1bt4IWSz5k0Mpbnbh9ndjkiIiKm6uzf70710XE4HADExMQAUFpaSktLC5mZmZ42qampJCcnU1JS4rVtXl4eAwcOZNy4cTz77LOcLW+VlJQQHR3tCTkAmZmZWK1Wtm7d2uE2TU1NOJ1Or6mnq21oZsX2A4AGCBQREfGH4Avd0OVycffdd3PdddcxevRoAKqrqwkNDSU6OtqrbXx8PNXV1Z73P//5z7n++uuJiIjgf//3f/nxj39MXV0dd911V4fHqq6uJi4uzrvw4GBiYmK89nuqoqIiFi1adKEfzxRrdlRzvKWN1IRIvnbxALPLERER6fUuOOjk5eWxY8cONm/e7PO2999/v2f+6quvpr6+nscee+yMQedCFBYWUlBQ4HnvdDpJSkry2/67QunnRwGYPCoOi0UDBIqIiHTWBV26ys/PZ/Xq1axfv54hQ4Z4lickJNDc3Extba1X+5qaGhISEs64v/T0dA4cOEBTU1OH6xMSEjh48KDXstbWVo4cOXLG/dpsNqKiorymnq60wh10rkm+yORKREREAoNPQccwDPLz81m5ciXr1q0jJcX7rqC0tDRCQkIoLi72LCsvL6eiooKMjIwz7resrIyLLroIm63jW6kzMjKora2ltLTUs2zdunW4XC7S09N9+Qg9Vm1DM58dct+9drWCjoiIiF/4dOkqLy+P5cuXs2rVKiIjIz39Y+x2O+Hh4djtdnJzcykoKCAmJoaoqCgWLFhARkaG546rN998k5qaGsaPH09YWBhr167l17/+Nffcc4/nONu2bWP27NkUFxczePBgRo0aRXZ2NvPmzeOZZ56hpaWF/Px8ZsyYcV53XPUG71XUApAysB8x/ULNLUZERCRA+BR0lixZAsDEiRO9lj/33HPMnTsXgCeeeAKr1cr06dNpamoiKyuLp59+2tM2JCSExYsXs3DhQgzDYMSIETz++OPMmzfP06ahoYHy8nJaWlo8y1566SXy8/OZPHmyZ/9PPfWUr5+3x3pXl61ERET8rlPj6PQmPX0cnVt/v4W39xzmV98Zzcx0PfZBREQETB5HR/yjzWXw/v5aQGd0RERE/ElBpwcorz5GfXMb/W3BXBofaXY5IiIiAUNBpwdov638qqRogqwaP0dERMRfFHR6gPc+b++IHG1uISIiIgFGQacHaL/j6uqh6p8jIiLiTwo6Jjtc18S+ww0AXJOkoCMiIuJPCjome/fEQIEj4vpjjwgxtxgREZEAo6BjspMDBUabW4iIiEgAUtAx2bufa0RkERGRrqKgY6KWNhcfHHAAkKaOyCIiIn6noGOiT6qOcbyljaiwYC6O7W92OSIiIgFHQcdE7f1zrkq+CKsGChQREfE7BR0TqSOyiIhI11LQMVF70FH/HBERka6hoGOSg8ca2X/kOBaL+xlXIiIi4n8KOiZ59/NaAC6NiyQyTAMFioiIdAUFHZO8194/Z2i0uYWIiIgEMAUdk5zsiKz+OSIiIl1FQccEza0u3j8xUOA16ogsIiLSZRR0TLCzyklzq4voiBCGD+xndjkiIiIBS0HHBO3Pt7o6KRqLRQMFioiIdBUFHRNo/BwREZHuoaBjAj2xXEREpHso6HSzakcjlY5GrBYYo4ECRUREupSCTjdrv2w1MiGKfrZgk6sREREJbAo63az08/b+OdHmFiIiItIHKOh0Mw0UKCIi0n0UdLpRU2sbH33hBBR0REREuoOCTjfa8YWT5jYXMf1CGTogwuxyREREAp6CTjc69bZyDRQoIiLS9RR0utG7emK5iIhIt/Ip6BQVFTF27FgiIyOJi4sjJyeH8vJyrzaNjY3k5eUxYMAA+vfvz/Tp06mpqfGsf//99/n+979PUlIS4eHhjBo1iv/+7/8+57GHDRuGxWLxmh5++GFfyjeVYRjqiCwiItLNfAo6GzduJC8vjy1btrB27VpaWlqYMmUK9fX1njYLFy7kzTffZMWKFWzcuJHKykqmTZvmWV9aWkpcXBwvvvgiH330Ef/1X/9FYWEhv/3tb895/J///OdUVVV5pgULFvhSvqkqHY3UOJsIsloYMyTa7HJERET6BJ9GrFuzZo3X+2XLlhEXF0dpaSkTJkzA4XCwdOlSli9fzvXXXw/Ac889x6hRo9iyZQvjx4/nBz/4gdc+hg8fTklJCa+99hr5+flnPX5kZCQJCQm+lNxjtI+fc9mgKMJDg0yuRkREpG/oVB8dh8MBQExMDOA+W9PS0kJmZqanTWpqKsnJyZSUlJx1P+37OJuHH36YAQMGcPXVV/PYY4/R2tp6xrZNTU04nU6vyUwnOyJHm1qHiIhIX3LBzyBwuVzcfffdXHfddYwePRqA6upqQkNDiY6O9mobHx9PdXV1h/t5++23efXVV/nrX/961uPdddddXHPNNcTExPD2229TWFhIVVUVjz/+eIfti4qKWLRoke8frIu85+mIrP45IiIi3eWCg05eXh47duxg8+bNF3zwHTt2cPPNN/Pggw8yZcqUs7YtKCjwzF955ZWEhobywx/+kKKiImw222ntCwsLvbZxOp0kJSVdcK2d0djSxkeVGihQRESku13Qpav8/HxWr17N+vXrGTJkiGd5QkICzc3N1NbWerWvqak5rW/Nzp07mTx5MvPnz+dnP/uZzzWkp6fT2trKvn37Olxvs9mIiorymszywQEHrS6D2EgbQy4KN60OERGRvsanoGMYBvn5+axcuZJ169aRkpLitT4tLY2QkBCKi4s9y8rLy6moqCAjI8Oz7KOPPmLSpEnMmTOHX/3qVxdUeFlZGVarlbi4uAvavjudvK08WgMFioiIdCOfLl3l5eWxfPlyVq1aRWRkpKffjd1uJzw8HLvdTm5uLgUFBcTExBAVFcWCBQvIyMhg/PjxgPty1fXXX09WVhYFBQWefQQFBREbGwvAtm3bmD17NsXFxQwePJiSkhK2bt3KpEmTiIyMpKSkhIULFzJr1iwuuqjnXwo6dURkERER6T4+BZ0lS5YAMHHiRK/lzz33HHPnzgXgiSeewGq1Mn36dJqamsjKyuLpp5/2tP3zn//MoUOHePHFF3nxxRc9y4cOHeq5DNXQ0EB5eTktLS2A+zLUK6+8wkMPPURTUxMpKSksXLjQqw9OT+UeKLAWgDR1RBYREelWFsMwDLOL6A5OpxO73Y7D4ejW/joVhxuY8Nh6QoIsfPhQFmEhGkNHRETkfHX277eeddXF2vvnXJZoV8gRERHpZgo6XezUjsgiIiLSvRR0ulh70FH/HBERke6noNOFGppb+bjqGKA7rkRERMygoNOF3t/voM1lkBAVRmK0BgoUERHpbgo6XcjTP2dotLmFiIiI9FEKOl3I8yBPXbYSERExhYJOFzl1oEA9sVxERMQcCjpdZN/hBo7UNxMaZOXyRPMeKCoiItKXKeh0kfbnW40eHIUtWAMFioiImEFBp4uUavwcERER0/n0UE85f3piuYiI+IvL5aK5udnsMrpMaGgoVmvXnHtR0OkCdU2tfFpzYqBAndEREZFOaG5uZu/evbhcLrNL6TJWq5WUlBRCQ0P9vm8FnS7w/v5aXAYMjg4nPirM7HJERKSXMgyDqqoqgoKCSEpK6rKzHmZyuVxUVlZSVVVFcnIyFovFr/tX0OkCpe2XrXQ2R0REOqG1tZWGhgYSExOJiIgwu5wuExsbS2VlJa2trYSEhPh134EXDXsAPbFcRET8oa2tDaBLLun0JO2fr/3z+pOCjp+5XAbvtQ8UqI7IIiLiB/6+nNPTdOXnU9Dxs8++rMdxvAVbsJVRgzRQoIiIiJkUdPys/bbyMUOiCQ3W1ysiImIm/SX2s/b+OVfrieUiItLHLV68mGHDhhEWFkZ6ejrbtm3r9hoUdPzsXT2xXEREhFdffZWCggIefPBB3n33XcaMGUNWVhYHDx7s1joUdPzIcbyFXQfrAAUdERHp2x5//HHmzZvH7bffzmWXXcYzzzxDREQEzz77bLfWoXF0/Khsfy2GAckxEcRG2swuR0REAoxhGBxv8f8t2OcjPCTovO+Oam5uprS0lMLCQs8yq9VKZmYmJSUlXVVihxR0/Ojk862izS1EREQC0vGWNi574B+mHHvnz7OICD2/2PDll1/S1tZGfHy81/L4+Hg++eSTrijvjHTpyo88/XM0IrKIiEiPoDM6fuJyGZRpoEAREelC4SFB7Px5lmnHPl8DBw4kKCiImpoar+U1NTUkJCT4u7SzUtDxk10H6zjW1EpEaBCpCZFmlyMiIgHIYrGc9+UjM4WGhpKWlkZxcTE5OTmA++GdxcXF5Ofnd2stPf/b6iXaL1tdOcROcJCuCIqISN9WUFDAnDlzuPbaaxk3bhxPPvkk9fX13H777d1ah4KOn5zsiKzLViIiIt/73vc4dOgQDzzwANXV1Vx11VWsWbPmtA7KXU1Bx0/az+ikqSOyiIgIAPn5+d1+qeqrdI3FD2obmtlzqB6Aq3VGR0REpMfwKegUFRUxduxYIiMjiYuLIycnh/Lycq82jY2N5OXlMWDAAPr378/06dNP63VdUVHBt7/9bSIiIoiLi+Pee++ltbX1rMc+cuQIM2fOJCoqiujoaHJzc6mrq/Ol/C7z3om7rVIG9iOmX6i5xYiIiIiHT0Fn48aN5OXlsWXLFtauXUtLSwtTpkyhvr7e02bhwoW8+eabrFixgo0bN1JZWcm0adM869va2vj2t79Nc3Mzb7/9Ns8//zzLli3jgQceOOuxZ86cyUcffcTatWtZvXo1mzZtYv78+T5+3K7heZCnBgoUERHpWYxOOHjwoAEYGzduNAzDMGpra42QkBBjxYoVnjYff/yxARglJSWGYRjG3/72N8NqtRrV1dWeNkuWLDGioqKMpqamDo+zc+dOAzDeeecdz7K///3vhsViMb744ovzqtXhcBiA4XA4fP6c5/L935UYQ3+62nhxyz6/71tERPqu48ePGzt37jSOHz9udild6myfs7N/vzvVR8fhcAAQExMDQGlpKS0tLWRmZnrapKamkpyc7Hm2RUlJCVdccYVXr+usrCycTicfffRRh8cpKSkhOjqaa6+91rMsMzMTq9XK1q1bO9ymqakJp9PpNXWFtqMVfOPA7/g/wct1x5WIiEgPc8F3XblcLu6++26uu+46Ro8eDUB1dTWhoaFER0d7tY2Pj6e6utrTpqNnX7Sv60h1dTVxcXHehQcHExMTc8ZtioqKWLRokc+fy1f7vqjmTstfaAiyYYsN7/LjiYiIyPm74DM6eXl57Nixg1deecWf9fhNYWEhDofDM+3fv79LjtM/aTRNQf2JsDQRdGhnlxxDRERELswFBZ38/HxWr17N+vXrGTJkiGd5QkICzc3N1NbWerU/9dkWCQkJHT77on1dRxISEjh48KDXstbWVo4cOXLGbWw2G1FRUV5TV4i3R2AbOtb9Zv+2LjmGiIiIXBifgo5hGOTn57Ny5UrWrVtHSkqK1/q0tDRCQkIoLi72LCsvL6eiooKMjAwAMjIy+PDDD72Cy9q1a4mKiuKyyy7r8LgZGRnU1tZSWlrqWbZu3TpcLhfp6em+fISukTTO/XrgHXPrEBERES8+BZ28vDxefPFFli9fTmRkJNXV1VRXV3P8+HEA7HY7ubm5FBQUsH79ekpLS7n99tvJyMhg/PjxAEyZMoXLLruM2267jffff59//OMf/OxnPyMvLw+bzQbAtm3bSE1N5YsvvgBg1KhRZGdnM2/ePLZt28Zbb71Ffn4+M2bMIDEx0Z/fx4VpDzo6oyMiItKj+BR0lixZgsPhYOLEiQwaNMgzvfrqq542TzzxBP/2b//G9OnTmTBhAgkJCbz22mue9UFBQaxevZqgoCAyMjKYNWsWs2fP5uc//7mnTUNDA+Xl5bS0tHiWvfTSS6SmpjJ58mRuuOEGvv71r/O73/2uM5/dfwafuBvs6F6oO2RuLSIiIj3Apk2buPHGG0lMTMRisfD666+bUodPd10ZhnHONmFhYSxevJjFixefsc3QoUP529/+dsb1EydOPO1YMTExLF++/PyL7U7h0RCbCoc+gQPbIPXbZlckIiJiqvr6esaMGcMPfvADr4GDu5se6ukvQ8a6g85+BR0REZGpU6cydepUs8tQ0PGbpHR474/qkCwiIl3HMKClwZxjh0SAxWLOsTtBQcdf2jskf/EutLVAUIi59YiISOBpaYBfm3QTzn2VENrPnGN3QqceASGnGHAJhNmh9ThUf2h2NSIiIoLO6PiP1erup7P7n+7LV4OvMbsiEREJNCER7jMrZh27F1LQ8aekdHfQ2b8N0n9odjUiIhJoLJZeefnITAo6/jREj4IQEREBqKurY/fu3Z73e/fupaysjJiYGJKTk7utDgUdfxqcBljAUQHHqiGy4+dwiYiIBLrt27czadIkz/uCggIA5syZw7Jly7qtDgUdfwqLgvjLoWaH+6zOZTeZXZGIiIgpOhr81wy668rf2i9fHdDlKxEREbMp6PibHvApIiLSYyjo+NuQE0Gnsgxam00tRUREpK9T0PG3ARdDeAy0NUH1B2ZXIyIi0qcp6PibxaLLVyIiIj2Egk5X8Iyns9XcOkREJCD0hLuXulJXfj4Fna7QfkZHTzIXEZFOCAoKAqC5ObD7fLZ/vvbP608aR6crJF4DliBwfgGOA2AfYnZFIiLSCwUHBxMREcGhQ4cICQnBag288xMul4tDhw4RERFBcLD/Y4mCTlew9XcPHFj9gbufjoKOiIhcAIvFwqBBg9i7dy+ff/652eV0GavVSnJyMhaLxe/7VtDpKknj3EHnwDsweprZ1YiISC8VGhrKJZdcEtCXr0JDQ7vsbJWCTlcZMg7e+YPuvBIRkU6zWq2EhYWZXUavFHgX+3qK9g7JVe9DS6O5tYiIiPRRCjpd5aJh0C8WXC1QVWZ2NSIiIn2Sgk5XsVhOPg5Cl69ERERMoaDTlZL0JHMREREzKeh0paR09+v+bRDgo1qKiIj0RAo6XSnxarAGQ10N1FaYXY2IiEifo6DTlULCIeEK97weByEiItLtFHS6mjoki4iImEZBp6t5HvCpoCMiItLdFHS6WnvQqf4QmhvMrUVERKSPUdDpavYk6J8ArlaofM/sakRERPoUn4POpk2buPHGG0lMTMRisfD66697ra+pqWHu3LkkJiYSERFBdnY2u3bt8qzft28fFoulw2nFihVnPO7cuXNPa5+dne1r+d3PYtF4OiIiIibxOejU19czZswYFi9efNo6wzDIycnhs88+Y9WqVbz33nsMHTqUzMxM6uvrAUhKSqKqqsprWrRoEf3792fq1KlnPXZ2drbXdi+//LKv5ZvDM56O7rwSERHpTj4/vXzq1KlnDCS7du1iy5Yt7Nixg8svvxyAJUuWkJCQwMsvv8wdd9xBUFAQCQkJXtutXLmS7373u/Tv3/+sx7bZbKdt2yt47rza6h440GIxtx4REZE+wq99dJqamgC8HiVvtVqx2Wxs3ry5w21KS0spKysjNzf3nPvfsGEDcXFxjBw5kjvvvJPDhw+ftRan0+k1mWbQGLCGQMOXcHSveXWIiIj0MX4NOqmpqSQnJ1NYWMjRo0dpbm7mkUce4cCBA1RVVXW4zdKlSxk1ahRf+9rXzrrv7OxsXnjhBYqLi3nkkUfYuHEjU6dOpa2trcP2RUVF2O12z5SUlNTpz3fBQsLcYQd0+UpERKQb+TXohISE8Nprr/Hpp58SExNDREQE69evZ+rUqVitpx/q+PHjLF++/LzO5syYMYObbrqJK664gpycHFavXs0777zDhg0bOmxfWFiIw+HwTPv37+/sx+uc9n466pAsIiLSbfx+e3laWhplZWXU1tZSVVXFmjVrOHz4MMOHDz+t7Z///GcaGhqYPXu2z8cZPnw4AwcOZPfu3R2ut9lsREVFeU2mar/zav9Wc+sQERHpQ7psHB273U5sbCy7du1i+/bt3Hzzzae1Wbp0KTfddBOxsbE+7//AgQMcPnyYQYMG+aPcrtfeIbnmI2iqM7cWERGRPsLnoFNXV0dZWRllZWUA7N27l7KyMioq3E/nXrFiBRs2bPDcYv6tb32LnJwcpkyZ4rWf3bt3s2nTJu64444Oj5OamsrKlSs9x7z33nvZsmUL+/bto7i4mJtvvpkRI0aQlZXl60cwh30wRA0GwwWV75pdjYiISJ/gc9DZvn07V199NVdffTUABQUFXH311TzwwAMAVFVVcdttt5Gamspdd93Fbbfd1uF4N88++yxDhgw5LQC1Ky8vx+FwABAUFMQHH3zATTfdxKWXXkpubi5paWn861//wmaz+foRzJOkB3yKiIh0J4thGIbZRXQHp9OJ3W7H4XCY11+n5Gn4RyFckgUz/2RODSIiIr1IZ/9+61lX3cnzJPN33AMHioiISJdS0OlOCVdCkA2OH4HDe8yuRkREJOAp6HSn4FBIdPdt0ng6IiIiXU9Bp7tpPB0REZFuo6DT3TwP+NSjIERERLqagk53a++QfHAnNJr4oFEREZE+QEGnu0UmQHQyYMAX282uRkREJKAp6JhBl69ERES6hYKOGTzj6ejOKxERka6koGOGUwcOdLnMrUVERCSAKeiYIX40BIdDowO+/NTsakRERAKWgo4ZgkJg8DXueV2+EhER6TIKOmYZ0j5woIKOiIhIV1HQMUtSuvv1gO68EhER6SoKOmZpP6Nz6BM4ftTcWkRERAKUgo5Z+sfCRSnu+QOl5tYiIiISoBR0zKTxdERERLqUgo6Z2oOOOiSLiIh0CQUdM7U/CuLAdnC1mVuLiIhIAFLQMVPcZRDSD5qPuTsli4iIiF8p6JgpKPjkwIG6fCUiIuJ3Cjpm03g6IiIiXUZBx2yeDslbza1DREQkACnomK194MDDu6HhiLm1iIiIBBgFHbNFxMCAEe55Xb4SERHxKwWdnqC9n446JIuIiPiVgk5P4HmSufrpiIiI+JOCTk/Q3iH5i3ehrdXcWkRERAKIgk5PEJsKoZHQUg8Hd5pdjYiISMBQ0OkJrEEw5Fr3vB7wKSIi4jcKOj2FHvApIiLidz4HnU2bNnHjjTeSmJiIxWLh9ddf91pfU1PD3LlzSUxMJCIiguzsbHbt2uXVZuLEiVgsFq/pRz/60VmPaxgGDzzwAIMGDSI8PJzMzMzT9turDVHQERER8Tefg059fT1jxoxh8eLFp60zDIOcnBw+++wzVq1axXvvvcfQoUPJzMykvr7eq+28efOoqqryTI8++uhZj/voo4/y1FNP8cwzz7B161b69etHVlYWjY2Nvn6Enqn90tXRvVB3yNxaREREAkSwrxtMnTqVqVOndrhu165dbNmyhR07dnD55ZcDsGTJEhISEnj55Ze54447PG0jIiJISEg4r2MahsGTTz7Jz372M26++WYAXnjhBeLj43n99deZMWOGrx+j5wmPdndKPvSJe+DA1BvMrkhERKTX82sfnaamJgDCwsJOHsBqxWazsXnzZq+2L730EgMHDmT06NEUFhbS0NBwxv3u3buX6upqMjMzPcvsdjvp6emUlJScsRan0+k19XgaT0dERMSv/Bp0UlNTSU5OprCwkKNHj9Lc3MwjjzzCgQMHqKqq8rS79dZbefHFF1m/fj2FhYX88Y9/ZNasWWfcb3V1NQDx8fFey+Pj4z3rvqqoqAi73e6ZkpKS/PAJu1jyePfrp2vAMMytRUREJAD4NeiEhITw2muv8emnnxITE0NERATr169n6tSpWK0nDzV//nyysrK44oormDlzJi+88AIrV65kz549fqulsLAQh8Phmfbv3++3fXeZUTdCaH/35avdxWZXIyIi0uv5/fbytLQ0ysrKqK2tpaqqijVr1nD48GGGDx9+xm3S093Petq9e3eH69v78tTU1Hgtr6mpOWM/H5vNRlRUlNfU44XZ4ZrZ7vmS35pbi4iISADosnF07HY7sbGx7Nq1i+3bt3s6EXekrKwMgEGDBnW4PiUlhYSEBIqLT57lcDqdbN26lYyMDL/Wbbr0H4HFCp+th+odZlcjIiLSq/kcdOrq6igrK/OEk71791JWVkZFRQUAK1asYMOGDZ5bzL/1rW+Rk5PDlClTANizZw+/+MUvKC0tZd++fbzxxhvMnj2bCRMmcOWVV3qOk5qaysqVKwGwWCzcfffd/PKXv+SNN97gww8/ZPbs2SQmJpKTk9PJr6CHuWgojLrJPb/laXNrERER6eV8vr18+/btTJo0yfO+oKAAgDlz5rBs2TKqqqooKCigpqaGQYMGMXv2bO6//35P+9DQUP75z3/y5JNPUl9fT1JSEtOnT+dnP/uZ13HKy8txOBye9z/5yU+or69n/vz51NbW8vWvf501a9Z43eEVML62AHa+Dh/8CSY/AJHndxu+iIiIeLMYRt+4vcfpdGK323E4HL2jv87SKe7bzL9xD0y+/9ztRUREAlBn/37rWVc9VUa++3X7UmiuP3tbERER6ZCCTk+V+m24aBgcPwrvv2x2NSIiIr2Sgk5PZQ2C8T92z5c8DS6XufWIiIj0Qgo6PdlVM91j6xzZ4x4tWURERHyioNOT2fpD2u3ueQ0gKCIi4jMFnZ5u3HywBsPnb8EX75pdjYiISK+ioNPT2QfD6Onu+ZLF5tYiIiLSyyjo9AYZee7Xj1aC44C5tYiIiPQiCjq9waAxMOwbYLTB1mfMrkZERKTXUNDpLdoHECx9HpqOmVuLiIhIL6Gg01tcMgUGXAJNTnj3j2ZXIyIi0iso6PQWVitknBhAcOsSaGs1tx4REZFeQEGnNxnzfQiPgdoK+ORNs6sRERHp8RR0epOQcBh7h3tet5qLiIick4JObzNuHgSFwoF3oGKr2dWIiIj0aAo6vU3/OLjyu+55PRZCRETkrBR0eqP2W80/WQ1H9ppbi4iISA+moNMbxY2CiyeD4dIAgiIiImehoNNbfe3EWZ13/wjHj5pbi4iISA+loNNbDZ8EcZdDS717tGQRERE5jYJOb2WxnHzY59b/gdZmc+sRERHpgRR0erMrboH+8XCsEna+bnY1IiIiPY6CTm8WbHOPqwPw9m/AMMytR0REpIdR0Ontrs2F4HCo/gD2bTa7GhERkR5FQae3i4iBq251z2sAQRERES8KOoFg/I8BC3y6Br7cZXY1IiIiPYaCTiAYOAJGTnXP62GfIiIiHgo6gaL9VvP3X4b6w+bWIiIi0kMo6ASKodfBoKugtRG2LzW7GhERkR5BQSdQWCwnH/a57XfQ0mhuPSIiIj2Agk4guTwHogZD/SH4cIXZ1YiIiJjO56CzadMmbrzxRhITE7FYLLz++ute62tqapg7dy6JiYlERESQnZ3Nrl0n7wQ6cuQICxYsYOTIkYSHh5OcnMxdd92Fw+E463Hnzp2LxWLxmrKzs30tP7AFhUD6D93zJYs1gKCIiPR5Pged+vp6xowZw+LFp9/dYxgGOTk5fPbZZ6xatYr33nuPoUOHkpmZSX19PQCVlZVUVlbyf//v/2XHjh0sW7aMNWvWkJube85jZ2dnU1VV5ZlefvllX8sPfNfMgdD+cOhj2FNsdjUiIiKmCvZ1g6lTpzJ16tQO1+3atYstW7awY8cOLr/8cgCWLFlCQkICL7/8MnfccQejR4/mL3/5i2ebiy++mF/96lfMmjWL1tZWgoPPXJLNZiMhIcHXkvuW8Gi4+jbYusR9VmdEptkViYiImMavfXSampoACAsLO3kAqxWbzcbmzWd+PIHD4SAqKuqsIQdgw4YNxMXFMXLkSO68804OHz7zbdRNTU04nU6vqc8Y/yOwWGHPOqjeYXY1IiIipvFr0ElNTSU5OZnCwkKOHj1Kc3MzjzzyCAcOHKCqqqrDbb788kt+8YtfMH/+/LPuOzs7mxdeeIHi4mIeeeQRNm7cyNSpU2lra+uwfVFREXa73TMlJSV1+vP1GhcNg1E3uudfmwfHa82sRkRExDQWw7jwHqsWi4WVK1eSk5PjWVZaWkpubi7vv/8+QUFBZGZmYrVaMQyDv//9717bO51OvvWtbxETE8Mbb7xBSEjIeR/7s88+4+KLL+af//wnkydPPm19U1OT5wxT+7GSkpI8Z48CXu1++EMm1FW7x9iZ9RqEhJ17OxERkR7E6XRit9sv+O+3328vT0tLo6ysjNraWqqqqlizZg2HDx9m+PDhXu2OHTtGdnY2kZGRrFy50qeQAzB8+HAGDhzI7t27O1xvs9mIiorymvqU6CSY9WewRcHnb8HK+eDq+OyXiIhIoOqycXTsdjuxsbHs2rWL7du3c/PNN3vWOZ1OpkyZQmhoKG+88YZXn57zdeDAAQ4fPsygQYP8WXZgSbgCvvciWENg5ypYU6hbzkVEpE/xOejU1dVRVlZGWVkZAHv37qWsrIyKigoAVqxYwYYNGzy3mH/rW98iJyeHKVOmACdDTn19PUuXLsXpdFJdXU11dbVXf5vU1FRWrlzpOea9997Lli1b2LdvH8XFxdx8882MGDGCrKyszn4HgW34N+E7z7jnt/0PvPWkqeWIiIh0J59vL9++fTuTJk3yvC8oKABgzpw5LFu2jKqqKgoKCqipqWHQoEHMnj2b+++/39P+3XffZevWrQCMGDHCa9979+5l2LBhAJSXl3sGEQwKCuKDDz7g+eefp7a2lsTERKZMmcIvfvELbDabrx+h77niFqirgX/cB/98CCIHwZgZZlclIiLS5TrVGbk36WxnpoDwj/+Ckt+CNRhufVVj7IiISI/X4zojSw/2rV/AFf8OrlZ4dTZUvmd2RSIiIl1KQacvsVrh5qdh+ERoqYeX/h2OfGZ2VSIiIl1GQaevCQ6F7/7RfUdW/SF4cTrUHTK7KhERkS6hoNMXhUXBzL9AdLL7jM7y70JTndlViYiI+J2CTl8VGQ+zVkJ4DFS+CyvmQFuL2VWJiIj4lYJOXzZwBMxcAcHhsPuf8MZdGlBQREQCioJOXzfkWvj3ZWAJgveXw7pfmF2RiIiI3yjoCIzMhn97wj3/r/8H235vbj0iIiJ+oqAjbmlzYOJ97vm/3Qs73zC3HhERET9Q0JGTvvkTSJsLGPCXO+Dzt82uSEREpFMUdOQkiwVu+H8w8gZoa4KXZ8DBj82uSkRE5IIp6Ii3oGCYvhSGjINGh3tAQccXZlclIiJyQRR05HShEe6Hfg68FJxfwEu3wPFas6sSERHxmYKOdCwiBmb9BfonwMGd8MqtelSEiIj0Ogo6cmbRyTDrz2CLgs/fgqeuhs1PQEuj2ZWJiIicFwUdObuEK2D2Khg0BpqPwT8fgt+OhQ//rFGURUSkx1PQkXMbfA3M2wA5z0BkIjgq4C+58IfJULHF7OpERETOSEFHzo/VCld9HxaUwqSfQUg/+KIUns2CV29zPwVdRESkh1HQEd+ERsA374W73oNr5oDFCh+/Ab8dB2vug+NHza5QRETEQ0FHLkxkPNz0FPxoM1w8GVwtsGUx/PdVUPI0tDabXaGIiIiCjnRS/OVw22sw8y8QOwoaa+EfhfB0Onz8pjosi4iIqRR0xD8uyXSf3fm3J6FfrLvPzquz4Lkb4It3za5ORET6KAUd8Z+gYLj2dnf/nW/cA8FhUPE2/H4S/GUe1O43u0IREeljFHTE/2yRMPl+9x1aV85wL/vwT/Dba+Gfi6DRaW59IiLSZ1gMo290onA6ndjtdhwOB1FRUWaX07dUvgf/+Bl8vtn9PiQCUia4OzGPmAwDLja3PhER6bE6+/dbQUe6h2FA+d9g7YNweJf3uotS3IFnRCYM+wbY+ptTo4iI9DgKOudJQaeHcLmgZgfsKYbdxe6RlV0tJ9dbQyB5/MngEz8aLBbz6hUREVMp6JwnBZ0equkY7P3XieDzTzi6z3t9//iTl7guvt79VHUREekzFHTOk4JOL3F4j/tMz55i2LsJWhpOWWlxP3fr4hNnewanue/0EhGRgKWgc54UdHqh1iaoKHEHn93FcPAj7/Vhdki82t3HJ2b4yemiYe5HVYiISK+noHOeFHQCgLMS9qw7ccZnnXsU5jOJHHQi+JwIQZ4wlOIOSCIi0it0e9DZtGkTjz32GKWlpVRVVbFy5UpycnI862tqavjpT3/K//7v/1JbW8uECRP4zW9+wyWXXOJp09jYyH/+53/yyiuv0NTURFZWFk8//TTx8fFnPK5hGDz44IP8/ve/p7a2luuuu44lS5Z47fdsFHQCjKsNqsrgULl7FOYje0+87oFGx9m3jRh4MgB5zgKlQL+BEH4R2KLcT2sXERHTdfbvt88dHOrr6xkzZgw/+MEPmDZtmtc6wzDIyckhJCSEVatWERUVxeOPP05mZiY7d+6kX79+ACxcuJC//vWvrFixArvdTn5+PtOmTeOtt94643EfffRRnnrqKZ5//nlSUlK4//77ycrKYufOnYSFhfn6MaS3swa5++gMTjt9XcMRd/A52h5+TpnqD0HDl+7pwDsd79tihbBod+jxmjpadsoUZoegkK781CIi4qNOXbqyWCxeZ3Q+/fRTRo4cyY4dO7j88ssBcLlcJCQk8Otf/5o77rgDh8NBbGwsy5cv55ZbbgHgk08+YdSoUZSUlDB+/PjTjmMYBomJifznf/4n99xzDwAOh4P4+HiWLVvGjBkzzlmrzugI4L7L68hXAtDRfe5lx498pfPzBQiNdAei4DAICYPg8M69BtncHa6twe5b763B536vs1EiEkC6/YzO2TQ1NQF4nWGxWq3YbDY2b97MHXfcQWlpKS0tLWRmZnrapKamkpycfMags3fvXqqrq722sdvtpKenU1JS0mHQaWpq8tQD7i9KBFskDLrSPXWkpdHd9+f40a9MHS07ZV3Tictlzcfck5ks1jMEoWD3OovlxKsVLEGnzFvdIenU92daj+XE+EZfee1wHae8t3a8nbvRKW2/+v5M6+igrdeXccrsWdadz/oztrvQ9hfCj/sK+PGpAv3z9VD9BsKEe8yuwotfg057YCksLOR//ud/6NevH0888QQHDhygqqoKgOrqakJDQ4mOjvbaNj4+nurq6g732778q314zrZNUVERixYt6uQnkj4nJAxCEiAywbft2lqhyXky+LQed4em83ltbYKW49DaePpra6O7P5KrFdpaTsy3nHxPBydkDRe0NbsnEZHuNOCSwA46ISEhvPbaa+Tm5hITE0NQUBCZmZlMnTqV7r65q7CwkIKCAs97p9NJUlJSt9YgfUhQsHsww+4e0NDlcoceT/hpPcv7NncIMgww2udPmbzWu05v4zr1vQEYHb8arjOvgw62B09g6/D92dZ19P6UZV+Z9V7+1f9POtu6jpxHm/P+/z1/7qu79dS6xBQRA8yu4DR+H20tLS2NsrIyHA4Hzc3NxMbGkp6ezrXXXgtAQkICzc3N1NbWep3VqampISGh439Fty+vqalh0KBBXttcddVVHW5js9mw2Wz++VAiPZXVCtZQINTsSkREeqQu67Vot9uJjY1l165dbN++nZtvvhlwB6GQkBCKi4s9bcvLy6moqCAjI6PDfaWkpJCQkOC1jdPpZOvWrWfcRkRERMTnMzp1dXXs3r3b837v3r2UlZURExNDcnIyK1asIDY2luTkZD788EP+4z/+g5ycHKZMmQK4A1Bubi4FBQXExMQQFRXFggULyMjI8OqInJqaSlFREd/5znewWCzcfffd/PKXv+SSSy7x3F6emJjoNYaPiIiIyKl8Djrbt29n0qRJnvft/WDmzJnDsmXLqKqqoqCgwHOZafbs2dx///1e+3jiiSewWq1Mnz7da8DAU5WXl+NwnBz47Sc/+Qn19fXMnz+f2tpavv71r7NmzRqNoSMiIiJnpEdAiIiISI/V2b/fGllMREREApaCjoiIiAQsBR0REREJWAo6IiIiErAUdERERCRgKeiIiIhIwFLQERERkYCloCMiIiIBS0FHREREApbfn17eU7UPAO10Ok2uRERERM5X+9/tC32QQ58JOseOHQMgKSnJ5EpERETEV8eOHcNut/u8XZ951pXL5aKyspLIyEgsFotf9+10OklKSmL//v16jlY30vduDn3v5tD3bg597+Y49XuPjIzk2LFjJCYmYrX63uOmz5zRsVqtDBkypEuPERUVpf8hmEDfuzn0vZtD37s59L2bo/17v5AzOe3UGVlEREQCloKOiIiIBCwFHT+w2Ww8+OCD2Gw2s0vpU/S9m0Pfuzn0vZtD37s5/Pm995nOyCIiItL36IyOiIiIBCwFHREREQlYCjoiIiISsBR0REREJGAp6HTS4sWLGTZsGGFhYaSnp7Nt2zazSwp4Dz30EBaLxWtKTU01u6yAs2nTJm688UYSExOxWCy8/vrrXusNw+CBBx5g0KBBhIeHk5mZya5du8wpNkCc6zufO3fuab/97Oxsc4oNIEVFRYwdO5bIyEji4uLIycmhvLzcq01jYyN5eXkMGDCA/v37M336dGpqakyqODCcz/c+ceLE037zP/rRj3w6joJOJ7z66qsUFBTw4IMP8u677zJmzBiysrI4ePCg2aUFvMsvv5yqqirPtHnzZrNLCjj19fWMGTOGxYsXd7j+0Ucf5amnnuKZZ55h69at9OvXj6ysLBobG7u50sBxru8cIDs72+u3//LLL3djhYFp48aN5OXlsWXLFtauXUtLSwtTpkyhvr7e02bhwoW8+eabrFixgo0bN1JZWcm0adNMrLr3O5/vHWDevHlev/lHH33UtwMZcsHGjRtn5OXled63tbUZiYmJRlFRkYlVBb4HH3zQGDNmjNll9CmAsXLlSs97l8tlJCQkGI899phnWW1trWGz2YyXX37ZhAoDz1e/c8MwjDlz5hg333yzKfX0JQcPHjQAY+PGjYZhuH/bISEhxooVKzxtPv74YwMwSkpKzCoz4Hz1ezcMw/jmN79p/Md//Een9qszOheoubmZ0tJSMjMzPcusViuZmZmUlJSYWFnfsGvXLhITExk+fDgzZ86koqLC7JL6lL1791JdXe31+7fb7aSnp+v338U2bNhAXFwcI0eO5M477+Tw4cNmlxRwHA4HADExMQCUlpbS0tLi9XtPTU0lOTlZv3c/+ur33u6ll15i4MCBjB49msLCQhoaGnzab595qKe/ffnll7S1tREfH++1PD4+nk8++cSkqvqG9PR0li1bxsiRI6mqqmLRokV84xvfYMeOHURGRppdXp9QXV0N0OHvv32d+F92djbTpk0jJSWFPXv2cN999zF16lRKSkoICgoyu7yA4HK5uPvuu7nuuusYPXo04P69h4aGEh0d7dVWv3f/6eh7B7j11lsZOnQoiYmJfPDBB/z0pz+lvLyc11577bz3raAjvc7UqVM981deeSXp6ekMHTqUP/3pT+Tm5ppYmUjXmjFjhmf+iiuu4Morr+Tiiy9mw4YNTJ482cTKAkdeXh47duxQv79udqbvff78+Z75K664gkGDBjF58mT27NnDxRdffF771qWrCzRw4ECCgoJO63VfU1NDQkKCSVX1TdHR0Vx66aXs3r3b7FL6jPbfuH7/5ho+fDgDBw7Ub99P8vPzWb16NevXr2fIkCGe5QkJCTQ3N1NbW+vVXr93/zjT996R9PR0AJ9+8wo6Fyg0NJS0tDSKi4s9y1wuF8XFxWRkZJhYWd9TV1fHnj17GDRokNml9BkpKSkkJCR4/f6dTidbt27V778bHThwgMOHD+u330mGYZCfn8/KlStZt24dKSkpXuvT0tIICQnx+r2Xl5dTUVGh33snnOt770hZWRmAT795XbrqhIKCAubMmcO1117LuHHjePLJJ6mvr+f22283u7SAds8993DjjTcydOhQKisrefDBBwkKCuL73/++2aUFlLq6Oq9/Ne3du5eysjJiYmJITk7m7rvv5pe//CWXXHIJKSkp3H///SQmJpKTk2Ne0b3c2b7zmJgYFi1axPTp00lISGDPnj385Cc/YcSIEWRlZZlYde+Xl5fH8uXLWbVqFZGRkZ5+N3a7nfDwcOx2O7m5uRQUFBATE0NUVBQLFiwgIyOD8ePHm1x973Wu733Pnj0sX76cG264gQEDBvDBBx+wcOFCJkyYwJVXXnn+B+rUPVti/OY3vzGSk5ON0NBQY9y4ccaWLVvMLingfe973zMGDRpkhIaGGoMHDza+973vGbt37za7rICzfv16AzhtmjNnjmEY7lvM77//fiM+Pt6w2WzG5MmTjfLycnOL7uXO9p03NDQYU6ZMMWJjY42QkBBj6NChxrx584zq6mqzy+71OvrOAeO5557ztDl+/Ljx4x//2LjooouMiIgI4zvf+Y5RVVVlXtEB4Fzfe0VFhTFhwgQjJibGsNlsxogRI4x7773XcDgcPh3HcuJgIiIiIgFHfXREREQkYCnoiIiISMBS0BEREZGApaAjIiIiAUtBR0RERAKWgo6IiIgELAUdERERCVgKOiIiIhKwFHREREQkYCnoiIiISMBS0BEREZGApaAjIiIiAev/AzGUc64/x7t1AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "demandPotential.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
01
05525.0000005625.000000
15906.2500005256.250000
26101.5625005076.562500
36200.3906254987.890625
46250.0976564943.847656
56275.0244144921.899414
66287.5061044910.943604
76293.7515264905.470276
86296.8753814902.734756
96298.4375954901.367283
106299.2187744900.683618
116299.6093814900.341803
126299.8046894900.170900
136299.9023444900.085450
146299.9511724900.042725
156299.9755864900.021362
166299.9877934900.010681
176299.9938964900.005341
186299.9969484900.002670
196299.9984744900.001335
206299.9992374900.000668
216299.9996194900.000334
226299.9998094900.000167
236299.9999054900.000083
240.0000000.000000
\n", - "
" - ], - "text/plain": [ - " 0 1\n", - "0 5525.000000 5625.000000\n", - "1 5906.250000 5256.250000\n", - "2 6101.562500 5076.562500\n", - "3 6200.390625 4987.890625\n", - "4 6250.097656 4943.847656\n", - "5 6275.024414 4921.899414\n", - "6 6287.506104 4910.943604\n", - "7 6293.751526 4905.470276\n", - "8 6296.875381 4902.734756\n", - "9 6298.437595 4901.367283\n", - "10 6299.218774 4900.683618\n", - "11 6299.609381 4900.341803\n", - "12 6299.804689 4900.170900\n", - "13 6299.902344 4900.085450\n", - "14 6299.951172 4900.042725\n", - "15 6299.975586 4900.021362\n", - "16 6299.987793 4900.010681\n", - "17 6299.993896 4900.005341\n", - "18 6299.996948 4900.002670\n", - "19 6299.998474 4900.001335\n", - "20 6299.999237 4900.000668\n", - "21 6299.999619 4900.000334\n", - "22 6299.999809 4900.000167\n", - "23 6299.999905 4900.000083\n", - "24 0.000000 0.000000" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "profits" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "profits.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
01
0115.000000125.000000
1117.500000122.500000
2118.750000121.250000
3119.375000120.625000
4119.687500120.312500
5119.843750120.156250
6119.921875120.078125
7119.960938120.039062
8119.980469120.019531
9119.990234120.009766
10119.995117120.004883
11119.997559120.002441
12119.998779120.001221
13119.999390120.000610
14119.999695120.000305
15119.999847120.000153
16119.999924120.000076
17119.999962120.000038
18119.999981120.000019
19119.999990120.000010
20119.999995120.000005
21119.999998120.000002
22119.999999120.000001
23119.999999120.000001
240.0000000.000000
\n", - "
" - ], - "text/plain": [ - " 0 1\n", - "0 115.000000 125.000000\n", - "1 117.500000 122.500000\n", - "2 118.750000 121.250000\n", - "3 119.375000 120.625000\n", - "4 119.687500 120.312500\n", - "5 119.843750 120.156250\n", - "6 119.921875 120.078125\n", - "7 119.960938 120.039062\n", - "8 119.980469 120.019531\n", - "9 119.990234 120.009766\n", - "10 119.995117 120.004883\n", - "11 119.997559 120.002441\n", - "12 119.998779 120.001221\n", - "13 119.999390 120.000610\n", - "14 119.999695 120.000305\n", - "15 119.999847 120.000153\n", - "16 119.999924 120.000076\n", - "17 119.999962 120.000038\n", - "18 119.999981 120.000019\n", - "19 119.999990 120.000010\n", - "20 119.999995 120.000005\n", - "21 119.999998 120.000002\n", - "22 119.999999 120.000001\n", - "23 119.999999 120.000001\n", - "24 0.000000 0.000000" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "prices" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAGdCAYAAADey0OaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1A0lEQVR4nO3df5QU9YHv/U9V//4x3cOAM8Mo6ESNaFQkGMhEkzVxroi5LESSSJY9lxgP7CbgijwbI3sEYtaEaLKGxSWyyUk0eY4mxntWXN1d8nhQ4WaDqBCSGJWg4QoRZgBhpqe7p3/X80cNDQMjzDA9U/3j/TqnzlRXVVd/KPuc/vitqm7DsixLAAAAZc50OgAAAMBgUFoAAEBFoLQAAICKQGkBAAAVgdICAAAqAqUFAABUBEoLAACoCJQWAABQEdxOBzgbhUJB+/fvV11dnQzDcDoOAAAYBMuy1NPTo5aWFpnm0MdNKrK07N+/XxMmTHA6BgAAOAv79u3TeeedN+TnVWRpqaurk2T/oyORiMNpAADAYMRiMU2YMKH4OT5UFVlajp0SikQilBYAACrM2V7awYW4AACgIlBaAABARaC0AACAikBpAQAAFYHSAgAAKgKlBQAAVARKCwAAqAiUFgAAUBEoLQAAoCJQWgAAQEWgtAAAgIpAaQEAABWB0nKirr3Sz+dLrz8tZVNOpwEAACeoyF95HjG/f1J681l78kWly/5SuvIW6fxrJJN+BwCAkygtJ5r0P6VUzC4vsXel3/y/9hQ5V7ris9IVn5eaL3c6JQAANcmwLMtyOsRQxWIxRaNRdXd3KxKJlP4FCgXpnf+Wfv8L6Q9PS+nu4+saPyRd+Tnpis9J0fNK/9oAAFSp4X5+U1rOJJuSdv9/0u+esP/mM30rDPu00ZWfly6bLQXqRzYHAAAVjtIy0qXlRL1H7Yt0f/cLeyTmGJdX+uAM+/qXi2+Q3L7RywQAQIWgtIxmaTlR117p9//bLjCH3ji+3B+VLptjF5iJbVzACwBAH0qLU6XlGMuSOl+zTx/9/n9LPQeOr4ucK507VWq6XGr6kNR0mVR/AUUGAFCTKC1Ol5YTFfLS//2VfQHv6/8upWOnbuMJ2eWl6UN2mWm8zH4cGDP6eQEAGEWUlnIqLSfK9kp7X5I6/9A3vSYd2iXl0wNvHznv+GjMsZGZsRdJLs/o5gYAYIRQWsq1tAwkn5OOvG0XmM4/SJ2v23+79w68vcsrnXOJfZv1OR+Uwk1SqFEKn2P/DZ0jub2j+28AAOAsjXpp2bJli77zne9o+/btOnDggJ566inNmTNHkpTNZnXPPffoP//zP/WnP/1J0WhU7e3t+va3v62WlpbiPo4cOaLbb79dzzzzjEzT1Ny5c/XP//zPCofDg8pQsaXl/fR2SQffkA7+4YSRmdelTM+Zn+uvl8KN/ctM+By70IQa+9adY//1BEb6XwIAwPsa7uf3kL8RN5FIaPLkyfrSl76km2++ud+6ZDKpHTt2aMWKFZo8ebKOHj2qO+64Q3/5l3+pV199tbjd/PnzdeDAAT333HPKZrO69dZbtWjRIj3++OND/gdUhUC9dH6bPR1TKNgjMMdGY468LSUOSfGD9t/EIamQk1Jd9nT4j2d+HW+dXWgCYyRPUPKGJW9Q8obsa228IfvxifPecN+2J873rXd5JcMYoYMCAEB/wzo9ZBhGv5GWgbzyyiuaNm2a3nnnHU2cOFFvvPGGLrvsMr3yyiu6+uqrJUkbN27UTTfdpD//+c/9RmTeT9WNtJyNQsEuK/GDUuLg8TJTfHzoeLmJH3z/a2mGw3RLLp993Y3L2ze5T5j3SKbn+Hzxr2fg9aZLMlySYR6fN82+v64T/ponbTPAOsO0C5VhSjLOMG/0zZuyJFkyZRmGPW8ZsgxJMmTJLmj2X0My7JvHJKO4/bH1xW0s2c+37G2O69uXZUnF5x7b/4nzVnH+2PPslzy1LB7LMhBL1pCfc/y5A7/eqfs6Oavz7EjllQkYKaZpqum8C2WU8R2qoz7SMlTd3d0yDEP19fWSpK1bt6q+vr5YWCSpvb1dpmlq27Zt+sxnPnPKPtLptNLp4x+6sdgAd+XUGtOUgg32pEmn39ay7DuZ4ofsQpPqljIJe8ompUxcyiT7HvctzySL66xMUlbfNkYmIaPQ963AhZw9ZUf8Xztq+qoGAFSkl8d8WtPuqN6zFiNaWlKplL72ta/pC1/4QrFRdXR0qLGxsX8It1sNDQ3q6OgYcD+rV6/WvffeO5JRq1YindPheFqH43kd6gnrcNyjWKpRyXReyUxeyUyu399EJq/eTE6JdF69WXt5Klvot0+X8goqraBS8hpZeZWTW3l5lJNXOXmUl9vI9X+snLyGPe9Rzn7cN+/p29algkxZMlWQq28qzhv2vCmr3/KTtzVlyWUU+sY67Mk84e+xcRJThb6/1oDb9p9spzw2jg9SHltnz+uEeavfY9uJzzv+fA04r1OWv1+p6v8ag1s3uIJmDXq7Uqn24ni6/1bA2XCpIK+RU3P3TqejjKgRKy3ZbFaf//znZVmWHn744WHta/ny5Vq2bFnxcSwW04QJE4YbsSJZlqVYqq+I9KR1OJ7pKyX2dKjn+OP34hn1ZvMle23DkIIel4I+n4LeOgU8Lvk8Lnldhjwus286cf6kx25DHvP4vNdlym0a8rhNeUxTLtOQyzRkGLLnDUNm31+XeXzeNGTPm4bMvnX2tiouM/tO6ZiGfRrTNCRDRvFs0InLzL7hFdMw7IJxwrriGaTiMTi2Td/jvn2eeIxOXm6c8LyTtzu2TwAYjrd++9+66KmbFCgknY4yokaktBwrLO+8846ef/75fuetmpubdfDgwX7b53I5HTlyRM3NzQPuz+fzyeernd/zsSxL+7tTevNATG929OjNjh69815Ch3rsIpLJF868kxMEPC6Nq/NqXNincWGf6gMeBb0uBX3uvhLith97XQp633/e7zH5gAWAMhSoa5AkhSxKy5AcKyy7d+/WCy+8oLFjx/Zb39bWpq6uLm3fvl1Tp06VJD3//PMqFAqaPn16qeOUvXg6p10dPXqzI2b/PdCjNzpi6knlTvu8Op9b4+p8Ghc+XkbGhX0aV+fV2JBP55xQUkK+Eb90CQDgoFDE/lb1oJFWNpOWx1ud/6M/5E+zeDyut956q/h4z5492rlzpxoaGjR+/Hh99rOf1Y4dO/Tss88qn88Xr1NpaGiQ1+vVpZdeqhtvvFELFy7U+vXrlc1mtWTJEs2bN29Qdw5VqnzB0jvvJeyRkwMxvdHRo10dPdp7ZOBW7DYNXdQY1iXNdZrUHNGF54TUGPEXS4rf4xrlfwEAoFwdKy2SlIgdVf24gc9cVLoh3/L84osv6pOf/OQpyxcsWKCvf/3ram1tHfB5L7zwgq677jpJ9pfLLVmypN+Xy61du7aqvlzu/x5O6Pk3D+rNDvsUzx87e065oPWYpohPk5ojmjS+TpOKJSUsr7t8b1sDAJSX5KpGBY203v1fL+ncD1zqdJwBjfotz9ddd51O13MG04EaGhqq8ovkDsfTeva3+7Vh537t3Nd1ynq/x9QlTXXFgnJsFKUhxFfxAwCGJ2EEFVRavT1HnI4yYrjYYZiSmZyee71TT/3mXf2f3YeVL9ilzTSkay4apykTx+jS5jpNGh/RxIagXCYXsgIASi9phqTCUaXjXU5HGTGUlrOQyxf0q7cO6+md+/XLP3QomTl+W/Hk86KafdW5+p+Tx6uxzu9gSgBALUmbQakgZRJHnY4yYigtg2RZln73525t2Pmunvntfh2OZ4rrJjYENeeqFs2ecq4uPGdw1+UAAFBKaVdYykm5ZLfTUUYMpeUM3nkvoQ2/2a+nd76rPx1OFJePCXo0a3KLZl91rj48sZ7vLwEAOCrrCUtpKd9Laakp78XT+o/fH9CG37yrHXu7isv9HlP/47JmfWZKiz5+8TnyuLi7BwBQHnKeOkmSlaK01IT/fuuwfvSrPdryx0PKnXRB7ZyrztWMy5sV5ovaAABlqOC1byE20j0OJxk5fAKf4E+H4nr+TfsnBq44N6o5U87VrCvHqzHCBbUAgPJm+fpKS4bSUhM+fWWLDvakNfuqc3VRIxfUAgAqh+G3S4s7S2mpCQ0hr/6fGy5xOgYAAENmBqKSJE827nCSkcOVpAAAVAF3sF6S5M1RWgAAQBnzhuyRFn+B0gIAAMqYL2z/0nOwkDjDlpWL0gIAQBUI9JWWkJV0OMnIobQAAFAFAnX1kqSQkVI+l3M2zAihtAAAUAXC0YbifDxWnT+aSGkBAKAK+PxBpS2PJCkRO+JwmpFBaQEAoErEjaAkqbeHkRYAAFDGkkZIkpROdDkbZIRQWgAAqBIpl11aMpQWAABQztJ9pSVHaQEAAOUs466TJOV7ux1OMjIoLQAAVImcxy4thRSlBQAAlLGC1y4tSvU4G2SEUFoAAKgSli8iSTIzMYeTjAxKCwAAVcLw2yMtrgwjLQAAoIyZ/qgkyZOjtAAAgDLmDtqlxZuLO5xkZFBaAACoEp5QvSTJn084G2SEUFoAAKgSvvAYSVKgkHQ4ycigtAAAUCX84XpJUlCMtAAAgDIWjDRIksJWrwr5vMNpSo/SAgBAlQj3lRbTsJSIV9+34lJaAACoEj5/UBnLJUlKxI44nKb0KC0AAFQJwzSVMOxfeu7tOepwmtKjtAAAUEUSRlCSlKa0AACAcpYy7ZGWdKLL2SAjgNICAEAVSbvs0pJNdjkbZARQWgAAqCIZd1iSlE9y9xAAAChjOY/9S8+FVMzhJKVHaQEAoIoUvHZpUZrSAgAAyljBF5EkmZQWAABQzgy/XVpcmR6Hk5QepQUAgCpi+qOSJHcu7nCS0htyadmyZYtmzZqllpYWGYahDRs29FtvWZZWrlyp8ePHKxAIqL29Xbt37+63zZEjRzR//nxFIhHV19frtttuUzxefQcXAIDR5grapcVLaZESiYQmT56sdevWDbj+gQce0Nq1a7V+/Xpt27ZNoVBIM2bMUCqVKm4zf/58/eEPf9Bzzz2nZ599Vlu2bNGiRYvO/l8BAAAkSZ5gvSTJl6++0uIe6hNmzpypmTNnDrjOsiytWbNG99xzj2bPni1J+ulPf6qmpiZt2LBB8+bN0xtvvKGNGzfqlVde0dVXXy1Jeuihh3TTTTfpu9/9rlpaWobxzwEAoLZ5w/WSpEAh4WyQEVDSa1r27Nmjjo4Otbe3F5dFo1FNnz5dW7dulSRt3bpV9fX1xcIiSe3t7TJNU9u2bRtwv+l0WrFYrN8EAABOFQiPkSSFLErLaXV0dEiSmpqa+i1vamoqruvo6FBjY2O/9W63Ww0NDcVtTrZ69WpFo9HiNGHChFLGBgCgagTqjpWWXlmFgsNpSqsi7h5avny5uru7i9O+ffucjgQAQFkKRezS4jYKSiaq68xESUtLc3OzJKmzs7Pf8s7OzuK65uZmHTx4sN/6XC6nI0eOFLc5mc/nUyQS6TcBAIBTBUMR5Sz74z0RO+pwmtIqaWlpbW1Vc3OzNm3aVFwWi8W0bds2tbW1SZLa2trU1dWl7du3F7d5/vnnVSgUNH369FLGAQCg5himqYQRkCT19lRXaRny3UPxeFxvvfVW8fGePXu0c+dONTQ0aOLEiVq6dKnuu+8+XXzxxWptbdWKFSvU0tKiOXPmSJIuvfRS3XjjjVq4cKHWr1+vbDarJUuWaN68edw5BABACSSMkKJWQr3xGi8tr776qj75yU8WHy9btkyStGDBAj366KO66667lEgktGjRInV1denaa6/Vxo0b5ff7i8957LHHtGTJEl1//fUyTVNz587V2rVrS/DPAQAAvWZIykuZeJfTUUrKsCzLcjrEUMViMUWjUXV3d3N9CwAAJ3n9W9fqsszvtX3ag5p6021Oxyka7ud3Rdw9BAAABi/jDkuS8sluh5OUFqUFAIAqk+srLYUUpQUAAJSxvLdOkmSl+J4WAABQxgo++3oRM01pAQAA5exYacn0OByktCgtAABUGdNvlxZ3ltICAADKmCsYlSR5c3GHk5QWpQUAgCrjCdZLknz5hLNBSozSAgBAlfGF6iVJ/gKlBQAAlDFf3RhJUshKOpyktCgtAABUmUCxtCRkFQoOpykdSgsAAFUmFGmQJHmNvNKp6hltobQAAFBlQuGoCpYhSYrHjjicpnQoLQAAVBnT5VLcCEiSkpQWAABQzpIKSZJS8S5ng5QQpQUAgCrUa9qlJR0/6nCS0qG0AABQhVKuoCQpm+hyNkgJUVoAAKhCGXdYkpRLdjucpHQoLQAAVKGsu06SVEjFHE5SOpQWAACqUN5rlxaL0gIAAMpZwRuRJBlpSgsAAChnfnukxcz0OBykdCgtAABUIdMflSS5s5QWAABQxlwBu7R4c5QWAABQxtyhekmSL59wNkgJUVoAAKhC3r7S4qe0AACAcuYPj5EkBS1KCwAAKGP+cL0kKWwlnQ1SQpQWAACqUCjSIEnyGVmlU9VRXCgtAABUoXBkTHE+EauOX3qmtAAAUIVcbrcSll+SlKS0AACAcpYwgpKk3jilBQAAlLGkGZIkpSktAACgnKXMsCQpk+h2OElpUFoAAKhSGbddWnLJLmeDlAilBQCAKpX12KWl0MtICwAAKGM5T50kyUrFHE5SGpQWAACqlOW1S4uRprQAAIAyZvns0mJmKC0AAKCMGf6oJMmd7XE4SWlQWgAAqFKugF1aPNm4w0lKg9ICAECVcgft0uLNJxxOUholLy35fF4rVqxQa2urAoGALrzwQv3jP/6jLMsqbmNZllauXKnx48crEAiovb1du3fvLnUUAABqmjdk/2iiv0BpGdD999+vhx9+WP/yL/+iN954Q/fff78eeOABPfTQQ8VtHnjgAa1du1br16/Xtm3bFAqFNGPGDKVSqVLHAQCgZvnC9ZKkYJWUFnepd/jrX/9as2fP1qc//WlJ0gUXXKCf/exnevnllyXZoyxr1qzRPffco9mzZ0uSfvrTn6qpqUkbNmzQvHnzSh0JAICaFKhrkCSFrKTDSUqj5CMtH/vYx7Rp0yb98Y9/lCT99re/1a9+9SvNnDlTkrRnzx51dHSovb29+JxoNKrp06dr69atA+4znU4rFov1mwAAwOmFIvbpoaCRVjaTdjjN8JV8pOXuu+9WLBbTpEmT5HK5lM/n9c1vflPz58+XJHV0dEiSmpqa+j2vqampuO5kq1ev1r333lvqqAAAVLVjpUWSErGjqh/X7GCa4Sv5SMsvfvELPfbYY3r88ce1Y8cO/eQnP9F3v/td/eQnPznrfS5fvlzd3d3Fad++fSVMDABAdfJ4fUpaPkl2aal0JR9p+epXv6q77767eG3KFVdcoXfeeUerV6/WggUL1Nxst7zOzk6NHz+++LzOzk5dddVVA+7T5/PJ5/OVOioAAFUvYQQVVFq9PUecjjJsJR9pSSaTMs3+u3W5XCoUCpKk1tZWNTc3a9OmTcX1sVhM27ZtU1tbW6njAABQ05JmSJKUjnc5G6QESj7SMmvWLH3zm9/UxIkT9aEPfUi/+c1v9OCDD+pLX/qSJMkwDC1dulT33XefLr74YrW2tmrFihVqaWnRnDlzSh0HAICaljaDUkHKJDg9dIqHHnpIK1as0Fe+8hUdPHhQLS0t+pu/+RutXLmyuM1dd92lRCKhRYsWqaurS9dee602btwov99f6jgAANS0tCss5aRcstvpKMNmWCd+VW2FiMViikaj6u7uViQScToOAABla8d3Z+nD8S3aNuluTZ+33NEsw/385reHAACoYjlPnSSpkKr8kRZKCwAAVazgtUc0jFTlfzErpQUAgCpm+fpKS6bH4STDR2kBAKCKGX67tLizlBYAAFDGzEBUkuTJxh1OMnyUFgAAqpg7WC9J8uYoLQAAoIx5Q/ZIi79AaQEAAGXMF7Z/6TlYSDicZPgoLQAAVDF/uF6SFLKSzgYpAUoLAABVLFhnj7SEjJTyuZzDaYaH0gIAQBULRxuK8/GeLueClAClBQCAKubzB5W2PJKkZOw9h9MMD6UFAIAqFzeCkqReRloAAEA5SxohSVIqftThJMNDaQEAoMqlXHZpySS6nA0yTJQWAACqXLqvtOQoLQAAoJxl3HWSpHxvt8NJhofSAgBAlct57NJSSFFaAABAGSt47dKiVI+zQYaJ0gIAQJWzfBFJkpmJOZxkeCgtAABUOcNvj7S4Moy0AACAMmb6o5IkTy7ucJLhobQAAFDl3EG7tHgpLQAAoJx5QvWSJH8+4WyQYaK0AABQ5XzhMZKkQIHSAgAAypg/XC9JCorSAgAAylgw0iBJClu9KuTzDqc5e5QWAACqXLivtJiGpUS8cr8Vl9ICAECV8/mDylguSVIidsThNGeP0gIAQJUzTFMJw/6l596eow6nOXuUFgAAakDCCEqS0pQWAABQzlKmPdKSTnQ5G2QYKC0AANSAtMsuLdleLsQFAABlLOMOS5LySUoLAAAoYzmP/UvPFiMtAACgnBW8faUlHXM4ydmjtAAAUAMKvogkyaS0AACAcmb47dLiyvQ4nOTsUVoAAKgBpj8qSXLn4g4nOXuUFgAAaoAraJcWL6UFAACUM0+wXpLky1NaAABAGfOG6yVJgULC2SDDQGkBAKAGBMJjJEkhi9LSz7vvvqu//uu/1tixYxUIBHTFFVfo1VdfLa63LEsrV67U+PHjFQgE1N7ert27d49EFAAAIClQd6y09MoqFBxOc3ZKXlqOHj2qa665Rh6PR//1X/+l119/Xf/0T/+kMWPGFLd54IEHtHbtWq1fv17btm1TKBTSjBkzlEqlSh0HAABICkXsz2G3UVBvsjJve3aXeof333+/JkyYoEceeaS4rLW1tThvWZbWrFmje+65R7Nnz5Yk/fSnP1VTU5M2bNigefPmlToSAAA1LxiKKGeZchsFJWJHFQxHnY40ZCUfafn3f/93XX311frc5z6nxsZGTZkyRT/84Q+L6/fs2aOOjg61t7cXl0WjUU2fPl1bt24dcJ/pdFqxWKzfBAAABs8wTSWMgCQpGTvicJqzU/LS8qc//UkPP/ywLr74Yv3yl7/Ul7/8Zf3d3/2dfvKTn0iSOjo6JElNTU39ntfU1FRcd7LVq1crGo0WpwkTJpQ6NgAAVS9hhCRJvfGjDic5OyUvLYVCQR/+8If1rW99S1OmTNGiRYu0cOFCrV+//qz3uXz5cnV3dxenffv2lTAxAAC1ode0S0sm3uVskLNU8tIyfvx4XXbZZf2WXXrppdq7d68kqbm5WZLU2dnZb5vOzs7iupP5fD5FIpF+EwAAGJq0KyxJyia7nA1ylkpeWq655hrt2rWr37I//vGPOv/88yXZF+U2Nzdr06ZNxfWxWEzbtm1TW1tbqeMAAIA+GbddWvLJboeTnJ2S3z1055136mMf+5i+9a1v6fOf/7xefvll/eAHP9APfvADSZJhGFq6dKnuu+8+XXzxxWptbdWKFSvU0tKiOXPmlDoOAADok+srLYUUpUWS9JGPfERPPfWUli9frm984xtqbW3VmjVrNH/+/OI2d911lxKJhBYtWqSuri5de+212rhxo/x+f6njAACAPnlvnSTJSlXmXbiGZVmW0yGGKhaLKRqNqru7m+tbAAAYpK0/vENt7z6qbed8VtMX/2jUX3+4n9/89hAAALXCZxcFM1OZv/RMaQEAoEaYfru0uLOV+TX+lBYAAGqEK2h/db83x0gLAAAoY55gvSTJl6e0AACAMuYL1UuS/IWEs0HOEqUFAIAa4asbI0kKWUmHk5wdSgsAADUiUCwtCVmFgsNpho7SAgBAjQhFGiRJXiOvdKryRlsoLQAA1IhQOKqCZUiS4rEjDqcZOkoLAAA1wnS5FDcCkqQkpQUAAJSzpEKSpFS8y9kgZ4HSAgBADek1g5KkdPyow0mGjtICAEANSbnskZZsstvhJENHaQEAoIZk3GFJUp7SAgAAylnWXSdJyvdSWgAAQBnLe+3SYqViDicZOkoLAAA1pOCNSJKMNKUFAACUM7890mJmehwOMnSUFgAAaojpj0qS3FlKCwAAKGOugF1avDlKCwAAKGPuUL0kyZdPOBvkLFBaAACoId6+0uKntAAAgHLmD4+RJAUtSgsAAChj/nC9JClkJZ0NchYoLQAA1JBQpEGS5DeyyqRTDqcZGkoLAAA1JBwZU5yPd7/nYJKho7QAAFBDXG63EpZfkpSMHXU4zdBQWgAAqDEJIyhJ6o1TWgAAQBlLmiFJUprSAgAAylnKDEuSMoluh5MMDaUFAIAak3HbpSWX7HI2yBBRWgAAqDFZj11aCr2MtAAAgDKW89RJkqxUzOEkQ0NpAQCgxlheu7QYaUoLAAAoY5bPLi1mpsfhJENDaQEAoMYY/qgkyZ2ltAAAgDLmCvSVllzc4SRDQ2kBAKDGuIN2afFRWgAAQDnzhuwfTfQXEg4nGRpKCwAANcYXrpckBSktAACgnAXqGiRJISvpcJKhobQAAFBjQhH79FDQSCubSTucZvAoLQAA1JhjpUWSErHK+aXnES8t3/72t2UYhpYuXVpclkqltHjxYo0dO1bhcFhz585VZ2fnSEcBAACSPF6fkpZPEqWl6JVXXtG//uu/6sorr+y3/M4779QzzzyjJ598Ups3b9b+/ft18803j2QUAABwgoQRlCT19hxxOMngjVhpicfjmj9/vn74wx9qzJjjw1Dd3d360Y9+pAcffFCf+tSnNHXqVD3yyCP69a9/rZdeemmk4gAAgBMkzZAkKZ2onF96HrHSsnjxYn36059We3t7v+Xbt29XNpvtt3zSpEmaOHGitm7dOuC+0um0YrFYvwkAAJy9tGmPtGQTXc4GGQL3SOz05z//uXbs2KFXXnnllHUdHR3yer2qr6/vt7ypqUkdHR0D7m/16tW69957RyIqAAA1Ke0KSzkpm+xyOsqglXykZd++fbrjjjv02GOPye/3l2Sfy5cvV3d3d3Hat29fSfYLAECtynrCkqRCbw2fHtq+fbsOHjyoD3/4w3K73XK73dq8ebPWrl0rt9utpqYmZTIZdXV19XteZ2enmpubB9ynz+dTJBLpNwEAgLOX89RJkgqpyiktJT89dP311+v3v/99v2W33nqrJk2apK997WuaMGGCPB6PNm3apLlz50qSdu3apb1796qtra3UcQAAwAAKXnsAwEhVznWiJS8tdXV1uvzyy/stC4VCGjt2bHH5bbfdpmXLlqmhoUGRSES333672tra9NGPfrTUcQAAwAAsX19pyfQ4nGTwRuRC3DP53ve+J9M0NXfuXKXTac2YMUPf//73nYgCAEBNMvx2aXFnKS39vPjii/0e+/1+rVu3TuvWrRuNlwcAACcxA1FJkicbdzjJ4PHbQwAA1CB3sF6S5M1RWgAAQBnzhuyRFn+B0gIAAMqYL2z/xE6gkHQ4yeBRWgAAqEH+cL0kKWRRWgAAQBkL1tkjLWGjV/lczuE0g0NpAQCgBoWjDcX5eE+Xc0GGgNICAEAN8vmDSlseSVIy9p7DaQaH0gIAQI2KG0FJUi8jLQAAoJwljZAkKRU/6nCSwaG0AABQo1Iuu7RkEl3OBhkkSgsAADUq3VdacpQWAABQzjLuOklSvrfb4SSDQ2kBAKBG5Tx2aSmkKC0AAKCMFbx2aVG6x9kgg0RpAQCgRlk+u7SY6ZjDSQaH0gIAQI0y/BFJkitbGb/0TGkBAKBGmf6oJMmT5fQQAAAoY+6gXVq8OUZaAABAGfOE6iVJ/nzC2SCDRGkBAKBG+cJjJEmBAqUFAACUMX+4XpIUFKUFAACUsWCkQZIUtnpVyOcdTnNmlBYAAGpUuK+0mIalRLz8vxWX0gIAQI3y+YPKWC5JUiJ2xOE0Z0ZpAQCgRhmmqYRh/9Jzb89Rh9OcGaUFAIAaljCCkqR0vMvZIINAaQEAoIalTHukJZ3ocjbIIFBaAACoYWmXXVqyyS5ngwwCpQUAgBqWcYclSfkkdw8BAIAylvPUSZKsXkoLAAAoYwVvX2lJxxxOcmaUFgAAaljBF5EkmZQWAABQzgy/XVpcmR6Hk5wZpQUAgBpm+qOSJHcu7nCSM6O0AABQw1xBu7R4KS0AAKCceYL1kiRfntICAADKmDdcL0kKFJLOBhkESgsAADUsEKqXJAWthLNBBoHSAgBADQtEGiRJYSspq1BwOM3pUVoAAKhhocgYSZLbKKg3Wd63PVNaAACoYcFQRDnLrgOJ2FGH05wepQUAgBpmmKYSRkCSlIwdcTjN6VFaAACocQkjJEnqjdfYSMvq1av1kY98RHV1dWpsbNScOXO0a9euftukUiktXrxYY8eOVTgc1ty5c9XZ2VnqKAAAYBB6Tbu0ZOJdzgY5g5KXls2bN2vx4sV66aWX9NxzzymbzeqGG25QInH8Vqo777xTzzzzjJ588klt3rxZ+/fv180331zqKAAAYBDSrrAkKZvscjbIGbhLvcONGzf2e/zoo4+qsbFR27dv1yc+8Ql1d3frRz/6kR5//HF96lOfkiQ98sgjuvTSS/XSSy/pox/9aKkjAQCA08i4w1JGyie7nY5yWiN+TUt3t30AGhrs+8C3b9+ubDar9vb24jaTJk3SxIkTtXXr1gH3kU6nFYvF+k0AAKA0cm57pKWQquHSUigUtHTpUl1zzTW6/PLLJUkdHR3yer2qr6/vt21TU5M6OjoG3M/q1asVjUaL04QJE0YyNgAANSXvrbNnUjX8PS2LFy/Wa6+9pp///OfD2s/y5cvV3d1dnPbt21eihAAAoOCL2DPp8j6TUfJrWo5ZsmSJnn32WW3ZskXnnXdecXlzc7MymYy6urr6jbZ0dnaqubl5wH35fD75fL6RigoAQG3rKy2uTI2NtFiWpSVLluipp57S888/r9bW1n7rp06dKo/Ho02bNhWX7dq1S3v37lVbW1up4wAAgDMw/XZpcWfLu7SUfKRl8eLFevzxx/X000+rrq6ueJ1KNBpVIBBQNBrVbbfdpmXLlqmhoUGRSES333672trauHMIAAAHuIJRSZI3F3c4yemVvLQ8/PDDkqTrrruu3/JHHnlEX/ziFyVJ3/ve92SapubOnat0Oq0ZM2bo+9//fqmjAACAQfAE6yVJvnyNlRbLss64jd/v17p167Ru3bpSvzwAABgiX6hekuQvJE6/ocP47SEAAGqcr26MJClkJR1OcnqUFgAAalygWFoSsgoFh9O8P0oLAAA1LhSxv7Xea+SVTpXvaAulBQCAGhcKR1WwDElSPHbE4TTvj9ICAECNM10uxY2AJKm356jDad4fpQUAACipkCSpt6fL2SCnQWkBAADqNYOSpHS8y9kgp0FpAQAASrnskZZsktNDAACgjGXcYUlSPtntcJL3N2K/8lwO8vm8stms0zFGhMfjkcvlcjoGAKBKZN11kqR8L6VlVFmWpY6ODnV1dTkdZUTV19erublZhmE4HQUAUOHyXru0WKmYw0neX1WWlmOFpbGxUcFgsOo+1C3LUjKZ1MGDByVJ48ePdzgRAKDSFbwRSZKRprSMmnw+XywsY8eOdTrOiAkE7PvpDx48qMbGRk4VAQCGx2+PtJiZHoeDvL+quxD32DUswWDQ4SQj79i/sVqv2wEAjB7TH5UkubOUllFXbaeEBlIL/0YAwOhwBezS4s1RWgAAQBlzh+olSd48P5gIAADKmLevtATycWeDnAalpcysW7dOF1xwgfx+v6ZPn66XX37Z6UgAgBrgD4+RJAUsRlowCE888YSWLVumVatWaceOHZo8ebJmzJhRvLUZAICR4g/XS5LCVsLZIKdBaSkjDz74oBYuXKhbb71Vl112mdavX69gMKgf//jHTkcDAFS5UKRBkuQ3ssqkUw6nGVjVfU/LQCzLUm82P+qvG/C4Bn2HTyaT0fbt27V8+fLiMtM01d7erq1bt45URAAAJEnhyJjifLz7PTU0nutgmoHVRGnpzeZ12cpfjvrrvv6NGQp6B3eIDx8+rHw+r6ampn7Lm5qa9Oabb45EPAAAilxutxKWXyEjpWTsaFmWFk4PAQAASVLCsL+0tDd+1OEkA6uJkZaAx6XXvzHDkdcdrHHjxsnlcqmzs7Pf8s7OTjU3N5c6GgAAp0iaIalwRGlKi3MMwxj0aRqneL1eTZ06VZs2bdKcOXMkSYVCQZs2bdKSJUucDQcAqAkpMywVpEyi2+koAyrvT/Ias2zZMi1YsEBXX321pk2bpjVr1iiRSOjWW291OhoAoAZk3GEpJ+WSXU5HGRClpYzccsstOnTokFauXKmOjg5dddVV2rhx4ykX5wIAMBKynrCUkgqpmNNRBkRpKTNLlizhdBAAwBE5T50kySrT0sLdQwAAQJJkee3SYqTK85oWSgsAAJAkWT67tJiZHoeTDIzSAgAAJEmGPypJcmcpLQAAoIy5An2lJRd3OMnAKC0AAECS5A7apcVHaQEAAOXMG7J/NNFfSDicZGCUFgAAIEnyheslSUFKCwAAKGeBugZJUshKOpxkYJQWAAAgSQpF7NNDQSOtbCbtcJpTUVoAAICk46VFkpI9Xc4FeR+UljKyZcsWzZo1Sy0tLTIMQxs2bHA6EgCghni8PiUtnyQpETvqcJpTUVrKSCKR0OTJk7Vu3TqnowAAalTCCEqSenuOOJzkVPxgYhmZOXOmZs6c6XQMAEAN6zWDUuGoUvEup6OcojZKi2VJWQeuhPYEJcMY/dcFAOAspcyQVJCyiS6no5zC0dKybt06fec731FHR4cmT56shx56SNOmTSv9C2WT0rdaSr/fM/mH/ZI3NPqvCwDAWUq7wlJOyia7nI5yCseuaXniiSe0bNkyrVq1Sjt27NDkyZM1Y8YMHTx40KlIAADUvKwnLEkq9HY7nORUjo20PPjgg1q4cKFuvfVWSdL69ev1H//xH/rxj3+su+++u7Qv5gnaox6jzRMc/dcEAGAYcp46SVIhRWmRJGUyGW3fvl3Lly8vLjNNU+3t7dq6desp26fTaaXTx7/kJhaLDe0FDYPTNAAADELBG5EkGakhftaOAkdODx0+fFj5fF5NTU39ljc1Namjo+OU7VevXq1oNFqcJkyYMFpRR1U8HtfOnTu1c+dOSdKePXu0c+dO7d2719lgAICaYfn6Skumx+Ekp6qI72lZvny5uru7i9O+ffucjjQiXn31VU2ZMkVTpkyRJC1btkxTpkzRypUrHU4GAKgVdZd8XFtbFsh3afl9BYcjp4fGjRsnl8ulzs7Ofss7OzvV3Nx8yvY+n08+n2+04jnmuuuuk2VZTscAANSwy6+ZJV0zy+kYA3JkpMXr9Wrq1KnatGlTcVmhUNCmTZvU1tbmRCQAAFDmHLt7aNmyZVqwYIGuvvpqTZs2TWvWrFEikSjeTQQAAHAix0rLLbfcokOHDmnlypXq6OjQVVddpY0bN55ycS4AAIDk8DfiLlmyREuWLHEyAgAAqBAVcfcQAABA1ZaWQqHgdIQRVwv/RgAAjqm6X3n2er0yTVP79+/XOeecI6/XK6PKfmnZsixlMhkdOnRIpmnK6/U6HQkAgBFXdaXFNE21trbqwIED2r/fgd8bGkXBYFATJ06UaVbtgBkAAEVVV1oke7Rl4sSJyuVyyufzTscZES6XS263u+pGkQAAeD9VWVokyTAMeTweeTwep6MAAIAS4LwCAACoCJQWAABQESgtAACgIlTkNS3Hfgk5Fos5nAQAAAzWsc/tY5/jQ1WRpaWnp0eSNGHCBIeTAACAoerp6VE0Gh3y8wzrbOuOgwqFgvbv36+6urqS3/Ibi8U0YcIE7du3T5FIpKT7xvvjuDuD4z76OObO4Lg74+TjblmWenp61NLSclbfMVaRIy2maeq8884b0deIRCK8sR3AcXcGx330ccydwXF3xonH/WxGWI7hQlwAAFARKC0AAKAiUFpO4vP5tGrVKvl8Pqej1BSOuzM47qOPY+4MjrszSn3cK/JCXAAAUHsYaQEAABWB0gIAACoCpQUAAFQESgsAAKgIlJYTrFu3ThdccIH8fr+mT5+ul19+2elIVe3rX/+6DMPoN02aNMnpWFVny5YtmjVrllpaWmQYhjZs2NBvvWVZWrlypcaPH69AIKD29nbt3r3bmbBV5EzH/Ytf/OIp7/8bb7zRmbBVZPXq1frIRz6iuro6NTY2as6cOdq1a1e/bVKplBYvXqyxY8cqHA5r7ty56uzsdChxdRjMcb/uuutOec//7d/+7ZBeh9LS54knntCyZcu0atUq7dixQ5MnT9aMGTN08OBBp6NVtQ996EM6cOBAcfrVr37ldKSqk0gkNHnyZK1bt27A9Q888IDWrl2r9evXa9u2bQqFQpoxY4ZSqdQoJ60uZzruknTjjTf2e///7Gc/G8WE1Wnz5s1avHixXnrpJT333HPKZrO64YYblEgkitvceeedeuaZZ/Tkk09q8+bN2r9/v26++WYHU1e+wRx3SVq4cGG/9/wDDzwwtBeyYFmWZU2bNs1avHhx8XE+n7daWlqs1atXO5iquq1atcqaPHmy0zFqiiTrqaeeKj4uFApWc3Oz9Z3vfKe4rKury/L5fNbPfvYzBxJWp5OPu2VZ1oIFC6zZs2c7kqeWHDx40JJkbd682bIs+/3t8XisJ598srjNG2+8YUmytm7d6lTMqnPycbcsy/qLv/gL64477hjWfhlpkZTJZLR9+3a1t7cXl5mmqfb2dm3dutXBZNVv9+7damlp0Qc+8AHNnz9fe/fudTpSTdmzZ486Ojr6vfej0aimT5/Oe38UvPjii2psbNQll1yiL3/5y3rvvfecjlR1uru7JUkNDQ2SpO3btyubzfZ7z0+aNEkTJ07kPV9CJx/3Yx577DGNGzdOl19+uZYvX65kMjmk/VbkDyaW2uHDh5XP59XU1NRveVNTk958802HUlW/6dOn69FHH9Ull1yiAwcO6N5779XHP/5xvfbaa6qrq3M6Xk3o6OiQpAHf+8fWYWTceOONuvnmm9Xa2qq3335b//AP/6CZM2dq69atcrlcTserCoVCQUuXLtU111yjyy+/XJL9nvd6vaqvr++3Le/50hnouEvSX/3VX+n8889XS0uLfve73+lrX/uadu3apX/7t38b9L4pLXDMzJkzi/NXXnmlpk+frvPPP1+/+MUvdNtttzmYDBh58+bNK85fccUVuvLKK3XhhRfqxRdf1PXXX+9gsuqxePFivfbaa1wrN8re77gvWrSoOH/FFVdo/Pjxuv766/X222/rwgsvHNS+OT0kady4cXK5XKdcPd7Z2anm5maHUtWe+vp6ffCDH9Rbb73ldJSacez9zXvfeR/4wAc0btw43v8lsmTJEj377LN64YUXdN555xWXNzc3K5PJqKurq9/2vOdL4/2O+0CmT58uSUN6z1NaJHm9Xk2dOlWbNm0qLisUCtq0aZPa2tocTFZb4vG43n77bY0fP97pKDWjtbVVzc3N/d77sVhM27Zt470/yv785z/rvffe4/0/TJZlacmSJXrqqaf0/PPPq7W1td/6qVOnyuPx9HvP79q1S3v37uU9PwxnOu4D2blzpyQN6T3P6aE+y5Yt04IFC3T11Vdr2rRpWrNmjRKJhG699Vano1Wtv//7v9esWbN0/vnna//+/Vq1apVcLpe+8IUvOB2tqsTj8X7/J7Nnzx7t3LlTDQ0NmjhxopYuXar77rtPF198sVpbW7VixQq1tLRozpw5zoWuAqc77g0NDbr33ns1d+5cNTc36+2339Zdd92liy66SDNmzHAwdeVbvHixHn/8cT399NOqq6srXqcSjUYVCAQUjUZ12223admyZWpoaFAkEtHtt9+utrY2ffSjH3U4feU603F/++239fjjj+umm27S2LFj9bvf/U533nmnPvGJT+jKK68c/AsN696jKvPQQw9ZEydOtLxerzVt2jTrpZdecjpSVbvlllus8ePHW16v1zr33HOtW265xXrrrbecjlV1XnjhBUvSKdOCBQssy7Jve16xYoXV1NRk+Xw+6/rrr7d27drlbOgqcLrjnkwmrRtuuME655xzLI/HY51//vnWwoULrY6ODqdjV7yBjrkk65FHHilu09vba33lK1+xxowZYwWDQeszn/mMdeDAAedCV4EzHfe9e/dan/jEJ6yGhgbL5/NZF110kfXVr37V6u7uHtLrGH0vBgAAUNa4pgUAAFQESgsAAKgIlBYAAFARKC0AAKAiUFoAAEBFoLQAAICKQGkBAAAVgdICAAAqAqUFAABUBEoLAACoCJQWAABQESgtAACgIvz/OPeKzM52jaIAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "prices.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
0
0149633.333429
1149633.333429
2149633.333429
3149633.333429
4149633.333429
5149633.333429
6149633.333429
7149633.333429
8149633.333429
9149633.333429
\n", - "
" - ], - "text/plain": [ - " 0\n", - "0 149633.333429\n", - "1 149633.333429\n", - "2 149633.333429\n", - "3 149633.333429\n", - "4 149633.333429\n", - "5 149633.333429\n", - "6 149633.333429\n", - "7 149633.333429\n", - "8 149633.333429\n", - "9 149633.333429" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "learning = pd.DataFrame(algorithm.returns)\n", - "learning" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "learning.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.9.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/learningAgents/src/environmentModel.py b/learningAgents/src/environmentModel.py deleted file mode 100644 index 8d1c8b6..0000000 --- a/learningAgents/src/environmentModel.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/learningAgents/src/learningAgents.py b/learningAgents/src/learningAgents.py deleted file mode 100644 index d68c052..0000000 --- a/learningAgents/src/learningAgents.py +++ /dev/null @@ -1,220 +0,0 @@ -import numpy as np -import torch -import torch.nn as nn -from torch.distributions import Categorical -import sys -import numpy as np # numerical python -# printoptions: output limited to 2 digits after decimal point -np.set_printoptions(precision=2, suppress=False) - - - -class DemandPotentialGame(): - """ - Fully defines demand Potential Game. It contains game rules, memory and agents strategies. - """ - - def __init__(self, totalDemand, tupleCosts, totalStages) -> None: - self.totalDemand = totalDemand - self.costs = tupleCosts - self.T = totalStages - # first index is always player - self.demandPotential = None # two lists for the two players - self.prices = None # prices over T rounds - self.profit = None # profit in each of T rounds - self.stage = None - - - def resetGame(self): - self.demandPotential = [[0]*self.T,[0]*self.T] # two lists for the two players - self.prices = [[0]*self.T,[0]*self.T] # prices over T rounds - self.profit = [[0]*self.T,[0]*self.T] # profit in each of T rounds - self.demandPotential[0][0] = self.totalDemand/2 # initialize first round 0 - self.demandPotential[1][0] = self.totalDemand/2 - - - def profits(self, player = 0): - return self.profit[player][self.stage] - - def updatePricesProfitDemand(self, pricepair): - # pricepair = list of prices for players 0,1 in current round t - for player in [0,1]: - price = pricepair[player] - self.prices[player][self.stage] = price - self.profit[player][self.stage] = (self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) - if self.stage < self.T-1 : - self.demandPotential[player][ self.stage + 1] = \ - self.demandPotential[player][self.stage] + (pricepair[1-player] - price)/2 - - - def monopolyPrice(self, player, t): # myopic monopoly price - return (self.demandPotential[player][self.stage] + self.costs[player])/2 - - def myopic(self, player = 0): - return self.monopolyPrice(player, self.stage) - - def const(self, player, price): # constant price strategy - if self.stage == T-1: - return monopolyPrice(player, self.stage) - return price - - def imit(self, player, firstprice): # price imitator strategy - if self.stage == 0: - return firstprice - if self.stage == T-1: - return monopolyPrice(player, self.stage) - return self.prices[1-player][t-1] - - def fight(self, player, firstprice): # simplified fighting strategy - if self.stage == 0: - return firstprice - if self.stage == T-1: - return monopolyPrice(player, self.stage) - aspire = [ 207, 193 ] # aspiration level for demand potential - D =self.demandPotential[player][self.stage] - Asp = aspire [player] - if D >= Asp: # keep price; DANGER: price will never rise - return self.prices[player][self.stage-1] - # adjust to get to aspiration level using previous - # opponent price; own price has to be reduced by twice - # the negative amount D - Asp to getself.demandPotential to Asp - P = self.prices[1-player][self.stage-1] + 2*(D - Asp) - # never price to high because even 125 gives good profits - P = min(P, 125) - return P - - - # sophisticated fighting strategy, compare fight() - # estimate *sales* of opponent as their target, kept between - # calls in global variable oppsaleguess[]. Assumed behavior - # of opponent is similar to this strategy itself. - oppsaleguess = [61, 75] # first guess opponent sales as in monopoly - def guess(self, player, firstprice): # predictive fighting strategy - if self.stage == 0: - oppsaleguess[0] = 61 # always same start - oppsaleguess[1] = 75 # always same start - return firstprice - - if self.stage == T-1: - return monopolyPrice(player, self.stage) - aspire = [ 207, 193 ] # aspiration level - D =self.demandPotential[player][self.stage] - Asp = aspire [player] - - if D >= Asp: # keep price, but go slightly towards monopoly if good - pmono = monopolyPrice(player, self.stage) - pcurrent = self.prices[player][self.stage-1] - if pcurrent > pmono: # shouldn't happen - return pmono - if pcurrent > pmono-7: # no change - return pcurrent - # current low price at 60%, be accommodating towards "collusion" - return .6 * pcurrent + .4 * (pmono-7) - - # guess current *opponent price* from previous sales - prevsales =self.demandPotential[1-player][t-1] - self.prices[1-player][t-1] - # adjust with weight alpha from previous guess - alpha = .5 - newsalesguess = alpha * oppsaleguess[player] + (1-alpha)*prevsales - # update - oppsaleguess[player] = newsalesguess - guessoppPrice = 400 - D - newsalesguess - P = guessoppPrice + 2*(D - Asp) - - if player == 0: - P = min(P, 125) - if player == 1: - P = min(P, 130) - return P - - -class Model(DemandPotentialGame): - """ - Defines the Problem's Model. It is assumed a Markov Decision Process is defined. - """ - def __init__(self, totalDemand,tupleCosts,totalStages, initState) -> None: - super().__init__( totalDemand,tupleCosts,totalStages) - - self.rewardFunction = self.profits - self.initState = initState - self.episodesMemory = list() - self.done = False - - def reset(self): - reward = 0 - self.stage = 0 - self.resetGame() - return torch.tensor(self.initState, dtype=torch.float32), reward, self.done - - - def adversaryChoosePrice(self): - return self.myopic(player = 1) - - - def step(self, state, action): - adversaryAction = self.adversaryChoosePrice() - self.updatePricesProfitDemand( [self.myopic() - action, adversaryAction] ) - newState = [ self.demandPotential[1][self.stage + 1], self.prices[1][self.stage] ] - reward = self.rewardFunction() - self.stage = self.stage + 1 - - - return torch.tensor(newState, dtype=torch.float32), reward, self.stage == self.T-1 - - - - - -class ReinforceAlgorithm(): - """ - Model Solver. - """ - def __init__(self, Model, policyNet, optim, numberEpisodes) -> None: - self.env = Model - self.env.adversaryReturns = np.zeros(numberEpisodes) - self.returns = np.zeros(numberEpisodes) - self.policy = policyNet - self.numberEpisodes = numberEpisodes - self.optim = optim - self.episodesMemory = list() - - def solver(self): - - for episode in range(self.numberEpisodes): - episodeMemory = list() - state, reward, done = self.env.reset() - retu = 0 - while not done: - prev_state = state - probs = self.policy(prev_state) - distAction = Categorical(probs) - action = distAction.sample() - - state, reward, done = self.env.step(prev_state, action.item()) - retu = retu + reward - episodeMemory.append((prev_state, action, reward)) - - - states = torch.stack([item[0] for item in episodeMemory]) - actions = torch.tensor([item[1] for item in episodeMemory]) - rewards = torch.tensor([item[2] for item in episodeMemory]) - - action_probs = self.policy(states) - action_dists = Categorical(action_probs) - action_logprobs = action_dists.log_prob(actions) - - returns = self.returnsComputation(rewards, episodeMemory) - - loss = - ( torch.sum(returns*action_logprobs) )/len(episodeMemory) - print(loss) - self.optim.zero_grad() - loss.backward() - self.optim.step() - self.returns[episode] = retu - - - - def returnsComputation(self, rewards, episodeMemory): - gamma = .9 - return torch.tensor( [torch.sum( rewards[i:] * (gamma ** torch.arange(i, len(episodeMemory))) ) for i in range(len(episodeMemory)) ] ) - diff --git a/learningAgents/stableBaseline3/Population_game.py b/learningAgents/stableBaseline3/Population_game.py new file mode 100644 index 0000000..bebedf5 --- /dev/null +++ b/learningAgents/stableBaseline3/Population_game.py @@ -0,0 +1,200 @@ + +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +import numpy as np +from Environment import ConPricingGame +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys + + +alg = SAC +env_class = ConPricingGame + +alg_name = "CoSAC" +num_rounds = 10 + + +def training(env_class, costs, adv_mixed_strategy, target_payoff, num_procs): + """ + trains an agent against adversaries. if the expected payoff of new agent is greater than expected payoff of NE, \ + returns acceptable=true and the new strategy and payoff to be added to the the strategies and matrix. + """ + + acceptable = False + + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + # if not os.path.exists(models_dir): + # os.makedirs(models_dir) + + # if not os.path.exists(log_dir): + # os.makedirs(log_dir) + + number_episodes = gl.NUM_EPISODES + gl.EPISODE_ADV_INCREASE * \ + (adv_mixed_strategy.support_size-1) + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + running_time = time.time() - start + + agent_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + adv_payoffs = np.zeros(len(adv_mixed_strategy.strategies)) + expected_payoff = 0 + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + data_rows = [] + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), gl.LR, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + data_rows.append(data) + + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + expected_payoff += (agent_payoffs[strategy_index]) * \ + (adv_mixed_strategy.strategy_probs[strategy_index]) + if expected_payoff > target_payoff: + acceptable = True + for data in data_rows: + cl.write_results(data) + # compute the payoff against all adv strategies, to be added to the matrix + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] == 0: + payoffs = [] + for _ in range(gl.NUM_STOCHASTIC_ITER): + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + mean_payoffs = np.array(payoffs).mean(axis=0) + + agent_payoffs[strategy_index] = mean_payoffs[0] + adv_payoffs[strategy_index] = mean_payoffs[1] + + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions \ + # gamma seed num_procs running_time date + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy), expected_payoff, target_payoff, + gl.LR, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, gl.ACTION_STEP, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + cl.write_agents(data) + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + return [acceptable, agent_payoffs, adv_payoffs, model_strategy, expected_payoff] + + +if __name__ == "__main__": + + equilibria = [] + gl.initialize() + cl.create_directories() + + strt1 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") + strt2 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) + strt3 = cl.Strategy( + cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + + strtL1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694164525") + strtH1 = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=SAC, name="CoSAC-1694461629") + + bimatrix_game = cl.BimatrixGame( + low_cost_strategies=[strt1, strt2, strt3, strtL1], high_cost_strategies=[strt1, strt2, strt3, strtH1], env_class=env_class) + + bimatrix_game.reset_matrix() + bimatrix_game.fill_matrix() + + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + dictionaries = bimatrix_game.compute_equilibria() + cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() + for round in range(num_rounds): + cl.prt(f"Round {round} of {num_rounds}") + new_low = False + new_high = False + # inputs = [] + # update = [False] * len(dictionaries) + # for equilibrium in dictionaries: + equi = dictionaries[0] + low_prob_str = ", ".join( + map("{0:.2f}".format, equi["low_cost_probs"])) + high_prob_str = ", ".join( + map("{0:.2f}".format, equi["high_cost_probs"])) + cl.prt( + f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + + # train a low-cost agent + high_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) + if acceptable: + new_low = True + # update[int(i/2)] = True + bimatrix_game.low_strategies.append(agent_strategy) + bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + + # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ + # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + cl.prt( + f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + + # train a high-cost agent + low_mixed_strat = cl.MixedStrategy( + strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + + [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ + gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) + if acceptable: + new_high = True + + bimatrix_game.high_strategies.append(agent_strategy) + bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + + cl.prt( + f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + + if new_low or new_high: + equilibria.append( + [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) + dictionaries = bimatrix_game.compute_equilibria() + gl.NUM_EPISODES = gl.NUM_EPISODES_RESET + else: + gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/stableBaseline3/bimatrix.py b/learningAgents/stableBaseline3/bimatrix.py new file mode 100644 index 0000000..766f685 --- /dev/null +++ b/learningAgents/stableBaseline3/bimatrix.py @@ -0,0 +1,370 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import utils +import columnprint +import lemke +import randomstart +import random # random.seed + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/stableBaseline3/classes.py b/learningAgents/stableBaseline3/classes.py new file mode 100644 index 0000000..8942871 --- /dev/null +++ b/learningAgents/stableBaseline3/classes.py @@ -0,0 +1,441 @@ +from enum import Enum +import numpy as np +import globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open("game.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix("game.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + with open('progress.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + path = 'results.xlsx' if (file_name is None) else file_name + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel('results.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel('trained_agents.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") \ No newline at end of file diff --git a/learningAgents/stableBaseline3/columnprint.py b/learningAgents/stableBaseline3/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/stableBaseline3/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/stableBaseline3/environment.py b/learningAgents/stableBaseline3/environment.py new file mode 100644 index 0000000..ee64d39 --- /dev/null +++ b/learningAgents/stableBaseline3/environment.py @@ -0,0 +1,178 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import globals as gl +import classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (price_pair[1-player] - price)/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/stableBaseline3/game.txt b/learningAgents/stableBaseline3/game.txt new file mode 100644 index 0000000..2e3d89c --- /dev/null +++ b/learningAgents/stableBaseline3/game.txt @@ -0,0 +1,18 @@ +7 5 + + 140 139 139 140 140 + 139 128 128 139 138 + 155 169 142 155 155 + 163 258 93 161 161 + 165 258 88 164 165 + 173 302 74 172 171 + 171 291 76 171 172 + + 94 95 95 94 94 + 95 104 104 95 95 + 80 69 79 80 80 + 47 -20 56 45 48 + 41 -19 49 45 45 + 30 -52 19 30 33 + 33 -43 26 32 31 + diff --git a/learningAgents/stableBaseline3/globals.py b/learningAgents/stableBaseline3/globals.py new file mode 100644 index 0000000..3208ca6 --- /dev/null +++ b/learningAgents/stableBaseline3/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 3 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=8 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/stableBaseline3/lemke.py b/learningAgents/stableBaseline3/lemke.py new file mode 100644 index 0000000..ce9a23c --- /dev/null +++ b/learningAgents/stableBaseline3/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import columnprint +import utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/stableBaseline3/results-previous.xlsx b/learningAgents/stableBaseline3/results-previous.xlsx new file mode 100644 index 0000000..8642ed0 Binary files /dev/null and b/learningAgents/stableBaseline3/results-previous.xlsx differ diff --git a/learningAgents/stableBaseline3/results.xlsx b/learningAgents/stableBaseline3/results.xlsx new file mode 100644 index 0000000..09a0fdf Binary files /dev/null and b/learningAgents/stableBaseline3/results.xlsx differ diff --git a/learningAgents/stableBaseline3/trained_agents.xlsx b/learningAgents/stableBaseline3/trained_agents.xlsx new file mode 100644 index 0000000..a4d7ca0 Binary files /dev/null and b/learningAgents/stableBaseline3/trained_agents.xlsx differ diff --git a/learningAgents/stableBaseline3/utils.py b/learningAgents/stableBaseline3/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/stableBaseline3/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/tuning_params/base.py b/learningAgents/tuning_params/base.py new file mode 100644 index 0000000..5784ba2 --- /dev/null +++ b/learningAgents/tuning_params/base.py @@ -0,0 +1,181 @@ + +import gymnasium as gym +from gymnasium import spaces +import numpy as np +from stable_baselines3 import SAC +from stable_baselines3.common.env_util import make_vec_env +from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv +import time +import sys +from src.environments import ConPricingGame +import src.globals as gl +import src.classes as cl + +if __name__ == "__main__": + + global job_name + job_name = "lr" + gl.initialize() + cl.set_job_name(job_name) + + alg = SAC + env_class = ConPricingGame + + lrs = np.linspace(0.00001, 0.0005, 10) + num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + + costs=[gl.LOW_COST,gl.HIGH_COST] + + adv_mixed_strategy = cl.MixedStrategy(strategies_lst=[cl.Strategy(cl.StrategyType.static, cl.myopic, name="myopic"), cl.Strategy( + cl.StrategyType.static, cl.myopic, name="guess", first_price=132)], probablities_lst=[0.5, 0.5]) + + for lr in lrs: + for iter in range(2): + cl.prt(f"\nlr = {lr:.5f}, iter= {iter+1} strated. {time.ctime(time.time())} --------------------\n") + alg_name = f"{job_name}_lr" + pricing_game = env_class( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy) + + seed = int(time.time()) + + model_name = f"{alg_name}-{str(seed)}" + models_dir = f"{gl.MODELS_DIR}/{model_name}" + log_dir = f"{gl.LOG_DIR}/{model_name}" + + number_episodes = 4_000_000 + train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict( + tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)) + model = alg('MlpPolicy', train_env, learning_rate=gl.LR, + verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0) + + start = time.time() + # for i in range(gl.NUM_MODEL_SAVE): + # tmp = (number_episodes/gl.NUM_MODEL_SAVE) + # model.learn(total_timesteps=tmp, reset_num_timesteps=False, + # tb_log_name=model_name) + # model.save(os.path.join(models_dir, str(tmp*(i+1)))) + model.learn(total_timesteps=number_episodes, tb_log_name=model_name) + model.save(models_dir) + cl.prt(f"model {models_dir} is saved!\n") + + running_time = time.time() - start + + + + model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model, + model_or_func=alg, name=model_name, action_step=pricing_game.action_step) + mean_payoffs=[0]*len(adv_mixed_strategy.strategies) + total_mean=0 + for strategy_index in range(len(adv_mixed_strategy.strategies)): + if adv_mixed_strategy.strategy_probs[strategy_index] > 0: + payoffs = [] + for i in range(gl.NUM_STOCHASTIC_ITER): + # returns = algorithm.play_trained_agent(adversary=( + # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter) + payoffs.append(model_strategy.play_against( + env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index])) + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), pricing_game.adversary_strategy.name, + sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str( + pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]), + str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str( + pricing_game.demand_potential[1]), lr, gl.NUM_ADV_HISTORY, + gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time] + cl.write_results(data) + + mean_payoffs[strategy_index] = (np.array(payoffs).mean(axis=0))[0] + total_mean+= mean_payoffs[strategy_index]*adv_mixed_strategy.strategy_probs[strategy_index] + + + + data = [model_name, number_episodes, ("L" if (costs[0] < costs[1]) else "H"), str(adv_mixed_strategy)+str(mean_payoffs), total_mean, 0, + lr, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time, + time.ctime(time.time())] + + cl.write_agents(data) + cl.prt(f"results of model {model_name} are written!\n") + # alg.write_nn_data(("low" if costs[0] < costs[1] else "high")) + + + +# if __name__ == "__main__": +# gl.initialize() + + +# equilibria = [] + +# cl.create_directories() + +# strt1 = cl.Strategy( +# cl.StrategyType.static, model_or_func=cl.myopic, name="myopic") +# strt2 = cl.Strategy( +# cl.StrategyType.static, model_or_func=cl.const, name="const", first_price=132) +# strt3 = cl.Strategy( +# cl.StrategyType.static, model_or_func=cl.guess, name="guess", first_price=132) + +# cl.prt("\n" + time.ctime(time.time())+"\n"+("-"*50)+"\n") + +# bimatrix_game = cl.BimatrixGame( +# low_cost_strategies=[strt1, strt2, strt3], high_cost_strategies=[strt1, strt2, strt3], env_class=env_class) + +# bimatrix_game.reset_matrix() +# bimatrix_game.fill_matrix() + +# num_procs = gl.NUM_PROCESS if (len(sys.argv) < 2) else int(sys.argv[1]) + +# dictionaries = bimatrix_game.compute_equilibria() + +# # low_cost_probabilities, high_cost_probabilities, low_cost_payoff, high_cost_payoff = bimatrix_game.compute_equilibria() +# for round in range(num_rounds): +# cl.prt(f"Round {round} of {num_rounds}") +# new_low = False +# new_high = False +# # inputs = [] +# # update = [False] * len(dictionaries) +# # for equilibrium in dictionaries: +# equi = dictionaries[0] +# low_prob_str = ", ".join( +# map("{0:.2f}".format, equi["low_cost_probs"])) +# high_prob_str = ", ".join( +# map("{0:.2f}".format, equi["high_cost_probs"])) +# cl.prt( +# f'equi: [{low_prob_str}], [{high_prob_str}], {equi["low_cost_payoff"]:.2f}, {equi["high_cost_payoff"]:.2f}') + +# # train a low-cost agent +# high_mixed_strat = cl.MixedStrategy( +# strategies_lst=bimatrix_game.high_strategies, probablities_lst=equi["high_cost_probs"]) + +# [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ +# gl.LOW_COST, gl.HIGH_COST], adv_mixed_strategy=high_mixed_strat, target_payoff=equi["low_cost_payoff"], num_procs=num_procs) +# if acceptable: +# new_low = True +# # update[int(i/2)] = True +# bimatrix_game.low_strategies.append(agent_strategy) +# bimatrix_game.add_low_cost_row(agent_payoffs, adv_payoffs) + +# # cl.prt(f"low cost player {agent_strategy.name} added, trained with ", [ +# # equi["low_cost_probabilities"], equi["high_cost_probabilities"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) +# cl.prt( +# f'low-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["high_cost_probs"]}, payoff={equi["low_cost_payoff"]:.2f}') + +# # train a high-cost agent +# low_mixed_strat = cl.MixedStrategy( +# strategies_lst=bimatrix_game.low_strategies, probablities_lst=((equi["low_cost_probs"]+[0]) if new_low else equi["low_cost_probs"])) + +# [acceptable, agent_payoffs, adv_payoffs, agent_strategy, expected_payoff] = training(env_class=env_class, costs=[ +# gl.HIGH_COST, gl.LOW_COST], adv_mixed_strategy=low_mixed_strat, target_payoff=equi["high_cost_payoff"], num_procs=num_procs) +# if acceptable: +# new_high = True + +# bimatrix_game.high_strategies.append(agent_strategy) +# bimatrix_game.add_high_cost_col(adv_payoffs, agent_payoffs) + +# cl.prt( +# f'high-cost player {agent_strategy.name} , payoff= {expected_payoff:.2f} added, trained against {equi["low_cost_probs"]}, payoff={equi["high_cost_payoff"]:.2f}') + +# if new_low or new_high: +# equilibria.append( +# [equi["low_cost_probs"], equi["high_cost_probs"], equi["low_cost_payoff"], equi["high_cost_payoff"]]) +# dictionaries = bimatrix_game.compute_equilibria() +# gl.NUM_EPISODES = gl.NUM_EPISODES_RESET +# else: +# gl.NUM_EPISODES += gl.EPISODE_ADV_INCREASE diff --git a/learningAgents/tuning_params/lr/run_lrs.ipynb b/learningAgents/tuning_params/lr/run_lrs.ipynb new file mode 100644 index 0000000..5852d4a --- /dev/null +++ b/learningAgents/tuning_params/lr/run_lrs.ipynb @@ -0,0 +1,292 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "4dc370d6-dc59-4fe0-97fa-c18b36da4208", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-11-06 17:41:41.224529: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:41:41.925469: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:41:42.576454: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:41:42.576496: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:41:42.576514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:41:42.672751: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:41:51.872903: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from stable_baselines3 import SAC\n", + "from stable_baselines3.common.env_util import make_vec_env\n", + "from stable_baselines3.common.vec_env import SubprocVecEnv\n", + "import time\n", + "from src.environments import ConPricingGame\n", + "import src.globals as gl\n", + "import src.classes as cl" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e72af7fa-11c3-472f-8550-8785ba735aaf", + "metadata": {}, + "outputs": [], + "source": [ + "num_procs = 15\n", + "\n", + "global job_name\n", + "job_name = \"lr\"\n", + "gl.initialize()\n", + "cl.set_job_name(job_name)\n", + "\n", + "alg = SAC\n", + "env_class = ConPricingGame\n", + "\n", + "lrs = np.linspace(0.00001, 0.001, 20)\n", + "\n", + "\n", + "costs=[gl.LOW_COST,gl.HIGH_COST]\n", + "\n", + "adv_mixed_strategy = cl.MixedStrategy(strategies_lst=[cl.Strategy(cl.StrategyType.static, cl.myopic, name=\"myopic\"), cl.Strategy(\n", + " cl.StrategyType.static, cl.myopic, name=\"guess\", first_price=132)], probablities_lst=[0.5, 0.5])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24db2ce4-10b7-4320-b344-27df7da76d65", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-11-06 17:42:28.656548: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656549: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656552: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656549: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656550: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656553: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.656549: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657089: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657092: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657089: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657097: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657090: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657089: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657089: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.657089: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-06 17:42:28.659003: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659004: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659005: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659006: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659006: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659008: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659008: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659604: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659605: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659605: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659606: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659606: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659607: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659607: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.659606: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-06 17:42:28.683001: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683035: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683356: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683376: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683389: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683452: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683471: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683482: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683498: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683498: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683502: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.683516: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683517: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683520: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683522: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.683532: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683532: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683533: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.683534: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.684966: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685000: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685017: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685058: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685078: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685069: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685088: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685079: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685094: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685098: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685101: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685090: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685109: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685111: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685124: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685116: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685118: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-06 17:42:28.685133: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685137: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685136: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-06 17:42:28.685145: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.685149: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-06 17:42:28.688360: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688360: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688361: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688361: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688360: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688360: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.688363: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690879: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690880: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690880: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690880: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690880: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690880: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.690892: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:28.691015: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-06 17:42:32.629086: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629091: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629462: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629473: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629521: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629566: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629580: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629594: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629615: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.629974: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.630007: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.630040: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.630085: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.630960: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-06 17:42:32.631440: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "for lr in lrs:\n", + " for iter in range(3):\n", + " cl.prt(f\"\\nlr = {lr:.5f}, iter= {iter+1} started. {time.ctime(time.time())} ---------\\n\")\n", + " alg_name = f\"{job_name}_{lr:5f}\"\n", + " \n", + "\n", + " seed = int(time.time())\n", + "\n", + " model_name = f\"{alg_name}-{str(seed)}\"\n", + " models_dir = f\"{gl.MODELS_DIR}/{model_name}\"\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + "\n", + " number_episodes = 4_000_000\n", + " train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy))\n", + " model = alg('MlpPolicy', train_env, learning_rate=lr,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + "\n", + " start = time.time()\n", + " # for i in range(gl.NUM_MODEL_SAVE):\n", + " # tmp = (number_episodes/gl.NUM_MODEL_SAVE)\n", + " # model.learn(total_timesteps=tmp, reset_num_timesteps=False,\n", + " # tb_log_name=model_name)\n", + " # model.save(os.path.join(models_dir, str(tmp*(i+1))))\n", + " model.learn(total_timesteps=number_episodes, tb_log_name=model_name)\n", + " model.save(models_dir)\n", + " cl.prt(f\"model {models_dir} is saved!\\n\")\n", + "\n", + " running_time = time.time() - start\n", + "\n", + " \n", + " pricing_game = env_class(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy)\n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=model_name, action_step=pricing_game.action_step)\n", + " mean_payoffs=[0]*len(adv_mixed_strategy.strategies)\n", + " total_mean=0\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] > 0:\n", + " pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=(adv_mixed_strategy.strategy_probs[strategy_index]).to_mixed_strategy())\n", + " payoffs = []\n", + " for i in range(gl.NUM_STOCHASTIC_ITER):\n", + " # returns = algorithm.play_trained_agent(adversary=(\n", + " # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter)\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " data = [model_name, number_episodes, (\"L\" if (costs[0] < costs[1]) else \"H\"), pricing_game.adversary_strategy.name,\n", + " sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str(\n", + " pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]),\n", + " str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str(\n", + " pricing_game.demand_potential[1]), lr, gl.NUM_ADV_HISTORY,\n", + " gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time]\n", + " cl.write_results(data)\n", + "\n", + " mean_payoffs[strategy_index] = (np.array(payoffs).mean(axis=0))[0]\n", + " total_mean+= mean_payoffs[strategy_index]*adv_mixed_strategy.strategy_probs[strategy_index]\n", + "\n", + " \n", + "\n", + " data = [model_name, number_episodes, (\"L\" if (costs[0] < costs[1]) else \"H\"), str(adv_mixed_strategy)+str(mean_payoffs), total_mean, 0,\n", + " lr, gl.NUM_ADV_HISTORY, gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time,\n", + " time.ctime(time.time())]\n", + "\n", + " cl.write_agents(data)\n", + " cl.prt(f\"results of model {model_name} are written!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "234e599f-5ab1-4691-b496-b1421ba36a27", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "venv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/tuning_params/lr/src/bimatrix.py b/learningAgents/tuning_params/lr/src/bimatrix.py new file mode 100644 index 0000000..799ac98 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils +import src.columnprint +import src.lemke +import src.randomstart +import random # random.seed +import src.classes + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + classes.prt("\n all equilibria: \n") + for eq in sorted_trset: + classes.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/tuning_params/lr/src/classes.py b/learningAgents/tuning_params/lr/src/classes.py new file mode 100644 index 0000000..ae9f72f --- /dev/null +++ b/learningAgents/tuning_params/lr/src/classes.py @@ -0,0 +1,448 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"game_{job_name}.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy=adversary.to_mixed_strategy() + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + + path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel(f'results_{job_name}.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") + +def set_job_name(name): + global job_name + job_name=name \ No newline at end of file diff --git a/learningAgents/tuning_params/lr/src/columnprint.py b/learningAgents/tuning_params/lr/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/tuning_params/lr/src/environments.py b/learningAgents/tuning_params/lr/src/environments.py new file mode 100644 index 0000000..3c00a74 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/environments.py @@ -0,0 +1,185 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl +import src.classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/tuning_params/lr/src/globals.py b/learningAgents/tuning_params/lr/src/globals.py new file mode 100644 index 0000000..2d82860 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 20 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=6 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/tuning_params/lr/src/lemke.py b/learningAgents/tuning_params/lr/src/lemke.py new file mode 100644 index 0000000..c794b49 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint +import src.utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/tuning_params/lr/src/utils.py b/learningAgents/tuning_params/lr/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/tuning_params/lr/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/tuning_params/memory/README.txt b/learningAgents/tuning_params/memory/README.txt new file mode 100644 index 0000000..9d6792b --- /dev/null +++ b/learningAgents/tuning_params/memory/README.txt @@ -0,0 +1,3 @@ +in these experiments on fabian and my own laptop, we trained agents against myopic 0.5 and guess 0.5. +The variable in these experiemnts is the length of memory for both our agent and opponent. +We run experiments for value 0, 2, 4,..., 24 diff --git a/learningAgents/tuning_params/memory/RUN.ipynb b/learningAgents/tuning_params/memory/RUN.ipynb new file mode 100644 index 0000000..854244b --- /dev/null +++ b/learningAgents/tuning_params/memory/RUN.ipynb @@ -0,0 +1,1838 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "id": "4dc370d6-dc59-4fe0-97fa-c18b36da4208", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from stable_baselines3 import SAC\n", + "from stable_baselines3.common.env_util import make_vec_env\n", + "from stable_baselines3.common.vec_env import SubprocVecEnv\n", + "import time\n", + "from src.environments import ConPricingGame\n", + "import src.globals as gl\n", + "import src.classes as cl" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e72af7fa-11c3-472f-8550-8785ba735aaf", + "metadata": {}, + "outputs": [], + "source": [ + "num_procs = 15\n", + "\n", + "global job_name\n", + "job_name = \"memory\"\n", + "gl.initialize()\n", + "cl.set_job_name(job_name)\n", + "\n", + "alg = SAC\n", + "env_class = ConPricingGame\n", + "\n", + "mems = np.arange(0,25,2)\n", + "\n", + "\n", + "costs=[gl.LOW_COST,gl.HIGH_COST]\n", + "\n", + "adv_mixed_strategy = cl.MixedStrategy(strategies_lst=[cl.Strategy(cl.StrategyType.static, cl.myopic, name=\"myopic\"), cl.Strategy(\n", + " cl.StrategyType.static, cl.myopic, name=\"guess\", first_price=132)], probablities_lst=[0.5, 0.5])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24db2ce4-10b7-4320-b344-27df7da76d65", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506255: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506304: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506307: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506405: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506410: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506409: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506411: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506413: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506408: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.506411: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 17:16:26.508701: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508702: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508703: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508703: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508705: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508704: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508705: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508710: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508877: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508878: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508879: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508879: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508884: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508884: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.508884: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 17:16:26.532504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532505: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532506: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532509: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532512: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532547: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532547: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532550: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532550: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532550: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532568: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532568: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532568: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532570: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532570: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532685: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532768: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532772: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.532791: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532803: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.532833: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.532855: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533244: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 17:16:26.533285: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533285: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533285: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533285: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533287: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533287: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533287: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 17:16:26.533310: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533310: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533311: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533312: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533312: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533312: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.533313: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 17:16:26.537938: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537939: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537938: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537939: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537938: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537939: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537939: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.537938: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539222: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539223: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539222: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539222: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539223: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539222: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:26.539222: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 17:16:30.977048: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977042: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977062: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977061: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977061: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977069: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977083: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977084: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977106: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977121: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977748: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.977855: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.978037: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.978175: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 17:16:30.978437: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:08.315211: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315211: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315261: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315262: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315263: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315340: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315341: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315341: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315393: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315394: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315392: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315391: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315393: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315391: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.315394: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 18:34:08.317708: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317711: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317711: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317711: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317712: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317715: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317718: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317719: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317909: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317912: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317913: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317913: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317914: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317914: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.317916: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 18:34:08.341538: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341538: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341537: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341537: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341598: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341600: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341600: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341689: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341699: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341713: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341705: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341725: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341740: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341758: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341781: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341775: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341776: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.341795: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341795: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.341809: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.341844: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342500: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342499: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342501: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342498: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342498: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342502: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342500: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 18:34:08.342539: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342539: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342539: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342539: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342540: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342540: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342565: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342565: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342565: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342566: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342566: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342566: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.342656: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 18:34:08.342681: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 18:34:08.347003: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347003: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347004: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347004: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347003: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347004: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347004: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.347008: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348446: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348448: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348447: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348447: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348446: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348447: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:08.348447: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 18:34:12.871749: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.871749: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.871786: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872291: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872294: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872315: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872325: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872325: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872329: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872339: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872340: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872344: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872380: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.872867: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 18:34:12.873163: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676699: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676894: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.676891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.677222: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 19:49:33.679184: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679184: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679189: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679188: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679190: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679190: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679194: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679386: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679387: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679388: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679390: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679392: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679392: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679391: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.679393: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 19:49:33.702671: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.702671: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.702704: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.702706: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.702720: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.702725: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.702958: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.702959: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.702968: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.702978: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.702978: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.702986: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.702991: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.702995: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.702998: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.703070: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.703070: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.703088: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.703089: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.703101: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.703104: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704057: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704054: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704053: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704058: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704057: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704053: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704057: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704053: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704095: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704123: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704123: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.704219: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 19:49:33.704245: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 19:49:33.708093: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708093: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.708097: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710096: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710096: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710096: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710096: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710095: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710096: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:33.710100: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 19:49:38.175601: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175601: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175611: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175608: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175608: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175612: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175615: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175622: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175627: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175628: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175638: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175650: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.175658: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.176111: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 19:49:38.176504: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:03:57.265122: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265121: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265121: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265122: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265121: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265122: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265801: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265801: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265800: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265800: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265801: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265801: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.265801: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:57.267526: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.267527: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.267527: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.267527: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.267528: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.267532: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268304: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268305: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268306: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268307: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268310: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268309: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.268310: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:57.291341: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291342: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291341: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291342: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291342: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291341: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.291381: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291381: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291381: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291382: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291383: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291383: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.291403: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.291403: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.291403: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.291404: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.291406: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.291407: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292667: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292666: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:57.292702: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292702: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292702: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292703: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292703: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292703: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292729: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292729: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292729: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292730: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292730: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292730: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.292810: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:57.292825: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:57.296859: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.296860: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.296859: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.296859: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.296859: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.296859: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298687: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298687: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298688: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298689: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298692: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298695: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:57.298696: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:59.002271: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:59.002271: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 21:03:59.004463: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:59.004462: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 21:03:59.027100: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:59.027100: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 21:03:59.027128: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:59.027128: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 21:03:59.027147: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:59.027147: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 21:03:59.032173: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:03:59.032174: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 21:04:01.823237: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823237: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823237: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823250: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823270: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823719: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.823835: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 21:04:01.824025: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426235: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426903: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426907: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426905: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426905: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426903: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426904: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.426904: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.427028: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:27.428640: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.428640: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.428641: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.428641: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.428643: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.428644: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429421: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429422: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429421: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429424: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429424: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429427: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429428: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.429430: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:27.452321: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452321: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452320: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452321: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452320: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452361: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452361: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452363: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452363: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452356: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.452375: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452387: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.452387: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.452387: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.452387: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.452388: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.452440: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.452468: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.453956: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453956: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453958: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453958: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453958: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453963: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453956: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453956: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:27.453999: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.453999: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.453999: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454000: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454001: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454001: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454001: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454024: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454024: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454024: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454024: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454026: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454026: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454027: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.454121: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:27.454143: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:27.457790: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.457791: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.457792: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.457790: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.457790: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.457791: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459992: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459992: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:27.459991: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:30.110118: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 22:19:30.112172: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 22:19:30.134141: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 22:19:30.134163: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 22:19:30.134178: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 22:19:30.138707: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 22:19:31.947788: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947788: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947788: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947788: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947788: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947795: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947796: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947813: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947817: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947818: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947829: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.947830: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.948232: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:31.948538: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 22:19:32.453243: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:24.938110: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938105: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938109: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938106: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938105: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938113: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938125: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938105: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938106: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938117: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938108: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938113: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938123: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938125: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.938127: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-07 23:34:24.940597: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940597: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940600: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940601: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940602: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940603: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940602: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940618: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940637: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940638: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940641: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940641: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940642: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940642: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.940641: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-07 23:34:24.964786: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964786: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964786: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964786: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964786: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964825: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964825: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964827: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964827: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964827: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964849: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964849: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964849: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964849: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964850: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964899: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964907: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.964922: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964927: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.964934: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.964938: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965515: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965513: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965509: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965509: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965511: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965509: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965510: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-07 23:34:24.965552: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965553: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965553: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965553: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965555: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965555: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965555: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965580: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965579: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965580: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965580: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.965668: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-07 23:34:24.965689: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970309: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.970308: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971499: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:24.971502: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-07 23:34:29.434338: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434338: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434338: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434344: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434345: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434344: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434344: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434344: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434893: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434900: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434909: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434919: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434923: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.434930: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-07 23:34:29.435396: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:45.443550: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443550: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443553: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443551: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443550: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443550: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.443551: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444187: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444190: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444187: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444188: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444184: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444186: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444187: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.444184: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 00:52:45.445936: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445938: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445937: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445938: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445938: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445938: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.445938: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446701: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446703: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446705: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446705: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446707: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446707: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446709: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.446709: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 00:52:45.469546: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469546: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469546: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469583: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469583: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469585: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469604: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469604: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469604: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469647: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469669: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469683: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469685: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469709: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469724: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469772: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469780: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.469793: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469801: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.469807: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.469814: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471449: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471448: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 00:52:45.471489: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471489: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471489: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471489: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471490: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471491: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471491: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471514: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.471608: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 00:52:45.471630: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 00:52:45.474997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474998: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474998: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.474999: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477397: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477398: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477398: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477398: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477398: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477399: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477399: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:45.477399: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 00:52:50.200306: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200682: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200690: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200694: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200711: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200737: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200737: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200737: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200979: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.200984: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.201874: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.202347: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.202972: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.202997: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 00:52:50.203038: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:09.457161: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457162: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457162: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457162: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457161: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457161: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457162: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457575: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457573: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457574: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457574: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457574: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457572: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457571: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.457824: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 02:12:09.459597: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459596: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459602: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459603: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459603: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459604: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.459608: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460100: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460100: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460101: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460102: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460104: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460106: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460106: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.460106: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 02:12:09.483620: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483614: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483614: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483614: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483614: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483655: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483655: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483657: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483657: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483657: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483677: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483677: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483677: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483677: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483677: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483672: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.483691: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483703: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.483739: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.483761: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484698: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484698: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484699: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484700: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484698: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484698: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484700: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484698: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 02:12:09.484740: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484740: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484740: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484740: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484741: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484742: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484742: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484764: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484764: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484764: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484765: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484765: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484765: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484765: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.484858: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 02:12:09.484880: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 02:12:09.489254: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489254: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489254: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489254: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489253: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489253: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.489253: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490731: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490730: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490731: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490730: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490731: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490730: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490731: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:09.490731: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 02:12:14.237090: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237090: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237090: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237107: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237107: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237113: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237113: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237113: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237115: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237116: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237116: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237125: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237126: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237141: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 02:12:14.237516: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:14.969733: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969731: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969731: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969731: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969733: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969733: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969733: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.969738: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971560: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971558: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971558: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971558: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971558: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971563: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.971559: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 03:31:14.972059: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972060: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972062: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972063: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972062: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972063: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972063: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.972064: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974113: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974114: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974114: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974114: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974114: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974115: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.974115: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 03:31:14.995917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995918: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995961: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995963: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995963: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995964: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995964: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995979: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.995979: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.995979: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.995981: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.995981: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.995972: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995972: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.995992: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.995992: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.996004: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.996008: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.996080: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.996102: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998673: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 03:31:14.998714: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998714: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998717: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998717: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998717: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998718: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998718: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 03:31:14.998742: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998743: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998744: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998744: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998744: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998745: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:14.998745: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001350: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.001353: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004657: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:15.004656: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 03:31:20.317197: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317571: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317573: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317582: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317598: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317598: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317598: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317598: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317785: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317802: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.317803: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.318218: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.318573: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.318616: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 03:31:20.318639: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208638: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208704: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208702: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208702: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.208700: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 04:48:44.211111: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211112: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211114: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211116: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211116: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211119: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211119: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211188: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211188: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211189: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211188: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211188: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211190: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211192: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.211192: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 04:48:44.235092: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235089: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235090: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235089: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235090: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235094: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235089: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235130: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235130: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235130: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235130: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235131: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235131: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235131: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235150: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235152: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235157: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235157: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235161: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235161: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235161: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235462: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235462: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235463: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235462: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235463: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235462: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235482: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235483: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 04:48:44.235503: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235503: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235527: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235527: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235529: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235531: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235531: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235532: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235532: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.235634: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 04:48:44.235658: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240557: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.240562: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241433: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241433: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241434: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241433: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241433: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241432: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241435: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:44.241435: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 04:48:48.488556: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489381: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489383: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489386: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489409: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489411: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489412: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489409: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489410: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489411: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.489978: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.490095: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.490133: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.490235: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 04:48:48.490468: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:18.740735: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740737: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740735: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740736: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740736: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740735: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.740735: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741607: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.741606: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 06:07:18.743071: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743071: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743075: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743075: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743075: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743075: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.743076: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744123: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744126: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744128: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744129: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744132: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744133: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744133: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.744134: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.766997: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.767022: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.767039: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767043: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767044: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767044: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767044: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767044: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767045: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.767057: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767057: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767058: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767065: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767067: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767067: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.767068: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768619: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768680: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768680: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768682: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768689: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768689: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768689: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768690: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.768778: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 06:07:18.768801: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772414: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.772412: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774540: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774541: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774540: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774540: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774541: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774541: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774540: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:18.774541: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 06:07:23.186857: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187450: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187455: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187499: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187511: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187511: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187511: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187526: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187618: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.187934: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 06:07:23.188088: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:24:55.612523: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612523: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612521: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612525: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612535: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612524: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612524: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612891: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612890: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.612889: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 07:24:55.614919: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614920: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614921: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614921: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614921: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614922: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.614922: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615388: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615390: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615390: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615391: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615390: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615390: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615391: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.615392: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 07:24:55.638391: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638391: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638391: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638427: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638427: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638428: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638452: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638452: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638452: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638586: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638607: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638621: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638687: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638708: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638721: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638717: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638717: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.638736: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638737: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.638752: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.638752: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640104: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 07:24:55.640149: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640149: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640149: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640151: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640151: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640154: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640155: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640171: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640177: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640177: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640180: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640180: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640180: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640180: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.640267: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 07:24:55.640281: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 07:24:55.643844: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643844: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643844: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643844: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643845: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643844: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.643845: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646124: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646124: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:24:55.646125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 07:25:00.319254: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.319254: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.319988: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.319998: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320034: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320036: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320036: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320037: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320057: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320062: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320067: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320069: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320069: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320518: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 07:25:00.320876: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:30.681933: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681934: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681937: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681933: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681933: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681938: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.681934: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682091: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682092: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682091: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682091: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682091: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682095: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682092: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.682424: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 08:41:30.684371: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684372: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684372: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684374: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684381: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684381: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684384: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684557: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684558: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684558: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684558: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684560: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684559: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684560: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.684560: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 08:41:30.708113: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708114: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708113: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708114: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708115: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708113: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708136: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.708156: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708156: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708156: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708157: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708157: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708157: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708181: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708181: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708183: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708186: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708186: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708186: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.708266: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.708289: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709381: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709380: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709380: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709380: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709380: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709382: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709383: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709380: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 08:41:30.709422: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709423: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709425: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709425: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709426: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709426: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709427: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709448: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709448: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709448: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709449: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709450: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709450: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709452: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.709536: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 08:41:30.709558: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 08:41:30.713623: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713624: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713623: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713623: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713623: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713623: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.713624: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715392: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715392: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715392: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715393: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715393: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715392: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715393: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:30.715393: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 08:41:35.115958: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116192: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116639: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116657: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116669: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116671: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116678: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116683: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116687: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116691: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116693: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116697: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.116706: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.117313: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 08:41:35.117438: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:19.776757: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776749: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776751: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776749: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776751: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776755: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776752: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776757: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776792: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776788: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776787: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776787: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776787: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776787: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.776788: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-11-08 09:58:19.779225: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779226: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779230: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779231: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779231: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779233: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779233: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779234: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779299: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779300: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779300: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779302: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779302: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779305: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.779305: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2023-11-08 09:58:19.803596: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803596: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803596: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803596: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803596: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803638: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803638: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803639: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803639: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803665: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803693: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803712: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803724: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803750: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803760: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803761: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.803772: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803780: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803797: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.803818: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.803844: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804051: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2023-11-08 09:58:19.804092: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804092: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804093: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804092: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804093: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804093: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804119: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804119: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804121: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804121: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804121: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804122: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.804197: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2023-11-08 09:58:19.804219: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2023-11-08 09:58:19.809058: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809057: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809058: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809057: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809058: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809058: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809060: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.809063: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810022: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:19.810052: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420241: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420250: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420250: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420250: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420702: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420723: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420728: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.420757: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.421120: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-11-08 09:58:24.421573: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "for mem in mems:\n", + " for iter in range(3):\n", + " cl.prt(f\"\\nmemory = {mem}, iter= {iter+1} started. {time.ctime(time.time())} ---------\\n\")\n", + " alg_name = f\"{job_name}_{mem}\"\n", + " pricing_game = env_class(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy,memory=mem)\n", + "\n", + " seed = int(time.time())\n", + "\n", + " model_name = f\"{alg_name}-{str(seed)}\"\n", + " models_dir = f\"{gl.MODELS_DIR}/{model_name}\"\n", + " log_dir = f\"{gl.LOG_DIR}/{model_name}\"\n", + "\n", + " number_episodes = 4_000_000\n", + " train_env = make_vec_env(env_class, n_envs=num_procs, seed=seed, vec_env_cls=SubprocVecEnv, env_kwargs=dict(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy,memory=mem))\n", + " model = alg('MlpPolicy', train_env, learning_rate=gl.LR,\n", + " verbose=0, tensorboard_log=log_dir, gamma=gl.GAMMA, target_entropy=0)\n", + "\n", + " start = time.time()\n", + " # for i in range(gl.NUM_MODEL_SAVE):\n", + " # tmp = (number_episodes/gl.NUM_MODEL_SAVE)\n", + " # model.learn(total_timesteps=tmp, reset_num_timesteps=False,\n", + " # tb_log_name=model_name)\n", + " # model.save(os.path.join(models_dir, str(tmp*(i+1))))\n", + " model.learn(total_timesteps=number_episodes, tb_log_name=model_name)\n", + " model.save(models_dir)\n", + " cl.prt(f\"model {models_dir} is saved!\\n\")\n", + "\n", + " running_time = time.time() - start\n", + "\n", + " \n", + " pricing_game = env_class(\n", + " tuple_costs=costs, adversary_mixed_strategy=adv_mixed_strategy,memory=mem)\n", + " model_strategy = cl.Strategy(strategy_type=cl.StrategyType.sb3_model,\n", + " model_or_func=alg, name=model_name, action_step=pricing_game.action_step,memory=mem)\n", + " mean_payoffs=[0]*len(adv_mixed_strategy.strategies)\n", + " total_mean=0\n", + " for strategy_index in range(len(adv_mixed_strategy.strategies)):\n", + " if adv_mixed_strategy.strategy_probs[strategy_index] > 0:\n", + " pricing_game = env_class(tuple_costs=costs, adversary_mixed_strategy=(adv_mixed_strategy.strategy_probs[strategy_index]).to_mixed_strategy(),memory=mem)\n", + " payoffs = []\n", + " for i in range(gl.NUM_STOCHASTIC_ITER):\n", + " # returns = algorithm.play_trained_agent(adversary=(\n", + " # (adv_mixed_strategy._strategies[strategy_index]).to_mixed_strategy()), iterNum=gl.num_stochastic_iter)\n", + " payoffs.append(model_strategy.play_against(\n", + " env=pricing_game, adversary=adv_mixed_strategy.strategies[strategy_index]))\n", + " data = [model_name, number_episodes, (\"L\" if (costs[0] < costs[1]) else \"H\"), pricing_game.adversary_strategy.name,\n", + " sum(pricing_game.profit[0]), sum(pricing_game.profit[1]), str(\n", + " pricing_game.profit[0]), str(pricing_game.actions), str(pricing_game.prices[0]),\n", + " str(pricing_game.prices[1]), str(pricing_game.demand_potential[0]), str(\n", + " pricing_game.demand_potential[1]), gl.LR, mem,\n", + " gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, False, seed, num_procs, running_time]\n", + " cl.write_results(data)\n", + "\n", + " mean_payoffs[strategy_index] = (np.array(payoffs).mean(axis=0))[0]\n", + " total_mean+= mean_payoffs[strategy_index]*adv_mixed_strategy.strategy_probs[strategy_index]\n", + "\n", + " \n", + "\n", + " data = [model_name, number_episodes, (\"L\" if (costs[0] < costs[1]) else \"H\"), str(adv_mixed_strategy)+str(mean_payoffs), total_mean, 0,\n", + " gl.LR, mem, gl.TOTAL_STAGES, pricing_game.action_step, gl.NUM_ACTIONS, gl.GAMMA, seed, num_procs, running_time,\n", + " time.ctime(time.time())]\n", + "\n", + " cl.write_agents(data)\n", + " cl.prt(f\"results of model {model_name} are written!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "234e599f-5ab1-4691-b496-b1421ba36a27", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "venv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learningAgents/tuning_params/memory/src/bimatrix.py b/learningAgents/tuning_params/memory/src/bimatrix.py new file mode 100644 index 0000000..799ac98 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils +import src.columnprint +import src.lemke +import src.randomstart +import random # random.seed +import src.classes + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + classes.prt("\n all equilibria: \n") + for eq in sorted_trset: + classes.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/tuning_params/memory/src/classes.py b/learningAgents/tuning_params/memory/src/classes.py new file mode 100644 index 0000000..0e5ca74 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/classes.py @@ -0,0 +1,449 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"game_{job_name}.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + memory = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, memory=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.memory = gl.NUM_ADV_HISTORY if ( + memory is None) else memory + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, memory=self.memory) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + # self.env = env + env.adversary_mixed_strategy= adversary.to_mixed_strategy() + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + + path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel(f'results_{job_name}.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") + +def set_job_name(name): + global job_name + job_name=name \ No newline at end of file diff --git a/learningAgents/tuning_params/memory/src/columnprint.py b/learningAgents/tuning_params/memory/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/tuning_params/memory/src/environments.py b/learningAgents/tuning_params/memory/src/environments.py new file mode 100644 index 0000000..81abd92 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/environments.py @@ -0,0 +1,183 @@ +# In this env, in the state representation, the memory og both agent and adversary will be given. the length of memory is specified with variable memory + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl +import src.classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + #memory of both players + self.memory=memory + # self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(2+2*memory,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, memory=None): + # [stage, our demand, our price memory, adv price memory] + + mem_len = memory if ( + memory is not None) else self.memory + + + stage_part = [stage] + self_mem=[] + adv_mem=[] + + if stage == 0: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + observation = stage_part+[self.demand_potential[player][self.stage]] + self_mem+ adv_mem + else: + if (mem_len > 0): + adv_mem = [0]*mem_len + self_mem = [0]*mem_len + j = mem_len-1 + for i in range(stage-1, max(-1, stage-1-mem_len), -1): + adv_mem[j] = self.prices[1-player][i] + self_mem[j] = self.prices[player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player][self.stage]]+ self_mem+ adv_mem + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy, memory): + super().__init__(tuple_costs, adversary_mixed_strategy,memory) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/tuning_params/memory/src/globals.py b/learningAgents/tuning_params/memory/src/globals.py new file mode 100644 index 0000000..3273cf6 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.0003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 20 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=6 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/tuning_params/memory/src/lemke.py b/learningAgents/tuning_params/memory/src/lemke.py new file mode 100644 index 0000000..c794b49 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint +import src.utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/tuning_params/memory/src/utils.py b/learningAgents/tuning_params/memory/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/tuning_params/memory/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/tuning_params/results.xlsx b/learningAgents/tuning_params/results.xlsx new file mode 100644 index 0000000..7abe831 Binary files /dev/null and b/learningAgents/tuning_params/results.xlsx differ diff --git a/learningAgents/tuning_params/src/bimatrix.py b/learningAgents/tuning_params/src/bimatrix.py new file mode 100644 index 0000000..799ac98 --- /dev/null +++ b/learningAgents/tuning_params/src/bimatrix.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# bimatrix class + +import sys +import numpy as np +import fractions +import src.utils +import src.columnprint +import src.lemke +import src.randomstart +import random # random.seed +import src.classes + +# for debugging +def printglobals(): + globs = [x for x in globals().keys() if not "__" in x] + for var in globs: + value = str(globals()[var]) + if not "<" in value: + print(" "+str(var)+"=", value) + +# file format: +# +# m*n entries of A, separated by blanks / newlines +# m*n entries of B, separated by blanks / newlines +# +# blank lines or lines starting with "#" are ignored + +# defaults +# MAXDIM = 2000 # largest allowed value for m and n; not used yet +gamefilename = "game" +gz0 = False +LHstring = "" # empty means LH not called +seed = -1 +trace = -1 # negative: no tracing +# accuracy = DEFAULT_accuracy = 1000 +accuracy = 1000 + +# amends defaults +def processArguments(): + global gamefilename,gz0,LHstring,seed,trace,accuracy + arglist = sys.argv[1:] + setLH = False + settrace = False + setaccuracy = False + setseed = False + setdecimals = False + showhelp = False + for s in arglist: + if s[0] == '-': + # discard optional argument-parameters + if (setLH or settrace or setseed): + setLH = settrace = setseed = False + if s=="-LH": + setLH = True + LHstring = "1-" + elif s=="-trace": + settrace = True + trace = 0 + elif s=="-seed": + setseed = True + seed = 0 + elif s=="-accuracy": + setaccuracy = True + elif s=="-decimals": + setdecimals = True + elif s=="-z0": + gz0 = True + elif s=="-?" or s=="-help": + showhelp = True + else: # any other "-" argument + showhelp = True + print("! unknown option: ", repr(s)) + else: # s not starting with "-" + if setLH: + setLH = False + LHstring = s + elif settrace: + settrace= False + trace = int(s) + elif setseed: + setseed= False + seed = int(s) + elif setdecimals: + setdecimals = False + utils.setdecimals(int(s)) + elif setaccuracy: + setaccuracy= False + accuracy = int(s) + else: + gamefilename = s + if (showhelp): + helpstring="""usage: bimatrix.py [options] +options: + here: """+repr(gamefilename)+ """, must not start with '-' + -LH [] : Lemke-Howson with missing labels, e.g. '1,3-5,7-' ('' = all) + -trace []: tracing procedure, no. of priors, 0 = centroid + -seed [] : random seed, default: None + -accuracy : accuracy prior, =denominator, here """+str(accuracy)+""" + -decimals : allowed payoff digits in input after decimal point, default 4 + -?, -help: show this help and exit""" + print(helpstring) + exit(0) + return + +# list generated from string s such as "1-3,10,4-7", all not +# larger than endrange (50 is arbitrary default) and at least 1 +def rangesplit(s,endrange=50): + result = [] + for part in s.split(','): + if part != "": + if '-' in part: + a, b = part.split('-') + a = int(a) + b = endrange if b=="" else int(b) + else: + a = int(part) + b = a + a = max(a,1) + b = min(b, endrange) # a > endrange means empty range + result.extend(range(a, b+1)) + return result + +# used for both A and B +class payoffmatrix: + # create zero matrix of given dimensions + def __init__(self, m, n): + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.negmatrix = np.zeros( (m,n), dtype=fractions.Fraction) + self.max = 0 + self.min = 0 + self.negshift = 0 + + # create matrix from any numerical matrix + def __init__(self, A): + AA = np.array(A) + m,n = AA.shape + self.numrows = m + self.numcolumns = n + self.matrix = np.zeros( (m,n), dtype=fractions.Fraction) + for i in range(m): + for j in range(n): + self.matrix[i][j] = utils.tofraction(AA[i][j]) + self.fullmaxmin() + + def __str__(self): + buf = columnprint.columnprint(self.numcolumns) + for i in range(self.numrows): + for j in range(self.numcolumns): + buf.sprint(str(self.matrix[i][j])) + out = str(buf) + out += "\n# max= " + str(self.max) + ", min= " + str(self.min) + out += ", negshift= " + str(self.negshift) + return out + + def updatemaxmin(self, fromrow, fromcol): + m=self.numrows + n=self.numcolumns + for i in range(fromrow, m): + for j in range(fromcol, n): + elt = self.matrix[i][j] + self.max = max(self.max, elt) + self.min = min(self.min, elt) + self.negshift = int(self.max)+1 + self.negmatrix = np.full((m,n),self.negshift,dtype=int)-self.matrix + + def fullmaxmin(self): + self.max = self.matrix[0][0] + self.min = self.matrix[0][0] + self.updatemaxmin(0,0) + + # add full row, row must be of size n + def addrow(self, row): + self.matrix = np.vstack([self.matrix, row]) + self.numrows += 1 + self.updatemaxmin(self.numrows-1,0) + + # add full column, col must be of size m + def addcolumn(self, col): + self.matrix = np.column_stack([self.matrix, col]) + self.numcolumns += 1 + self.updatemaxmin(0,self.numcolumns-1) + +class bimatrix: + # create A,B given m,n + def __init__(self, m, n): + self.A = payoffmatrix(m,n) + self.B = payoffmatrix(m,n) + + # create A,B from file + def __init__(self, filename): + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + m = int(words[0]) + n = int(words[1]) + needfracs = 2*m*n + if len(words) != needfracs + 2: + print("in bimatrix file "+repr(filename)+":") + print("m=",n,", n=",n,", need", + needfracs,"payoffs, got", len(words)-2) + exit(1) + k = 2 + C = utils.tomatrix(m, n, words, k) + self.A = payoffmatrix(C) + k+= m*n + C = utils.tomatrix(m, n, words, k) + self.B = payoffmatrix(C) + + def __str__(self): + out = "# m,n= \n" + str(self.A.numrows) + out += " " + str(self.A.numcolumns) + out += "\n# A= \n" + str(self.A) + out += "\n# B= \n" + str(self.B) + return out + + def createLCP(self): + m = self.A.numrows + n = self.A.numcolumns + lcpdim = m+n+2 + lcp = lemke.lcp(lcpdim) + lcp.q[lcpdim-2] = -1 + lcp.q[lcpdim-1] = -1 + for i in range(m): + lcp.M[lcpdim-2][i] = 1 + lcp.M[i][lcpdim-2] = -1 + for j in range(m,m+n): + lcp.M[lcpdim-1][j] = 1 + lcp.M[j][lcpdim-1] = -1 + for i in range(m): + for j in range(n): + lcp.M[i][j+m] = self.A.negmatrix[i][j] + for j in range(n): + for i in range(m): + lcp.M[j+m][i] = self.B.negmatrix[i][j] + # d for now + for i in range(lcpdim): + lcp.d[i]=1 + return lcp + + + def runLH(self, droppedlabel): + lcp = self.createLCP() + lcp.d[droppedlabel-1] = 0 # subsidize this label + tabl = lemke.tableau(lcp) + # tabl.runlemke(verbose=True, lexstats=True, z0=gz0) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def LH(self, LHstring): + if LHstring == "": + return + m = self.A.numrows + n = self.A.numcolumns + lhset = {} # dict of equilibria and list by which label found + labels = rangesplit(LHstring, m+n) + for k in labels: + eq = self.runLH(k) + if eq in lhset: + lhset[eq].append(k) + else: + print ("label",k,"found eq", str_eq(eq,m,n)) + lhset[eq] = [k] + for eq in lhset: + print (str_eq(eq,m,n),"found by labels", str(lhset[eq])) + return lhset + + def runtrace(self, xprior, yprior): + lcp = self.createLCP() + Ay = self.A.negmatrix @ yprior + xB = xprior @ self.B.negmatrix + lcp.d = np.hstack((Ay,xB,[1,1])) + tabl = lemke.tableau(lcp) + tabl.runlemke(silent=True) + return tuple(getequil(tabl)) + + def tracing(self, trace,equi_num=1): + """ + trace: number of iterations + equi_num: the number of most frequent equilibria + """ + if trace < 0: + return + m = self.A.numrows + n = self.A.numcolumns + trset = {} # dict of equilibria, how often found + if trace == 0: + xprior = uniform(m) + yprior = uniform(n) + eq = self.runtrace(xprior, yprior) + trset[eq]=1 + trace = 1 # for percentage + else: + for k in range(trace): + if seed >=0: + random.seed(10*trace*seed+k) + x = randomstart.randInSimplex(m) + xprior = randomstart.roundArray(x, accuracy) + y = randomstart.randInSimplex(n) + yprior = randomstart.roundArray(y, accuracy) + # print (f"{k=} {xprior=} {yprior=}") + eq = self.runtrace(xprior, yprior) + if eq in trset: + trset[eq] += 1 + else: +# print ("found eq", str_eq(eq,m,n), "index", +# self.eqindex(eq,m,n)) + trset[eq] = 1 + sorted_trset=sorted(trset.items(), key=lambda x: x[1], reverse=True) + + classes.prt("\n all equilibria: \n") + for eq in sorted_trset: + classes.prt(str_eq(eq[0], m,n)+ ", found: "+ str(eq[1])+"\n") + + equilibria = [] + equilibria_num=min(equi_num,len(sorted_trset)) + times_found = 0 + for i in range(equilibria_num): + if sorted_trset[i][1] > times_found: + equilibria.append(str_eq(sorted_trset[i][0], m,n)) +# print (trset[eq],"times found ",str_eq(eq,m,n)) +# print(trace,"total priors,",len(trset),"equilibria found") + return equilibria + + def eqindex(self,eq,m,n): + rowset,colset = supports(eq,m,n) + k,l = len(rowset),len(colset) + if k!=l: + return 0 + A1 = submatrix(self.A.negmatrix, rowset, colset) + DA = np.linalg.det(A1) + B1 = submatrix(self.B.negmatrix, rowset, colset) + DB = np.linalg.det(B1) + sign = 2*(k%2) - 1 # -1 if even, 1 if odd + if DA*DB == 0: + return 0 + if DA*DB > 0: + return sign + return -sign + +def uniform(n): + return np.array([ fractions.Fraction(1,n) for j in range(n)]) + +def getequil(tabl): + tabl.createsol() + return tabl.solution[1:tabl.n-1] + +def str_eq(eq,m,n): + x = "("+",".join([str(x) for x in eq[0:m]])+")" + y = "("+",".join([str(x) for x in eq[m:m+n]])+")" + rowset,colset = supports(eq,m,n) + return x+","+y+"\n supports: "+str(rowset)+str(colset) + +def supports(eq,m,n): + rowset = [i for i in range(m) if eq[i]!= 0] + colset = [j for j in range(n) if eq[m+j]!= 0] + return rowset,colset + +def submatrix(A,rowset,colset): + k,l = len(rowset),len(colset) + B = np.zeros((k,l)) + for i in range (k): + for j in range(l): + B[i][j] = A[rowset[i]][colset[j]] + return B + +if __name__ == "__main__": + processArguments() + printglobals() + + G = bimatrix(gamefilename) + print(G) + eqset = G.LH(LHstring) + eqset = G.tracing(trace) diff --git a/learningAgents/tuning_params/src/classes.py b/learningAgents/tuning_params/src/classes.py new file mode 100644 index 0000000..a829b88 --- /dev/null +++ b/learningAgents/tuning_params/src/classes.py @@ -0,0 +1,448 @@ +from enum import Enum +import numpy as np +import src.globals as gl +# import torch +# from torch.distributions import Categorical +from openpyxl import load_workbook +from fractions import Fraction +import src.bimatrix +import time +import os + + +class BimatrixGame(): + """ + strategies play against each other and fill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + low_strategies = [] + high_strategies = [] + matrix_A = None + matrix_B = None + + def __init__(self, low_cost_strategies, high_cost_strategies, env_class) -> None: + # globals.initialize() + self.low_strategies = low_cost_strategies + self.high_strategies = high_cost_strategies + self.env_class = env_class + + def reset_matrix(self): + self.matrix_A = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + self.matrix_B = np.zeros( + (len(self.low_strategies), len(self.high_strategies))) + + def fill_matrix(self): + self.reset_matrix() + + for low in range(len(self.low_strategies)): + for high in range(len(self.high_strategies)): + self.update_matrix_entry(low, high) + + def update_matrix_entry(self, low_index, high_index): + stratL = self.low_strategies[low_index] + stratH = self.high_strategies[high_index] + stratL.reset() + stratH.reset() + + env = self.env_class(tuple_costs=( + gl.LOW_COST, gl.HIGH_COST), adversary_mixed_strategy=stratH.to_mixed_strategy()) + payoffs = [stratL.play_against(env, stratH) + for _ in range(gl.NUM_STOCHASTIC_ITER)] + + mean_payoffs = (np.mean(np.array(payoffs), axis=0)) + + self.matrix_A[low_index][high_index], self.matrix_B[low_index][high_index] = mean_payoffs[0], mean_payoffs[1] + + def write_all_matrix(self): + # print("A: \n", self._matrix_A) + # print("B: \n", self._matrix_B) + + output = f"{len(self.matrix_A)} {len(self.matrix_A[0])}\n\n" + + for matrix in [self.matrix_A, self.matrix_B]: + for i in range(len(self.matrix_A)): + for j in range(len(self.matrix_A[0])): + output += f"{matrix[i][j]:7.0f} " + output += "\n" + output += "\n" + + with open(f"game_{job_name}.txt", "w") as out: + out.write(output) + + output+="\nlow-cost strategies: \n" + for strt in self.low_strategies: + output+=f" {strt.name} " + output+="\nhigh-cost strategies: \n" + for strt in self.high_strategies: + output+=f" {strt.name} " + + with open(f"games/game{int(time.time())}.txt", "w") as out: + out.write(output) + + + def add_low_cost_row(self, row_A, row_B): + self.matrix_A = np.append(self.matrix_A, [row_A], axis=0) + self.matrix_B = np.append(self.matrix_B, [row_B], axis=0) + + def add_high_cost_col(self, colA, colB): + self.matrix_A = np.hstack((self.matrix_A, np.atleast_2d(colA).T)) + self.matrix_B = np.hstack((self.matrix_B, np.atleast_2d(colB).T)) + # for j in range(len(self._matrix_A)): + # self._matrix_A[j].append(colA[j]) + # self._matrix_B[j].append(colB[j]) + + def compute_equilibria(self): + self.write_all_matrix() + game = bimatrix.bimatrix(f"game_{job_name}.txt") + equilibria_traces = game.tracing(100, gl.NUM_TRACE_EQUILIBRIA) + equilibria = [] + for equilibrium in equilibria_traces: + low_cost_probs, high_cost_probs, low_cost_support, high_cost_support = recover_probs( + equilibrium) + low_cost_probabilities = return_distribution( + len(self.low_strategies), low_cost_probs, low_cost_support) + high_cost_probabilities = return_distribution( + len(self.high_strategies), high_cost_probs, high_cost_support) + low_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_A, np.transpose(high_cost_probabilities))) + high_cost_payoff = np.matmul(low_cost_probabilities, np.matmul( + self.matrix_B, np.transpose(high_cost_probabilities))) + + + result = {"low_cost_probs": low_cost_probabilities, + "high_cost_probs": high_cost_probabilities, + "low_cost_payoff": low_cost_payoff, + "high_cost_payoff": high_cost_payoff} + equilibria.append(result) + return equilibria + + +class Strategy(): + """ + strategies can be static or they can come from neural nets. If NN, policy is nn.policy o.w. the static function + """ + type = None + env = None + name = None + nn = None + state_adv_hist = None + policy = None + + def __init__(self, strategy_type, model_or_func, name, first_price=132, state_adv_hist=None, action_step=None) -> None: + """ + model_or_func: for static strategy is the function, for sb3 is the optimizer class + """ + self.type = strategy_type + self.name = name + # self._env = environment + self.state_adv_hist = gl.NUM_ADV_HISTORY if ( + state_adv_hist is None) else state_adv_hist + + self.action_step = action_step + + if strategy_type == StrategyType.neural_net: + # self.nn = ModelOrFunc + # self.policy = ModelOrFunc.policy + # self.state_adv_hist = gl.NUM_ADV_HISTORY + pass + elif strategy_type == StrategyType.sb3_model: + self.dir = f"{gl.MODELS_DIR}/{name}" + self.model = model_or_func + # self.policy = self.model.predict + + else: + self.policy = model_or_func + self.first_price = first_price + + def reset(self): + pass + + def play(self, env, player=1): + """ + Computes the price to be played in the environment, nn.step_action is the step size for pricing less than myopic + """ + + if self.type == StrategyType.neural_net: + # state = self.env.get_state( + # self.env.stage, player, adv_hist=gl.num_adv_history) + # normState = normalize_state(state=state) + # probs = self.policy(normState) + # distAction = Categorical(probs) + # action = distAction.sample() + # return compute_price(action=action.item(), action_step=gl.ACTION_STEP, demand=self.env.demandPotential[player][self.env.stage], cost=self.env.costs[player]) + pass + elif self.type == StrategyType.sb3_model: + if self.policy is None: + self.policy= (self.model.load(self.dir,env=env)).predict + state = env.get_state( + stage=env.stage, player=player, adv_hist=self.state_adv_hist) + action, _ = self.policy(state) + #compute price for co model and disc model + price= (env.myopic(player)-action[0]) if (self.action_step is None) else (env.myopic(player)-(self.action_step*action)) + + if player==0: + env.actions[env.stage]= (action[0] if(self.action_step is None) else (self.action_step*action)) + + return price + else: + return self.policy(env, player, self.first_price) + + def play_against(self, env, adversary): + """ + self is player 0 and adversary is layer 1. The environment should be specified. action_step for the neural netwroks should be set. + output: tuple (payoff of low cost, payoff of high cost) + """ + self.env = env + + state,_ = env.reset() + while env.stage < (env.T): + prices = [0, 0] + prices[0], prices[1] = self.play(env, 0), adversary.play(env, 1) + env.update_game_variables(prices) + env.stage += 1 + + return [sum(env.profit[0]), sum(env.profit[1])] + + def to_mixed_strategy(self): + """ + Returns a MixedStrategy, Pr(self)=1 + """ + mix = MixedStrategy(probablities_lst=[1], + strategies_lst=[self]) + + return mix + + +class MixedStrategy(): + strategies = [] + strategy_probs = None + + def __init__(self, strategies_lst, probablities_lst) -> None: + self.strategies = strategies_lst + self.strategy_probs = probablities_lst + self.support_size=support_count(probablities_lst) + + def choose_strategy(self): + if len(self.strategies) > 0: + # adversaryDist = Categorical(torch.tensor(self._strategyProbs)) + # if not torch.is_tensor(self._strategyProbs): + # self._strategyProbs = torch.tensor(self._strategyProbs) + # adversaryDist = Categorical(self._strategyProbs) + # strategyInd = (adversaryDist.sample()).item() + strategy_ind = np.random.choice( + len(self.strategies), size=1, p=self.strategy_probs) + return self.strategies[strategy_ind[0]] + else: + print("adversary's strategy can not be set!") + return None + + def play_against(self, env, adversary): + pass + + def __str__(self) -> str: + s = "" + for i in range(len(self.strategies)): + if self.strategy_probs[i] > 0: + s += f"{self.strategies[i].name}-{self.strategy_probs[i]:.2f}," + return s + + +class StrategyType(Enum): + static = 0 + neural_net = 1 + sb3_model = 2 + + +def myopic(env, player, firstprice=0): + """ + Adversary follows Myopic strategy + """ + return env.myopic(player) + + +def const(env, player, firstprice): # constant price strategy + """ + Adversary follows Constant strategy + """ + if env.stage == env.T-1: + return env.myopic(player) + return firstprice + + +def imit(env, player, firstprice): # price imitator strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + return env.prices[1-player][env.stage-1] + + +def fight(env, player, firstprice): # simplified fighting strategy + if env.stage == 0: + return firstprice + if env.stage == env.T-1: + return env.myopic(player) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (env.total_demand-env.costs[player] + + env.costs[1-player])/2 + + D = env.demand_potential[player][env.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return env.prices[player][env.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getenv.demandPotential to Asp + P = env.prices[1-player][env.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (env.total_demand+env.costs[0]+env.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + +def fight_lb(env, player, firstprice): + P = env.fight(player, firstprice) + # never price less than production cost + P = max(P, env.costs[player]) + return P + +# sophisticated fighting strategy, compare fight() +# estimate *sales* of opponent as their target + + +def guess(env, player, firstprice): # predictive fighting strategy + if env.stage == 0: + env.aspireDemand = [(env.total_demand/2 + env.costs[1]-env.costs[0]), + (env.total_demand/2 + env.costs[0]-env.costs[1])] # aspiration level + env.aspirePrice = (env.total_demand+env.costs[0]+env.costs[1])/4 + # first guess opponent sales as in monopoly ( sale= demand-price) + env.saleGuess = [env.aspireDemand[0]-env.aspirePrice, + env.aspireDemand[1]-env.aspirePrice] + + return firstprice + + if env.stage == env.T-1: + return env.myopic(player) + + D = env.demand_potential[player][env.stage] + Asp = env.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = env.myopic(player) + pcurrent = env.prices[player][env.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = env.demand_potential[1 - + player][env.stage-1] - env.prices[1-player][env.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * env.saleGuess[player] + (1-alpha)*prevsales + # update + env.saleGuess[player] = newsalesguess + guessoppPrice = env.total_demand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +def monopolyPrice(demand, cost): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (demand + cost) / 2 + # return (self.demandPotential[player][self.stage] + self.costs[player])/2 + +def prt(string): + """ + writing the progres into a file instead of print + """ + global job_name + with open(f'progress_{job_name}.txt','a') as file: + file.write("\n"+string) + + +def write_to_excel(file_name, new_row): + """ + row includes: name ep costs adversary agent_return adv_return agent_rewards actions agent_prices adv_prices agent_demands adv_demands lr hist total_stages action_step num_actions gamma stae_onehot seed num_procs running_time + """ + + + path = f'results_{job_name}.xlsx' if (file_name is None) else file_name + + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + +def write_results(new_row): + write_to_excel(f'results_{job_name}.xlsx', new_row) +def write_agents(new_row): + # name ep costs adversary expected_payoff payoff_treshhold lr hist total_stages action_step num_actions\ + #gamma seed num_procs running_time date + + write_to_excel(f'trained_agents_{job_name}.xlsx', new_row) + + +def support_count(list): + """ + gets a list and returns the number of elements that are greater than zero + """ + counter = 0 + for item in list: + if item > 0: + counter += 1 + return counter + +def recover_probs(test): + low_cost_probs, high_cost_probs, rest = test.split(")") + low_cost_probs = low_cost_probs.split("(")[1] + _, high_cost_probs = high_cost_probs.split("(") + high_cost_probs = [float(Fraction(s)) for s in high_cost_probs.split(',')] + low_cost_probs = [float(Fraction(s)) for s in low_cost_probs.split(',')] + _, low_cost_support, high_cost_support = rest.split('[') + high_cost_support, _ = high_cost_support.split(']') + high_cost_support = [int(s) for s in high_cost_support.split(',')] + low_cost_support, _ = low_cost_support.split(']') + low_cost_support = [int(s) for s in low_cost_support.split(',')] + return low_cost_probs, high_cost_probs, low_cost_support, high_cost_support + + +def return_distribution(number_players, cost_probs, cost_support): + player_probabilities = [0] * number_players + for index, support in enumerate(cost_support): + player_probabilities[support] = cost_probs[support] + return player_probabilities + +def create_directories(): + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists(gl.LOG_DIR): + os.makedirs(gl.LOG_DIR) + if not os.path.exists(gl.MODELS_DIR): + os.makedirs(gl.MODELS_DIR) + if not os.path.exists("games"): + os.makedirs("games") + +def set_job_name(name): + global job_name + job_name=name \ No newline at end of file diff --git a/learningAgents/tuning_params/src/columnprint.py b/learningAgents/tuning_params/src/columnprint.py new file mode 100644 index 0000000..763cb62 --- /dev/null +++ b/learningAgents/tuning_params/src/columnprint.py @@ -0,0 +1,88 @@ +# automatic pretty printing in columns +import random + +class columnprint: + +# create buffer with c columns, at least 1 + def __init__(self, c): # void colset(int c); + if c < 1 : + print ("need positive number of columns, not", c) + raise Exception + self.buf = [] + self.ncols = c + self.colwidth = [0]*c + self.widthsign = [1]*c + self.currlines = 0 + self.currcol = 0 + self.line = [] + +# create string, intermittent lines (not last line) separated by \n + def __str__(self) : # colout(void) + out = "" + for l in self.buf: + out += self.prline(l) + "\n" + if self.line == [] : + out = out[:-1] + else: + out += self.prline(self.line) + return out + +# (private) string from line, which is a list of strings + def prline(self, line): # prline(char *s) + out = "" + i = 0 + for word in line: + if self.widthsign[i] == 1: + word = word.rjust(self.colwidth[i]) + else: + word = word.ljust(self.colwidth[i]) + out += word + i += 1 + if i < self.ncols: + out += " " ####### single spacing here + return out + +# print integer i into the current column + def iprint(self, i): # colipr(i) + self.sprint(str(i)) + +# make column c in 0..ncols-1 left-adjusted + def makeLeft(self, c): # colleft(int c) + self.widthsign[c] = -1 + +# terminate current line early. blank line if in column 0 + def newline(self): # colnl(void); + for j in range(self.ncols - self.currcol): + self.sprint("") + +# store string s into the current column, updating column width + def sprint(self,s): # colpr(const char *s) + w = len(s) + if self.colwidth[self.currcol] < w: + self.colwidth[self.currcol] = w + self.line.append(s) + self.currcol += 1 + if self.currcol == self.ncols : + self.buf.append(self.line) + self.line = [] + self.currcol = 0 + +if __name__ == "__main__": + print ("example with 3 columns, first left-justified") + print ("============================================") + M = columnprint(3) + M.makeLeft(0) + M.sprint("z0") + M.sprint("z1") + M.sprint("z2") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) + print ("example with 2 columns") + print ("======================") + M = columnprint(2) + M.sprint("z0") + M.sprint("z1") + for i in [1,200,3,20000,0,-1,88,9] : + M.iprint(i) + print(M) diff --git a/learningAgents/tuning_params/src/environments.py b/learningAgents/tuning_params/src/environments.py new file mode 100644 index 0000000..3c00a74 --- /dev/null +++ b/learningAgents/tuning_params/src/environments.py @@ -0,0 +1,185 @@ + +from enum import Enum +import numpy as np +import gymnasium as gym +from gymnasium import spaces +import src.globals as gl +import src.classes as cl +class ConPricingGame(gym.Env): + + + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__() + gl.initialize() + + # Actions that we can take: From 0 to 49 below the myopic price + # self.action_space = spaces.Discrete(50) + self.action_step=None + + self.total_demand = gl.TOTAL_DEMAND + self.costs = tuple_costs + self.T = gl.TOTAL_STAGES + self.demand_potential = None # two lists for the two players + self.prices = None # prices over rounds + self.profit = None # profit in each round + self.stage = None + self.done = False + + self.adversary_mixed_strategy = adversary_mixed_strategy + self.state_adv_history = gl.NUM_ADV_HISTORY + self.reward_division = gl.REWARDS_DIVISION_CONST + + self.action_space = spaces.Box(low=0, high=gl.CON_ACTIONS_RANGE, shape=(1,)) + + # State space + self.observation_space = spaces.Box( + low=0, high=self.total_demand, shape=(3+gl.NUM_ADV_HISTORY,)) + + + + + def reset(self, seed = None, options = None): + super().reset(seed=seed) + + self.resetGame() + self.adversary_strategy = self.adversary_mixed_strategy.choose_strategy() + # [stage, agent_ demand, agent_last_price, adversary_price_history] + observation = self.get_state(stage=0) + return observation, {}# reward, done, info can't be included + + + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.episodesMemory = list() + self.stage = 0 + self.done = False + self.demand_potential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.myopic_prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + # initialize first round 0 + self.demand_potential[0][0] = self.demand_potential[1][0] = self.total_demand / 2 + self.actions=[0]*self.T + + def get_state(self, stage, player=0, adv_hist=None): + + num_adv_hist = adv_hist if ( + adv_hist is not None) else self.state_adv_history + adv_history = [] + + stage_part = [stage] + # if self.state_onehot: + # stage_part=[0]*3 + # if stage==0: + # stage_part[0]=1 + # elif stage==self.T-1: + # stage_part[2]=1 + # else: + # stage_part[1]=1 + + + if stage == 0: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + observation = stage_part+[ self.demand_potential[player] + [self.stage], 0] + adv_history + else: + if (num_adv_hist > 0): + adv_history = [0]*num_adv_hist + j = num_adv_hist-1 + for i in range(stage-1, max(-1, stage-1-num_adv_hist), -1): + adv_history[j] = self.prices[1-player][i] + j -= 1 + + observation = stage_part+ [self.demand_potential[player] + [self.stage], self.prices[player][stage-1]] + adv_history + + return np.array(observation) + + + + + def step(self,action): + + self.actions[self.stage]=action[0] + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - action[0], adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info + + + + def update_game_variables(self, price_pair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + price_pair: Pair of prices from the learning agent and adversary. + """ + + for player in [0,1]: + price = price_pair[player] + if price self.demand_potential[player][self.stage]: + price = self.demand_potential[player][self.stage] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = (self.demand_potential[player][self.stage] - price) * (price - self.costs[player])/self.reward_division + + for player in [0,1]: + if self.stage < self.T - 1 : + self.demand_potential[player][ self.stage + 1] = \ + self.demand_potential[player][self.stage] + (self.prices[1-player][self.stage] - self.prices[player][self.stage])/2 + + + + def myopic(self, player = 0): + """ + Adversary follows Myopic strategy + """ + return (self.demand_potential[player][self.stage]+self.costs[player])/2 + # return self.monopoly_price(player) + + + + def render(self): + pass + + def close(self): + pass + + + +class DisPricingGame(ConPricingGame): + def __init__(self,tuple_costs, adversary_mixed_strategy): + super().__init__(tuple_costs, adversary_mixed_strategy) + + self.action_step=gl.ACTION_STEP + + self.action_space = spaces.Discrete(gl.NUM_ACTIONS) + + def step(self, action): + self.actions[self.stage]=action + adversary_action = self.adversary_strategy.play( + env=self, player=1) + self.update_game_variables( [self.myopic() - (action*self.action_step), adversary_action] ) + + done = (self.stage == self.T-1) + + reward = self.profit[0][self.stage] + self.stage += 1 + + info = {} + + return self.get_state(stage=self.stage), reward, done,False, info diff --git a/learningAgents/tuning_params/src/globals.py b/learningAgents/tuning_params/src/globals.py new file mode 100644 index 0000000..2d82860 --- /dev/null +++ b/learningAgents/tuning_params/src/globals.py @@ -0,0 +1,39 @@ +def initialize(): + global TOTAL_DEMAND, LOW_COST, HIGH_COST, TOTAL_STAGES, NUM_ADV_HISTORY, LR, GAMMA, NUM_ACTIONS + global ACTION_STEP, NUM_STOCHASTIC_ITER, NUM_EPISODES, NUM_EPISODES_RESET, EPISODE_ADV_INCREASE + global REWARDS_DIVISION_CONST,REPLAY_BUFFER_SIZE,PROB_BREAK_LIMIT_LN,CONVERGE_BREAK, PRINT_STEP + global BATCH_UPDATE_SIZE,BUFFER_PLAY_COEFFICIENT, NUM_PROCESS,NUM_TRACE_EQUILIBRIA + global TIMESTEPS, NUM_TIMESTEPS,CON_ACTIONS_RANGE,NUM_MODEL_SAVE,MODELS_DIR,LOG_DIR + + TOTAL_DEMAND = 400 + LOW_COST = 57 + HIGH_COST = 71 + TOTAL_STAGES = 25 + NUM_ADV_HISTORY = 3 + + LR = 0.00003 + GAMMA = 1 + NUM_ACTIONS = 20 + CON_ACTIONS_RANGE=60 + ACTION_STEP = 3 + NUM_STOCHASTIC_ITER = 20 + REWARDS_DIVISION_CONST = 1000 + + + NUM_EPISODES = 3_000_000 + EPISODE_ADV_INCREASE = 3_000_000 + # NUM_EPISODES = 3 + # EPISODE_ADV_INCREASE = 3 + + NUM_EPISODES_RESET = NUM_EPISODES + # INCREASE IN NUM OF EPISODES FOR EACH ADV IN SUPPORT + + NUM_PROCESS=6 + + NUM_TRACE_EQUILIBRIA=1 + #HOW OFTEN THE MODEL SHOULD BE SAVED. + NUM_MODEL_SAVE=3 + + MODELS_DIR="models" + LOG_DIR="logs" + \ No newline at end of file diff --git a/learningAgents/tuning_params/src/lemke.py b/learningAgents/tuning_params/src/lemke.py new file mode 100644 index 0000000..c794b49 --- /dev/null +++ b/learningAgents/tuning_params/src/lemke.py @@ -0,0 +1,542 @@ +#!/usr/bin/python +# LCP solver + +import sys +import fractions +import math # gcd + +import src.columnprint +import src.utils + +# global defaults +lcpfilename="lcp" +outfile=lcpfilename+".out" +filehandle = sys.stdout +verbose=False +silent=False +z0=False + +# process command-line arguments +def processArguments(): + global lcpfilename,outfile,filehandle,verbose,silent,z0 + helpstring="""usage: lemke.py [options] +options: -v, -verbose : printout intermediate tableaus + -s, -silent : send output to .out + -z0 : show value of z0 at each step + -?, -help: show this help + (default: "lcp", must not start with "-") + Example: [python] lemke.py -v 2lcp""" + arglist = sys.argv[1:] + showhelp = False + for s in arglist: + if s=="-v" or s=="-verbose": + verbose = True + elif s=="-s" or s=="-silent": + silent = True + elif s=="-z0": + z0 = True + elif s[0]=="-" : + showhelp = True + else: + lcpfilename = s + outfile = s+".out" + if (showhelp): + printout(helpstring) + exit(0) + return + +def printout(*s): + print(*s, file=filehandle) + +# LCP data M,q,d +class lcp: + # create LCP either with given n or from file + def __init__(self, arg): + if isinstance(arg, int): # arg is an integer + n = self.n = arg + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + else: # assume arg is a string = name of lcp file + # create LCP from file + filename = arg + lines = utils.stripcomments(filename) + # flatten into words + words = utils.towords(lines) + if words[0]!="n=": + printout("lcp file",repr(filename), + "must start with 'n=' lcpdim, e.g. 'n= 5', not", + repr(words[0])) + exit(1) + n = int(words[1]) + self.n = n + # self.M = np.zeros( (n,n), dtype=fractions.Fraction) + # self.d = np.zeros( (n), dtype=fractions.Fraction) + # self.q = np.zeros( (n), dtype=fractions.Fraction) + self.M = [[]]*n + for i in range(n): + self.M[i]=[0]*n + self.q = [0]*n + self.d = [0]*n + needfracs = n*n + 2*n + if len(words) != needfracs + 5: + # printout("in lcp file '",filename,"':") + printout("in lcp file "+repr(filename)+":") + printout("n=",n,", need keywords 'M=' 'q=' 'd=' and n*n + n + n =", + needfracs,"fractions, got", len(words)-5) + exit(1) + k = 2 # index in words + while k < len(words): + if words[k]=="M=": + k+=1 + self.M = utils.tomatrix(n,n,words,k) + k+= n*n + elif words[k]=="q=": + k+=1 + self.q = utils.tovector(n,words,k) + k+=n + elif words[k]=="d=": + k+=1 + self.d = utils.tovector(n,words,k) + k+=n + else: + printout("in lcp file "+repr(filename)+":") + printout("expected one of 'M=' 'q=' 'd=', got",repr(words[k])) + exit(1) + return + + def __str__(self): + n=self.n + M=self.M + q=self.q + d=self.d + m = columnprint.columnprint(n) + m.makeLeft(0) + m.sprint("M=") + m.newline() + for i in range(n): + for j in range(n): + m.sprint(str(M[i][j])) + m.sprint("q=") + m.newline() + for i in range(n): + m.sprint(str(q[i])) + m.sprint("d=") + m.newline() + for i in range(n): + m.sprint(str(d[i])) + # printout("M[0][0]", type(M[0][0])) + return "n= "+str(n)+"\n"+str(m) + ####### end of class lcp + +class tableau: + # filling the tableau from the LCP instance Mqd + def __init__(self, Mqd): + self.n = Mqd.n + n = self.n + self.scalefactor = [0]*(n+2) # 0 for z0, n+1 for RHS + # A = tableau, long integer entries + # self.A = np.zeros( (n,n+2), dtype=object) + self.A = [[]]*n + for i in range(n): + self.A[i]=[0]*(n+2) + self.determinant = 1 + self.lextested = [0]*(n+1) + self.lexcomparisons = [0]*(n+1) + self.pivotcount = 0 + self.solution = [fractions.Fraction(0)]*(2*n+1) # all vars + # variable encodings: VARS = 0..2n = Z(0) .. Z(n) W(1) .. W(n) + # tableau columns: RHS n+1 + # bascobas[v] in 0..n-1: basic, bascobas[v] = tableau row + # bascobas[v] in n..2n: cobasic, bascobas[v]-n = tableau col + self.bascobas = [0]*(2*n+1) + # whichvar inverse of bascobas, shows which basic/cobasic vars + self.whichvar = [0]*(2*n+1) + for i in range(n+1): # variables Z(i) all cobasic + self.bascobas[i] = n+i + self.whichvar[n+i] = i + for i in range(n): # variables W(i+1) all basic + self.bascobas[n+1+i] = i + self.whichvar[i] = n+1+i + # determine scale factors, lcm of denominators + for j in range(n+2): + factor = 1 + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + else: + den = Mqd.M[i][j-1].denominator + # least common multiple + factor *= den // math.gcd(factor,den) + self.scalefactor[j] = factor + # fill in column j of A + for i in range(n): + if j==0: + den = Mqd.d[i].denominator + num = Mqd.d[i].numerator + elif j==n+1: # RHS + den = Mqd.q[i].denominator + num = Mqd.q[i].numerator + else: + den = Mqd.M[i][j-1].denominator + num = Mqd.M[i][j-1].numerator + self.A[i][j] = (factor//den) * num + self.determinant = -1 + return + + def __str__(self): + out = "Determinant: "+str(self.determinant) + n = self.n + tabl = columnprint.columnprint(n+3) + tabl.makeLeft(0) + tabl.sprint("var") # headers + for j in range(n+1): + tabl.sprint(self.vartoa(self.whichvar[j+n])) + tabl.sprint("RHS") + tabl.sprint("scfa") # scale factors + for j in range(n+2): + if j == n+1: # RHS + tabl.sprint(str(self.scalefactor[n+1])) + elif self.whichvar[j+n] > n: # col j is some W + tabl.sprint("1") + else: + tabl.sprint(str(self.scalefactor[self.whichvar[j+n]])) + tabl.newline() # blank line + for i in range(n): + tabl.sprint(self.vartoa(self.whichvar[i])) + for j in range(n+2): + s = str(self.A[i][j]) + if s == "0" : + s = "." # replace 0 by dot + tabl.sprint(s) + out += "\n"+ str(tabl) + out += "\n"+ "-----------------end of tableau-----------------" + return out + + def vartoa(self, v): # variable as as string w1..wn or z0..zn + if (v > self.n): + return "w"+str(v-self.n) + else: + return "z"+str(v) + + def createsol(self): # get solution from current tableau + n = self.n + for i in range(2*n+1): + row = self.bascobas[i] + if row < n: # i is a basic variable + num = self.A[row][n+1] + # value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) + # value of W(i-n): rhs[row] / (scfa[RHS]*det) + if i <= n: # computing Z(i) + num *= self.scalefactor[i] + self.solution[i] = fractions.Fraction(num, + self.determinant*self.scalefactor[n+1]) + else: # i is nonbasic + self.solution[i]=fractions.Fraction(0) + + def outsol(self): # string giving solution, after createsol() + # printout in columns to check complementarity + n = self.n + sol = columnprint.columnprint(n+2) + sol.sprint("basis=") + for i in range(n+1): + if (self.bascobas[i]0 and self.bascobas[n+i]= self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be basic") + exit(1) + return + + def assertcobasic(self, v, info): # assert that v is cobasic + if (self.bascobas[v] < self.n): + printout (info, "Cobasic variable", self.vartoa(v), + "should be cobasic") + exit(1) + return + + def docupivot(self, leave, enter): # leave, enter in VARS + self.assertbasic (leave, "docupivot") + self.assertcobasic (enter, "docupivot") + s = "leaving: " + self.vartoa(leave).ljust(5) + s += "entering: " + self.vartoa(enter) + printout (s) + return + + def raytermination(self, enter): + printout("Ray termination when trying to enter",self.vartoa(enter)) + printout (self) + printout("Current basis not an LCP solution:") + self.createsol() + printout(self.outsol()) + exit(1) + + def testtablvars(self): # msg only if error, continue + n = self.n + for i in range(2*n+1): + if self.bascobas[self.whichvar[i]] != i : + # injective suffices + for j in range(2*n+1): + if j==i: + printout ("First problem for j=",j,":") + # printout (f"{j=} {self.bascobas[j]=} {self.whichvar[j]=}") + printout (f"j={j} self.bascobas[j]={self.bascobas[j]} self.whichvar[j]={self.whichvar[j]}") + break + return + + def complement(self, v): # Z(i),W(i) are complements + n = self.n + if v == 0: + printout ("Attempt to find complement of z0") + exit(1) + if v > n: + return v-n + else: + return v+n + + # output statistics of minimum ratio test + def outstatistics(self): + n = self.n + lext = self.lextested + stats = columnprint.columnprint(n+2) + stats.makeLeft(0) + stats.sprint("lex-column") + for i in range(n+1): + stats.iprint(i) + stats.sprint("times tested") + for i in range(n+1): + stats.iprint(lext[i]) + if lext[0]>0: # otherwise never a degeneracy + stats.sprint("% of pivots") + for i in range(0,n+1): + stats.iprint(round(lext[i]*100/self.pivotcount)) + stats.sprint("avg comparisons") + for i in range(n+1): + if lext[i]>0: + x = round(self.lexcomparisons[i]*10/lext[0]) + stats.sprint(str(x/10.0)) + else: + stats.sprint("-") + printout(stats) + + # returns leave,z0leave + # leave = leaving variable in VARS, given by lexmin row, + # when enter in VARS is entering variable + # only positive entries of entering column tested. + # Boolean z0leave indicates that z0 can leave the + # basis, but the lex-minratio test is performed fully, + # so leave might not be the index of z0 + def lexminvar(self, enter): + n = self.n + A = self.A + self.assertcobasic(enter, "Lexminvar") + col = self.bascobas[enter]-n # entering tableau column + leavecand = [] # candidates(=rows) for leaving var + for i in range(n): # start with positives in entering col + if A[i][col] > 0: + leavecand.append(i) + if leavecand == []: + self.raytermination(enter) + if len(leavecand)==1: # single positive entering value + z0leave = self.bascobas[0] == leavecand[0] + ## omitted from statistics: only one possible row + ## means no min-ratio test needed for leaving variable + ## self.lextested[0] += 1 + ## self.lexcomparisons[0] += 1 + + # as long as there is more than one leaving candidate, + # perform a minimum ratio test for the columns + # j in RHS,W(1)..W(n) in the tableau. + # That test has an easy known result if the test + # column is basic, or equal to the entering variable. + j = 0 # going through j = 0..n + while len(leavecand)>1: + if j > n: # impossible, perturbed RHS should have full rank + printout("lex-minratio test failed") + exit(1) + self.lextested[j] += 1 + self.lexcomparisons[j] += len(leavecand) + if j==0: + testcol = n+1 # RHS + else: + testcol = self.bascobas[n+j]-n # tabl col of W(j) + if testcol != col: # otherwise nothing changed + if testcol >= 0: + # not a basic testcolumn: perform minimum ratio tests + newcand = [ leavecand[0] ] + # newcand contains the new candidates + for i in range(1,len(leavecand)): + # investigate remaining candidates + # compare ratios via products + tmp1 = A[newcand[0]][testcol] * A[leavecand[i]][col] + tmp2 = A[leavecand[i]][testcol] * A[newcand[0]][col] + # sgn = np.sign(tmp1 - tmp2) + # if sgn==0: + if tmp1 == tmp2 : # new ratio is the same as before + newcand.append(leavecand[i]) + elif tmp1 > tmp2: # new smaller ratio detected: reset + newcand = [ leavecand[i] ] + # else : unchanged candidates + leavecand = newcand + else: # testcol < 0: W(j) basic, eliminate its row + # from leavecand if in there, since testcol is + # the jth unit column (ratio too big) + wj = self.bascobas[j+n] + if wj in leavecand: + leavecand.remove(wj) + # end of if testcol != col + # check if z0 among the first-col leaving candidates + if j == 0: + z0leave = self.bascobas[0] in leavecand + j += 1 # end while + assert (len(leavecand)==1) + return self.whichvar[leavecand[0]], z0leave + # end of lexminvar(enter) + + # negate tableau column col + def negcol(self, col): + for i in range(self.n): + self.A[i][col] = -self.A[i][col] + + # negate tableau row. Used in pivot() + def negrow(self, row): + for j in range(self.n+2): + self.A[row][j] = -self.A[row][j] + + # leave, enter in VARS defining row, col of A + # pivot tableau on the element A[row][col] which must be nonzero + # afterwards tableau normalized with positive determinant + # and updated tableau variables + def pivot(self, leave, enter): + n = self.n + A = self.A + row = self.bascobas[leave] + col = self.bascobas[enter]-n + pivelt = A[row][col] # becomes new determinant + negpiv = pivelt < 0 + if negpiv: + pivelt = -pivelt + for i in range(n): + if i != row: + nonzero = A[i][col] != 0 + for j in range(n+2): + if j != col: + tmp1 = A[i][j] * pivelt + if nonzero: + tmp2 = A[i][col] * A[row][j] + if negpiv: + tmp1 += tmp2 + else: + tmp1 -= tmp2 + A[i][j] = tmp1 // self.determinant + # row i has been dealt with, update A[i][col] safely + if nonzero and not negpiv: + A[i][col] = -A[i][col] + # end of for i + A[row][col] = self.determinant + if negpiv: + negrow(row) + self.determinant = pivelt # by construction always positive + # update tableau variables + self.bascobas[leave] = col+n + self.whichvar[col+n] = leave + self.bascobas[enter] = row + self.whichvar[row] = enter + ###### end of pivot (leave, enter) + + def runlemke(self,*,verbose=False,lexstats=False,z0=False,silent=False): + global filehandle + # z0: printout value of z0 + # flags.maxcount = 0; + # flags.bdocupivot = 1; + # flags.binitabl = 1; + # flags.bouttabl = 0; (= verbose) + # flags.boutsol = 1; + # flags.binteract = 0; + # flags.blexstats = 0; + + if silent: + filehandle = open(outfile,'w') + n = self.n + self.pivotcount = 1 + # check if d is ok - TBC + # if (flags.binitabl) + printout ("After filltableau:") + printout(self) + + # z0 enters the basis to obtain lex-feasible solution + enter = 0 + leave, z0leave = self.lexminvar(enter) + # negate RHS + self.negcol(n+1) + # if (flags.binitabl) + if verbose: + printout("After negcol:") + printout(self) + + while True: # main loop of complementary pivoting + self.testtablvars() + if z0: # printout progress of z0 + if self.bascobas[0]0: + b = random.uniform(0, 1) + if i==1 or b==1.0 : + f = 1-b + else: + f = math.exp(math.log(1-b)/i) + x[i] = factor * (1-f) + factor *= f + i -= 1 + x[0] = factor + return x + +# round an array of probabilities to fractions with +# denominator +def roundArray(x, accuracy=10000): + n = len(x) + sum = 0 + numerator = [0]*n + pastdecimals = [0.0]*n + for i in range(n): + abig = x[i]*accuracy + num = numerator[i] = int(abig) + pastdecimals[i] = abig-num + sum += num + tobeadded = accuracy - sum + # print(tobeadded) + assert (tobeadded >=0 and tobeadded1: + numpoints = int(arglist[1]) + if len(arglist)>2: + accuracy = int(arglist[2]) + if len(arglist)>3: + a = int(arglist[3]) + if a>2 and a<11: + higherdim = a + if len(arglist)>4: + naiveplot = True + print (f"numpoints={numpoints} numpoints={numpoints} higherdim={higherdim} naiveplot={naiveplot}") + if higherdim>3: + segmentstart = (higherdim-2)//2 + print ("show positions", segmentstart,"..", + segmentstart+2,"of 0 ..", higherdim-1) + fig1, ax = plt.subplots() + ax.set_box_aspect(.866) + # plt.axis('square') + x1,y1 = maptotriangle([1,0,0]) + x2,y2 = maptotriangle([0,1,0]) + x3,y3 = maptotriangle([0,0,1]) + plt.plot ([x1,x2,x3,x1], [y1,y2,y3,y1], "black") + + roundedpoints = [] + for i in range(numpoints): + point = randInSimplex(higherdim, naiveplot) + if higherdim>3: + segmentstart = (higherdim-2)//2 + point = renormalize (point[segmentstart:segmentstart+3]) + roundedpoints.append(roundArray(point,accuracy)) + x,y = maptotriangle(point) + plt.plot([x], [y], 'g.') + for circ in roundedpoints: + x,y = maptotriangle(circ) + plt.scatter([x], [y], s=10000//accuracy, facecolors='none', + edgecolors='r') + plt.show() diff --git a/learningAgents/tuning_params/src/utils.py b/learningAgents/tuning_params/src/utils.py new file mode 100644 index 0000000..04d6d23 --- /dev/null +++ b/learningAgents/tuning_params/src/utils.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# file utilities +# tofraction utilities with global decimals + +import fractions +import numpy as np + +# global constants, mutable +# https://stackoverflow.com/questions/1977362/how-to-create-module-wide-variables-in-python +decimals = 4 +deciDenom = 10**decimals +MAXDECIMALS = 20 +# roundingwarn = False + +def setdecimals(n): + global decimals,deciDenom + if n>=0 and n<=MAXDECIMALS: + decimals = n + deciDenom = 10**decimals + else: + # if roundingwarn: + print(n,"as number of decimals not in allowed range 0 to", MAXDECIMALS) + return + +commentchars = "#%*" # lines starting with these are ignored + +# read file into list of line-strings +# truncate leading and trailing blanks +# ignore blank lines and lines starting with commentchars +def stripcomments(filename): + # http://stackoverflow.com/questions/12330522/reading-a-file-without-newlines + newlist = [] + with open(filename,'r') as temp: + temp = temp.read().splitlines() + # strip comments + for line in temp: + line = line.strip() + if line != "" and not line[0] in commentchars: + newlist.append(line) + return newlist + +# convert lines to words +def towords(lines): + words = [] + for line in lines: + l = line.split() + for w in l: + words.append(w) + return words + +# convert s to fraction +# if s contains ".": convert to decimal fraction +# (numerator deciDenom) +def tofraction(s): + if isinstance(s, str) and "." in s: + s = float(s) + if isinstance(s, float): + num = int(abs(s)*deciDenom+0.5) # round .5 away from zero + if s<0: + num = -num + return fractions.Fraction(num,deciDenom) + # any other s than a float or string containing '.': + return fractions.Fraction(s) + +# create n-vector of fractions from words[start,start+n) +def tovector(n, words, start): + vector = np.zeros( (n), dtype=fractions.Fraction) + for i in range(n): + vector[i] = tofraction(words[start+i]) + return vector + +# create (m,n)-matrix of fractions from words[start,start+m*n) +def tomatrix(m, n, words, start): + C = np.zeros( (m,n), dtype=fractions.Fraction) + k = start + for i in range(m): + for j in range(n): + C[i][j] = tofraction(words[k]) + k+=1 + return C diff --git a/learningAgents/tuning_params/trained_agents.xlsx b/learningAgents/tuning_params/trained_agents.xlsx new file mode 100644 index 0000000..e57636c Binary files /dev/null and b/learningAgents/tuning_params/trained_agents.xlsx differ diff --git a/mainGame/.ipynb_checkpoints/Play-checkpoint.ipynb b/mainGame/.ipynb_checkpoints/Play-checkpoint.ipynb new file mode 100644 index 0000000..908eb42 --- /dev/null +++ b/mainGame/.ipynb_checkpoints/Play-checkpoint.ipynb @@ -0,0 +1,1148 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from MainGame import MainGame\n", + "from environmentModel import Model, AdversaryModes" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "game = Model(totalDemand = 400, \n", + " tupleCosts = (57, 71),\n", + " totalStages = 25,\n", + " initState = [400/2,0], adversaryMode=AdversaryModes.myopic)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([200., 0.]), 0, False)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "135.5" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game.adversaryChoosePrice()" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torch.distributions import Categorical\n", + "\n", + "# Hyperparameters\n", + "def NeuralNetwork():\n", + " lr = .0009\n", + " num_actions = 10\n", + "\n", + " nn_ = 100\n", + " # 2 --> nn nn --> nn nn --> num_actions\n", + " policy = nn.Sequential(\n", + " nn.Linear(2, nn_), \n", + " nn.ReLU(),\n", + " nn.Linear(nn_,nn_),\n", + " nn.ReLU(),\n", + " nn.Linear(nn_,num_actions), \n", + " nn.Softmax(dim=0))\n", + " optim = torch.optim.Adam(policy.parameters(), lr=lr) \n", + "\n", + " return policy, optim\n" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm = ReinforceAlgorithm(game, NeuralNetwork, numberIterations=10, numberEpisodes=10, discountFactor =0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "algorithm.solver()" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "144585.33346434432" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.bestAverageRetu" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "profits = pd.DataFrame(game.profit).T\n", + "prices = pd.DataFrame(game.prices).T\n", + "demandPotential = pd.DataFrame(game.demandPotential).T" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0200.000000200.000000
1206.500000193.500000
2209.750000190.250000
3211.375000188.625000
4212.187500187.812500
5212.593750187.406250
6212.796875187.203125
7212.898438187.101562
8212.949219187.050781
9212.974609187.025391
10212.987305187.012695
11212.993652187.006348
12212.996826187.003174
13212.998413187.001587
14212.999207187.000793
15212.999603187.000397
16212.999802187.000198
17212.999901187.000099
18212.999950187.000050
19212.999975187.000025
20212.999988187.000012
21212.999994187.000006
22212.999997187.000003
23212.999998187.000002
24212.999999187.000001
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 200.000000 200.000000\n", + "1 206.500000 193.500000\n", + "2 209.750000 190.250000\n", + "3 211.375000 188.625000\n", + "4 212.187500 187.812500\n", + "5 212.593750 187.406250\n", + "6 212.796875 187.203125\n", + "7 212.898438 187.101562\n", + "8 212.949219 187.050781\n", + "9 212.974609 187.025391\n", + "10 212.987305 187.012695\n", + "11 212.993652 187.006348\n", + "12 212.996826 187.003174\n", + "13 212.998413 187.001587\n", + "14 212.999207 187.000793\n", + "15 212.999603 187.000397\n", + "16 212.999802 187.000198\n", + "17 212.999901 187.000099\n", + "18 212.999950 187.000050\n", + "19 212.999975 187.000025\n", + "20 212.999988 187.000012\n", + "21 212.999994 187.000006\n", + "22 212.999997 187.000003\n", + "23 212.999998 187.000002\n", + "24 212.999999 187.000001" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "demandPotential" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "demandPotential.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
05076.2500004160.250000
15551.5625003751.562500
25797.1406253555.140625
35921.9101563458.910156
45984.7900393411.290039
56016.3537603387.603760
66032.1665653375.791565
76040.0807043369.893204
86044.0397073366.945957
96046.0196923365.472817
106047.0098063364.736368
116047.5048933364.368174
126047.7524443364.184085
136047.8762213364.092042
146047.9381113364.046021
156047.9690553364.023010
166047.9845283364.011505
176047.9922643364.005753
186047.9961323364.002876
196047.9980663364.001438
206047.9990333364.000719
216047.9995163364.000360
226047.9997583364.000180
236047.9998793364.000090
240.0000000.000000
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 5076.250000 4160.250000\n", + "1 5551.562500 3751.562500\n", + "2 5797.140625 3555.140625\n", + "3 5921.910156 3458.910156\n", + "4 5984.790039 3411.290039\n", + "5 6016.353760 3387.603760\n", + "6 6032.166565 3375.791565\n", + "7 6040.080704 3369.893204\n", + "8 6044.039707 3366.945957\n", + "9 6046.019692 3365.472817\n", + "10 6047.009806 3364.736368\n", + "11 6047.504893 3364.368174\n", + "12 6047.752444 3364.184085\n", + "13 6047.876221 3364.092042\n", + "14 6047.938111 3364.046021\n", + "15 6047.969055 3364.023010\n", + "16 6047.984528 3364.011505\n", + "17 6047.992264 3364.005753\n", + "18 6047.996132 3364.002876\n", + "19 6047.998066 3364.001438\n", + "20 6047.999033 3364.000719\n", + "21 6047.999516 3364.000360\n", + "22 6047.999758 3364.000180\n", + "23 6047.999879 3364.000090\n", + "24 0.000000 0.000000" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 143180.333454\n", + "1 82300.333243\n", + "dtype: float64" + ] + }, + "execution_count": 160, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "profits.sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "profits.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
0122.500000135.500000
1125.750000132.250000
2127.375000130.625000
3128.187500129.812500
4128.593750129.406250
5128.796875129.203125
6128.898438129.101562
7128.949219129.050781
8128.974609129.025391
9128.987305129.012695
10128.993652129.006348
11128.996826129.003174
12128.998413129.001587
13128.999207129.000793
14128.999603129.000397
15128.999802129.000198
16128.999901129.000099
17128.999950129.000050
18128.999975129.000025
19128.999988129.000012
20128.999994129.000006
21128.999997129.000003
22128.999998129.000002
23128.999999129.000001
240.0000000.000000
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 122.500000 135.500000\n", + "1 125.750000 132.250000\n", + "2 127.375000 130.625000\n", + "3 128.187500 129.812500\n", + "4 128.593750 129.406250\n", + "5 128.796875 129.203125\n", + "6 128.898438 129.101562\n", + "7 128.949219 129.050781\n", + "8 128.974609 129.025391\n", + "9 128.987305 129.012695\n", + "10 128.993652 129.006348\n", + "11 128.996826 129.003174\n", + "12 128.998413 129.001587\n", + "13 128.999207 129.000793\n", + "14 128.999603 129.000397\n", + "15 128.999802 129.000198\n", + "16 128.999901 129.000099\n", + "17 128.999950 129.000050\n", + "18 128.999975 129.000025\n", + "19 128.999988 129.000012\n", + "20 128.999994 129.000006\n", + "21 128.999997 129.000003\n", + "22 128.999998 129.000002\n", + "23 128.999999 129.000001\n", + "24 0.000000 0.000000" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prices" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 163, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "prices.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
0141336.264102
1141033.472756
2141462.404872
3141781.825113
4141781.825113
5141781.825113
6141781.825113
7141781.825113
8141781.825113
9141781.825113
\n", + "
" + ], + "text/plain": [ + " 0\n", + "0 141336.264102\n", + "1 141033.472756\n", + "2 141462.404872\n", + "3 141781.825113\n", + "4 141781.825113\n", + "5 141781.825113\n", + "6 141781.825113\n", + "7 141781.825113\n", + "8 141781.825113\n", + "9 141781.825113" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "learning = pd.DataFrame(algorithm.returns.mean(axis = 0))\n", + "learning" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 10)" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.returns.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax=learning.plot(color='r')\n", + "for i in range(algorithm.numberIterations):\n", + " ax.plot((pd.DataFrame(algorithm.returns[i])),color='b')" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
0145155.396389
1143199.287513
2142764.333510
3143180.333454
4143180.333454
5143180.333454
6143180.333454
7143180.333454
8143180.333454
9143180.333454
\n", + "
" + ], + "text/plain": [ + " 0\n", + "0 145155.396389\n", + "1 143199.287513\n", + "2 142764.333510\n", + "3 143180.333454\n", + "4 143180.333454\n", + "5 143180.333454\n", + "6 143180.333454\n", + "7 143180.333454\n", + "8 143180.333454\n", + "9 143180.333454" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(algorithm.returns[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/mainGame/MainGame.py b/mainGame/MainGame.py new file mode 100644 index 0000000..f700b20 --- /dev/null +++ b/mainGame/MainGame.py @@ -0,0 +1,190 @@ +from enum import Enum +import torch +from torch.distributions import Categorical +import torch.nn as nn +import numpy as np +from environmentModelBase import Model, AdversaryModes +from learningBase import ReinforceAlgorithm + +totalDemand = 400 +lowCost = 57 +highCost = 71 +totalStages = 25 + + +class MainGame(): + """ + strategies play against each other and dill the matrix of payoff, then the equilibria would be computed using Lemke algorithm + """ + + _strategies = [] + _matrix_A = None + _matrix_B = None + + def __init__(self) -> None: + pass + + def reset_matrix(self): + self._matrix_A = np.zeros( + (len(self._strategies), len(self._strategies))) + self._matrix_B = np.zeros( + (len(self._strategies), len(self._strategies))) + + def fill_matrix(self): + self.reset_matrix() + n = len(self._strategies) + for low in range(n): + for high in range(n): + self.update_matrix_entry(low, high) + pass + + def update_matrix_entry(self, lowIndex, highIndex): + stratL = self._strategies[lowIndex] + stratH = self._strategies[highIndex] + stratL.reset() + stratH.reset() + [self._matrix_A[lowIndex][highIndex], self._matrix_B[lowIndex][highIndex]] = stratL.play(stratH) + pass + + def write_all_matrix(self): + print(self._matrix_A) + print(self._matrix_B) + + + def compute_equilibria(self): + pass + + +class Strategy(): + """ + strategies can be static or they can come from neural nets or Q-tables. + + """ + _type = None + _name = None + _neural_net = None + _q_table = None + _static_index = None + + def __init__(self, strategyType, name, staticIndex=None, neuralNet=None, history_num=0, qTable=None) -> None: + """ + Based on the type of strategy, the index or neuralnet or q-table should be given as input + """ + self._type = strategyType + self._name = name + self._neural_net = neuralNet + self._neural_net_history = history_num + self._static_index = staticIndex + self._q_table = qTable + self.stochastic_iters = 1 + + def reset(self): + pass + + def play(self, adversary): + """ + self is low cost and gets adversary(high cost) strategy and they play + output: tuple (payoff of low cost, payoff of high cost) + """ + if self._type == StrategyType.static and adversary._type == StrategyType.static: + return self.play_static_static(adversary._static_index) + elif self._type == StrategyType.static and adversary._type == StrategyType.neural_net: + returns = torch.zeros(2, self.stochastic_iters) + for iter in range(self.stochastic_iters): + + game = Model(totalDemand=400, + tupleCosts=(highCost, lowCost), + totalStages=25, adversaryProbs=None, advHistoryNum=adversary._neural_net_history) + algorithm = ReinforceAlgorithm( + game, neuralNet=None, numberIterations=3, numberEpisodes=1_000_000, discountFactor=1) + + algorithm.policy = adversary._neural_net.policy + returns[1][iter], returns[0][iter] = algorithm.playTrainedAgent( + AdversaryModes(self._static_index), 1) + + return [torch.mean(returns[0]), torch.mean(returns[1])] + + elif self._type == StrategyType.neural_net and adversary._type == StrategyType.static: + returns = torch.zeros(2, self.stochastic_iters) + for iter in range(self.stochastic_iters): + game = Model(totalDemand=400, + tupleCosts=(lowCost, highCost), + totalStages=25, adversaryProbs=None, advHistoryNum=self._neural_net_history) + algorithm = ReinforceAlgorithm( + game, neuralNet=None, numberIterations=3, numberEpisodes=1_000_000, discountFactor=1) + + algorithm.policy = self._neural_net.policy + returns[0][iter], returns[1][iter] = algorithm.playTrainedAgent( + AdversaryModes(adversary._static_index), 1) + + return [torch.mean(returns[0]), torch.mean(returns[1])] + + elif self._type == StrategyType.neural_net and adversary._type == StrategyType.neural_net: + returns = torch.zeros(2, self.stochastic_iters) + for iter in range(self.stochastic_iters): + advprobs = torch.zeros(len(AdversaryModes)) + advprobs[10] = 1 + game = Model(totalDemand=400, tupleCosts=(lowCost, highCost), totalStages=25, adversaryProbs=advprobs, + advHistoryNum=self._neural_net_history, advNN=adversary._neural_net) + algorithm = ReinforceAlgorithm( + game, neuralNet=None, numberIterations=3, numberEpisodes=1_000_000, discountFactor=1) + algorithm.policy = self._neural_net.policy + + state, reward, done = game.reset() + while not done: + prevState = state + normPrevState = game.normalizeState( + prevState) + probs = self._neural_net.policy(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item()) + returns[0][iter], returns[1][iter] = sum( + game.profit[0]), sum(game.profit[1]) + + return [torch.mean(returns[0]), torch.mean(returns[1])] + else: + print("play is not implemented!") + + def play_static_static(self, adversaryIndex): + """ + self is the low cost player + """ + + selfIndex = self._static_index + + lProbs = torch.zeros(len(AdversaryModes)) + lProbs[selfIndex] = 1 + + hProbs = torch.zeros(len(AdversaryModes)) + hProbs[adversaryIndex] = 1 + + lGame = Model(totalDemand=400, + tupleCosts=(highCost, lowCost), + totalStages=25, adversaryProbs=lProbs, advHistoryNum=0) + hGame = Model(totalDemand=400, + tupleCosts=(lowCost, highCost), + totalStages=25, adversaryProbs=hProbs, advHistoryNum=0) + lGame.reset() + hGame.reset() + + for i in range(totalStages): + lAction = lGame.adversaryChoosePrice() + hAction = hGame.adversaryChoosePrice() + lGame.updatePricesProfitDemand([hAction, lAction]) + hGame.updatePricesProfitDemand([lAction, hAction]) + lGame.stage += 1 + hGame.stage += 1 + + # print("\nl: ", lAction, " h: ", hAction, "\nprofits: ", hGame.profit,"\ndemand: ", hGame.demandPotential,"\nprices:",hGame.prices) + profits = np.array(hGame.profit) + returns = profits.sum(axis=1) + return returns + + +class StrategyType(Enum): + static = 0 + q_table = 1 + neural_net = 2 diff --git a/mainGame/Pre version/Play.ipynb b/mainGame/Pre version/Play.ipynb new file mode 100644 index 0000000..a19e4cb --- /dev/null +++ b/mainGame/Pre version/Play.ipynb @@ -0,0 +1,205 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from MainGame import MainGame\n", + "from MainGame import Strategy\n", + "from MainGame import StrategyType\n", + "from environmentModel import Model, AdversaryModes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "const132=Strategy(StrategyType.static,name=\"const132\",staticIndex=1)\n", + "const95=Strategy(StrategyType.static,\"const95\",staticIndex=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, 0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, 0, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, 0, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, 0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, 0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, 0, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 0, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, 0, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, 0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, 0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, 0, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 0, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, -22650.0, 0, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 11400.0, 0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, -188.5, 0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 588.5, 0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, -22650.0, -24037.5, 0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 11400.0, 11844.0, 0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, -188.5, -207.0, 0, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 588.5, 607.0, 0, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, -22650.0, -24037.5, -25425.0, 0, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 11400.0, 11844.0, 12288.0, 0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, -188.5, -207.0, -225.5, 0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 588.5, 607.0, 625.5, 0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0, 0]]\n", + "\n", + "l: 132 h: 95 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, -22650.0, -24037.5, -25425.0, -26812.5, 0], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 11400.0, 11844.0, 12288.0, 12732.0, 0]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, -188.5, -207.0, -225.5, -244.0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 588.5, 607.0, 625.5, 644.0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 0], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 0]]\n", + "\n", + "l: -93.5 h: 357.5 \n", + "profits: [[5100.0, 3712.5, 2325.0, 937.5, -450.0, -1837.5, -3225.0, -4612.5, -6000.0, -7387.5, -8775.0, -10162.5, -11550.0, -12937.5, -14325.0, -15712.5, -17100.0, -18487.5, -19875.0, -21262.5, -22650.0, -24037.5, -25425.0, -26812.5, 22650.25], [2520.0, 2964.0, 3408.0, 3852.0, 4296.0, 4740.0, 5184.0, 5628.0, 6072.0, 6516.0, 6960.0, 7404.0, 7848.0, 8292.0, 8736.0, 9180.0, 9624.0, 10068.0, 10512.0, 10956.0, 11400.0, 11844.0, 12288.0, 12732.0, 82082.25]] \n", + "demand: [[200.0, 181.5, 163.0, 144.5, 126.0, 107.5, 89.0, 70.5, 52.0, 33.5, 15.0, -3.5, -22.0, -40.5, -59.0, -77.5, -96.0, -114.5, -133.0, -151.5, -170.0, -188.5, -207.0, -225.5, -244.0], [200.0, 218.5, 237.0, 255.5, 274.0, 292.5, 311.0, 329.5, 348.0, 366.5, 385.0, 403.5, 422.0, 440.5, 459.0, 477.5, 496.0, 514.5, 533.0, 551.5, 570.0, 588.5, 607.0, 625.5, 644.0]] \n", + "prices: [[132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, -93.5], [95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 357.5]]\n", + "[-237899.75 265106.25]\n" + ] + } + ], + "source": [ + "const132.play(const95)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/mainGame/Pre version/environmentModel.py b/mainGame/Pre version/environmentModel.py new file mode 100644 index 0000000..f689859 --- /dev/null +++ b/mainGame/Pre version/environmentModel.py @@ -0,0 +1,287 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T), [0]*(self.T)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player, t): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player, self.stage) + + def const(self, player, price): # constant price strategy + """ + Adversary follows Constant strategy + """ + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return price + + def imit(self, player, firstprice): # price imitator strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return self.prices[1-player][self.stage-1] + + def fight(self, player, firstprice): # simplified fighting strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (self.totalDemand-self.costs[player] + + self.costs[1-player])/2 + + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return self.prices[player][self.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getself.demandPotential to Asp + P = self.prices[1-player][self.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (self.totalDemand+self.costs[0]+self.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + def fight_lb(self, player, firstprice): + P = self.fight(player, firstprice) + # never price less than production cost + P = max(P, self.costs[player]) + return P + + # sophisticated fighting strategy, compare fight() + # estimate *sales* of opponent as their target + + def guess(self, player, firstprice): # predictive fighting strategy + if self.stage == 0: + self.aspireDemand = [(self.totalDemand+ self.costs[1]-self.costs[0] ), (self.totalDemand+ self.costs[0]-self.costs[1] )] # aspiration level + self.aspirePrice = (self.totalDemand+self.costs[0]+self.costs[1])/4 + self.saleGuess= [self.aspireDemand[0]-self.aspirePrice,self.aspireDemand[1]-self.aspirePrice ] # first guess opponent sales as in monopoly ( sale= demand-price) + + return firstprice + + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + + + + D = self.demandPotential[player][self.stage] + Asp = self.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = self.monopolyPrice(player, self.stage) + pcurrent = self.prices[player][self.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = self.demandPotential[1 - + player][self.stage-1] - self.prices[1-player][self.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * self.saleGuess[player] + (1-alpha)*prevsales + # update + self.saleGuess[player] = newsalesguess + guessoppPrice = self.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, adversaryProbs, advHistoryNum=3) -> None: + super().__init__(totalDemand, tupleCosts, totalStages) + + self.rewardFunction = self.profits + + # [stage, agent's demand potential, agent's last price, history of adversary's prices] + self.initState = [ + 0, totalDemand/2, ((totalDemand/2) + tupleCosts[0])/2] + ([0]*advHistoryNum) + self.episodesMemory = list() + self.done = False + self.adversaryProbs = adversaryProbs + # number of previous adversary's action we consider in the state + self.advHistoryNum = advHistoryNum + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return torch.tensor(self.initState, dtype=torch.float32), reward, self.done + + def resetAdversary(self): + adversaryDist = Categorical(self.adversaryProbs) + adversaryInd = (adversaryDist.sample()).item() + self.adversaryMode = AdversaryModes(adversaryInd) + # print(self.adversaryMode) + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + if self.adversaryMode == AdversaryModes.constant_132: + return self.const(player=1, price=132) + elif self.adversaryMode == AdversaryModes.constant_95: + return self.const(player=1, price=95) + elif self.adversaryMode == AdversaryModes.imitation_128: + return self.imit(player=1, firstprice=128) + elif self.adversaryMode == AdversaryModes.imitation_132: + return self.imit(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_100: + return self.fight(player=1, firstprice=100) + elif self.adversaryMode == AdversaryModes.fight_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_lb_125: + return self.fight_lb(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_132: + return self.fight(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_lb_132: + return self.fight_lb(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.guess_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.guess_132: + return self.fight(player=1, firstprice=132) + else: + return self.myopic(player=1) + + def step(self, state, action): + """ + Transition Function. + Parameters: + - action: Price + - state: tupple in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + adversaryAction = self.adversaryChoosePrice() + myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [self.myopic() - action, adversaryAction]) + + done = (self.stage == self.T-1) + + + if not done: + newState = [self.stage+1, self.demandPotential[0] + [self.stage + 1], self.prices[0][self.stage]] + else: + newState = [self.stage+1, 0, self.prices[0] + [self.stage]] + + if(self.advHistoryNum>0): + advHistory = [0]*self.advHistoryNum + j = self.advHistoryNum-1 + for i in range(self.stage, max(-1, self.stage-self.advHistoryNum), -1): + advHistory[j] = self.prices[1][i] + j -= 1 + + newState+= advHistory + + + reward = self.rewardFunction() + self.stage = self.stage + 1 + + return torch.tensor(newState, dtype=torch.float32), reward, done + + +class AdversaryModes(Enum): + myopic = 0 + constant_132 = 1 + constant_95 = 2 + imitation_132 = 3 + imitation_128 = 4 + fight_132 = 5 + fight_lb_132 = 6 + fight_125 = 7 + fight_lb_125 = 8 + fight_100 = 9 + guess_132 = 10 + guess_125 = 11 diff --git a/mainGame/Pre version/learningActorCritic.py b/mainGame/Pre version/learningActorCritic.py new file mode 100644 index 0000000..610c29e --- /dev/null +++ b/mainGame/Pre version/learningActorCritic.py @@ -0,0 +1,295 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModel as em +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +from openpyxl import load_workbook +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + + def runBestPolicy(self): + """ + Run best policy from the Reinforcement Learning Algorithm. It needs to be used after training. + """ + + state, reward, done = self.env.reset() + returns = 0 + while not done: + prev_state = state + probs = self.bestPolicy(prev_state) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = self.env.step(prev_state, action.item()) + returns = returns + reward + + return returns + + def write_to_excel(self, new_row): + """ + row includes: # h/l(cost) ep adversary return advReturn loss actor critic lr gamma hist clc actions nn_name total_stages num_actions return_against_adversaries + """ + + path = 'results.xlsx' + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + + self.returns = [] + self.loss = [] + # self.returns = np.zeros((numberIterations, numberEpisodes)) + # self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + def saveResult(self): + pass + + def solver(self, print_step=10_000, prob_break_limit_ln=-0.001, clc=0.1): + """ + Method that performs Monte Carlo Policy Gradient algorithm. + """ + + for iteration in range(self.numberIterations): + self.resetPolicyNet() + + self.returns.append([]) + self.loss.append([]) + + for episode in range(self.numberEpisodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst = [] + value_lst = [] + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs, value = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + value_lst.append(value) + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*30) + # print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] for item in episodeMemory]) + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + discReturns = (self.returnsComputation( + rewards, episodeMemory)) + + discValues = (self.returnsComputation( + value_lst, episodeMemory)) + + actor_loss = - (torch.sum((discReturns-(discValues).detach())*action_logprobs)) / \ + len(episodeMemory) + critic_loss = torch.sum( + torch.pow(discValues-discReturns, 2))/len(episodeMemory) + + loss = actor_loss + clc*critic_loss + + shouldBreak = torch.all((action_logprobs > + prob_break_limit_ln)) + + if (episode % print_step == 0) or shouldBreak: + print("-"*50) + print(episode, " adversary: ", self.env.adversaryMode) + print(" actions: ", actions) + + print("loss= ", loss, " , actor= ", actor_loss, + " , critic= ", critic_loss, " , return= ", returns) + # print("states= ", states) + print("probs of actions: ", torch.exp(action_logprobs)) + print("discounted returns: ", discReturns) + print("discounted values: ", discValues) + print("stage values: ", torch.cat( + value_lst).detach().numpy()) + # print("shouldBreak:", shouldBreak.item()) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + + self.optim.zero_grad() + + loss.backward() + self.optim.step() + + # sum of the our player's rewards rounds 0-25 + # self.returns[iteration][episode] = returns + # self.loss[iteration][episode] = loss + self.returns[iteration].append(returns) + self.loss[iteration].append(loss.item()) + + # all probs >0.999 means coverged? break + if shouldBreak: + # self.returns[iteration] = self.returns[iteration][0:episode] + # self.loss[iteration] = self.loss[iteration][0:episode] + break + + # averageRetu = ( + # (self.returns[iteration]).sum())/(self.numberEpisodes) + # if (self.bestPolicy is None) or (averageRetu > self.bestAverageRetu): + # self.bestPolicy = self.policy + # self.bestAverageRetu = averageRetu + + advModeNames = "" + for i in range(len(self.env.adversaryProbs)): + if self.env.adversaryProbs[i] != 0: + tmp = "{:.1f}".format(self.env.adversaryProbs[i]) + advModeNames += f"{(em.AdversaryModes(i)).name}-{tmp}-" + + name = f"ep {len(self.returns[iteration])}, {advModeNames}, {self.env.advHistoryNum} hist, {self.neuralNetwork.lr} lr" + self.neuralNetwork.save(name=name) + + # h/l(cost) ep adversary return advReturn loss actor critic lr gamma hist clc actions nn_name total_stages num_actions return_against adversaries + new_row = [('h' if self.env.costs[0] > self.env.costs[1] else 'l'), len(self.returns[iteration]), str(self.env.adversaryProbs), returns, sum(self.env.profit[1]), loss.item(), actor_loss.item( + ), critic_loss.item(), self.neuralNetwork.lr, self.gamma, self.env.advHistoryNum, clc, str(actions), name, self.env.T, self.neuralNetwork.num_actions] + + for advmode in em.AdversaryModes: + new_row.append( + np.array(self.playTrainedAgent(advmode, 10)).mean()) + + self.write_to_excel(new_row) + + plt.scatter( + range(len(self.returns[iteration])), self.returns[iteration]) + plt.show() + + def returnsComputation(self, rewards, episodeMemory): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + output:tensor + + """ + + discRewards = torch.zeros(len(episodeMemory)) + discRewards[-1] = rewards[-1] + for i in range(len(episodeMemory)-2, -1, -1): + discRewards[i] = rewards[i] + self.gamma*discRewards[i+1] + return discRewards + + # return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + def normalizeState(self, state): + normalized = [0]*len(state) + normalized[0] = (state[0]+1)/(self.env.T) + for i in range(1, len(state)): + normalized[i] = state[i]/(self.env.totalDemand) + return torch.tensor(normalized) + # return state + + def playTrainedAgent(self, advMode, iterNum): + advProbs = torch.zeros(len(em.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = em.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = np.zeros(iterNum) + + # self.policy, _ = self.neuralNetwork.reset() + # self.neuralNetwork.load(NN_name) + + for episode in range(iterNum): + + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.normalizeState(prevState) + probs, _ = self.policy(normPrevState) + distAction = Categorical(probs) + + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*30) + # print("probs= ", probs) + + state, reward, done = game.step( + prevState, action.item()) + retu += reward + + # prevState = state + # normPrevState = self.normalizeState(prevState) + # probs, _ = self.policy(normPrevState) + # distAction = Categorical(probs) + # action = distAction.sample() + + # state, reward, done = game.step( + # prevState, action.item()) + # retu = retu + reward + # episodeMemory.append((normPrevState, action, reward)) + + # states = torch.stack([item[0] for item in episodeMemory]) + # actions = torch.tensor([item[1] for item in episodeMemory]) + # rewards = torch.tensor([item[2] for item in episodeMemory]) + + # print(f"iteration {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[episode] = retu + + print('returns', retu) + + print("profits sum: ", sum(game.profit[0]), sum(game.profit[1])) + + # plt.plot(returns) + # plt.show() + + return returns diff --git a/mainGame/Pre version/neuralNetwork.py b/mainGame/Pre version/neuralNetwork.py new file mode 100644 index 0000000..ee56937 --- /dev/null +++ b/mainGame/Pre version/neuralNetwork.py @@ -0,0 +1,81 @@ +import torch +import torch.nn as nn +from torch.nn import functional as F +import torch.multiprocessing as mp + + +class NNBase(): + + """ + Defines a three layer Neural Network that acts as the agent. The output is a tensor of probablities over actions. + + reset() function should be overwritten to define the policy and optimizer + """ + + save_path_format = './NNs/{name}.pt' + + def __init__(self, lr=.000001, num_input=3, num_actions=50, nn_dim=100) -> None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + self.nn_dim = nn_dim + + self.nn_name = f"nn, lr={self.lr}, actions={self.num_actions}" + + def reset(self): + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_dim), + nn.ReLU(), + nn.Linear(self.nn_dim, self.nn_dim), + nn.ReLU(), + nn.Linear(self.nn_dim, self.num_actions), + nn.Softmax(dim=0)) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim + + def save(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + return torch.save(self.policy.state_dict(), self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + self.policy.load_state_dict( + torch.load(self.save_path_format.format(name=self.nn_name))) + print("\n load NN:",name) + + +# class PlicyGradient(): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# return + + +class ActorCritic(nn.Module): + def __init__(self, num_input=3, num_actions=50, nn_dim=100): + super(ActorCritic, self).__init__() + self.l1 = nn.Linear(num_input,nn_dim) + self.l2 = nn.Linear(nn_dim,nn_dim) + self.actor_lin1 = nn.Linear(nn_dim,num_actions) + self.l3 = nn.Linear(nn_dim,nn_dim) + self.critic_lin1 = nn.Linear(nn_dim,1) + def forward(self,x): + #x = F.normalize(x,dim=0) + y = F.relu(self.l1(x)) + y = F.relu(self.l2(y)) + actor = F.softmax(self.actor_lin1(y),dim=0) #C + c = F.elu(self.l3(y.detach())) + critic = F.elu(self.critic_lin1(c)) #D + return actor, critic #E + +class NeuralNetwork(NNBase): + def __init__(self,lr=.000001, num_input=3, num_actions=50, nn_dim=100): + super().__init__(lr=lr, num_input=num_input, num_actions=num_actions, nn_dim=nn_dim) + + def reset(self): + self.policy = ActorCritic(num_input=self.num_input, num_actions=self.num_actions, nn_dim=self.nn_dim) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + + return self.policy, self.optim diff --git a/mainGame/__pycache__/MainGame.cpython-39.pyc b/mainGame/__pycache__/MainGame.cpython-39.pyc new file mode 100644 index 0000000..0dadc18 Binary files /dev/null and b/mainGame/__pycache__/MainGame.cpython-39.pyc differ diff --git a/mainGame/__pycache__/environmentModel.cpython-39.pyc b/mainGame/__pycache__/environmentModel.cpython-39.pyc new file mode 100644 index 0000000..1224aa5 Binary files /dev/null and b/mainGame/__pycache__/environmentModel.cpython-39.pyc differ diff --git a/mainGame/environmentModelBase.py b/mainGame/environmentModelBase.py new file mode 100644 index 0000000..c973503 --- /dev/null +++ b/mainGame/environmentModelBase.py @@ -0,0 +1,354 @@ +# Francisco, Sahar, Edward +# Contains Game Class and Model of the Game Class. + +from enum import Enum +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys # Not used? +import numpy as np # numerical python +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class DemandPotentialGame(): + """ + Fully defines demand Potential Game. It contains game rules, memory and agents strategies. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages,actionStep=1) -> None: + self.totalDemand = totalDemand + self.costs = tupleCosts + self.T = totalStages + # first index is always player + self.demandPotential = None # two lists for the two players + self.prices = None # prices over T rounds + self.profit = None # profit in each of T rounds + self.stage = None + self.actionStep=actionStep + + def resetGame(self): + """ + Method resets game memory: Demand Potential, prices, profits + """ + self.demandPotential = [ + [0]*(self.T+1), [0]*(self.T+1)] # two lists for the two players + self.prices = [[0]*self.T, [0]*self.T] # prices over T rounds + self.profit = [[0]*self.T, [0]*self.T] # profit in each of T rounds + self.demandPotential[0][0] = self.totalDemand / \ + 2 # initialize first round 0 + self.demandPotential[1][0] = self.totalDemand/2 + + self.our_target_demand=((self.totalDemand+ self.costs[1]-self.costs[0])/2) #target demand + self.target_price=(self.our_target_demand+self.costs[0])/2 + + def profits(self, player=0): + """ + Computes profits. Player 0 is the learning agent. + """ + return self.profit[player][self.stage] + + def updatePricesProfitDemand(self, pricePair): + """ + Updates Prices, Profit and Demand Potential Memory. + Parameters. + pricePair: Pair of prices from the Learning agent and adversary. + """ + + for player in [0, 1]: + price = pricePair[player] + self.prices[player][self.stage] = price + self.profit[player][self.stage] = ( + self.demandPotential[player][self.stage] - price)*(price - self.costs[player]) + if self.stage < self.T-1: + self.demandPotential[player][self.stage + 1] = \ + self.demandPotential[player][self.stage] + \ + (pricePair[1-player] - price)/2 + + def monopolyPrice(self, player, t): # myopic monopoly price + """ + Computes Monopoly prices. + """ + return (self.demandPotential[player][self.stage] + self.costs[player])/2 + + def myopic(self, player=0): + """ + Adversary follows Myopic strategy + """ + return self.monopolyPrice(player, self.stage) + + def const(self, player, price): # constant price strategy + """ + Adversary follows Constant strategy + """ + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return price + + def imit(self, player, firstprice): # price imitator strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + return self.prices[1-player][self.stage-1] + + def fight(self, player, firstprice): # simplified fighting strategy + if self.stage == 0: + return firstprice + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + # aspire = [ 207, 193 ] # aspiration level for demand potential + aspire = [0, 0] + for i in range(2): + aspire[i] = (self.totalDemand-self.costs[player] + + self.costs[1-player])/2 + + D = self.demandPotential[player][self.stage] + Asp = aspire[player] + if D >= Asp: # keep price; DANGER: price will never rise + return self.prices[player][self.stage-1] + # adjust to get to aspiration level using previous + # opponent price; own price has to be reduced by twice + # the negative amount D - Asp to getself.demandPotential to Asp + P = self.prices[1-player][self.stage-1] + 2*(D - Asp) + # never price to high because even 125 gives good profits + # P = min(P, 125) + aspire_price = (self.totalDemand+self.costs[0]+self.costs[1])/4 + P = min(P, int(0.95*aspire_price)) + + return P + + def fight_lb(self, player, firstprice): + P = self.fight(player, firstprice) + # never price less than production cost + P = max(P, self.costs[player]) + return P + + # sophisticated fighting strategy, compare fight() + # estimate *sales* of opponent as their target + + def guess(self, player, firstprice): # predictive fighting strategy + if self.stage == 0: + self.aspireDemand = [(self.totalDemand+ self.costs[1]-self.costs[0] ), (self.totalDemand+ self.costs[0]-self.costs[1] )] # aspiration level + self.aspirePrice = (self.totalDemand+self.costs[0]+self.costs[1])/4 + self.saleGuess= [self.aspireDemand[0]-self.aspirePrice,self.aspireDemand[1]-self.aspirePrice ] # first guess opponent sales as in monopoly ( sale= demand-price) + + return firstprice + + if self.stage == self.T-1: + return self.monopolyPrice(player, self.stage) + + + + D = self.demandPotential[player][self.stage] + Asp = self.aspireDemand[player] + + if D >= Asp: # keep price, but go slightly towards monopoly if good + pmono = self.monopolyPrice(player, self.stage) + pcurrent = self.prices[player][self.stage-1] + if pcurrent > pmono: # shouldn't happen + return pmono + elif pcurrent > pmono-7: # no change + return pcurrent + # current low price at 60%, be accommodating towards "collusion" + return .6 * pcurrent + .4 * (pmono-7) + + # guess current *opponent price* from previous sales + prevsales = self.demandPotential[1 - + player][self.stage-1] - self.prices[1-player][self.stage-1] + # adjust with weight alpha from previous guess + alpha = .5 + newsalesguess = alpha * self.saleGuess[player] + (1-alpha)*prevsales + # update + self.saleGuess[player] = newsalesguess + guessoppPrice = self.totalDemand - D - newsalesguess + P = guessoppPrice + 2*(D - Asp) + + if player == 0: + P = min(P, 125) + if player == 1: + P = min(P, 130) + return P + + +class Model(DemandPotentialGame): + """ + Defines the Problem's Model. It is assumed a Markov Decision Process is defined. The class is a Child from the Demand Potential Game Class. + The reason: Model is a conceptualization of the Game. + """ + + def __init__(self, totalDemand, tupleCosts, totalStages, adversaryProbs, advHistoryNum=3, advNN=None,actionStep=1) -> None: + super().__init__(totalDemand, tupleCosts, totalStages,actionStep) + """ + if the adversary is NN then advNN should be set, action step is assumed to be the same as self + """ + self.rewardFunction = self.profits + + # [stage, agent's demand potential, agent's last price, history of adversary's prices] + self.episodesMemory = list() + self.done = False + self.adversaryProbs = adversaryProbs + # number of previous adversary's action we consider in the state + self.advHistoryNum = advHistoryNum + + self.advNN=advNN + + def reset(self): + """ + Reset Model Instantiation. + """ + reward = 0 + self.stage = 0 + self.done = False + self.resetGame() + self.resetAdversary() + return self.getState(0), reward, self.done + + def resetAdversary(self): + adversaryDist = Categorical(self.adversaryProbs) + adversaryInd = (adversaryDist.sample()).item() + self.adversaryMode = AdversaryModes(adversaryInd) + # print(self.adversaryMode) + + def adversaryChoosePrice(self): + """ + Strategy followed by the adversary. + """ + + if self.adversaryMode == AdversaryModes.constant_132: + return self.const(player=1, price=132) + elif self.adversaryMode == AdversaryModes.constant_95: + return self.const(player=1, price=95) + elif self.adversaryMode == AdversaryModes.imitation_128: + return self.imit(player=1, firstprice=128) + elif self.adversaryMode == AdversaryModes.imitation_132: + return self.imit(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_100: + return self.fight(player=1, firstprice=100) + elif self.adversaryMode == AdversaryModes.fight_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_lb_125: + return self.fight_lb(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.fight_132: + return self.fight(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.fight_lb_132: + return self.fight_lb(player=1, firstprice=132) + elif self.adversaryMode == AdversaryModes.guess_125: + return self.fight(player=1, firstprice=125) + elif self.adversaryMode == AdversaryModes.guess_132: + return self.fight(player=1, firstprice=132) + else: + return self.myopic(player=1) + + def step(self, state, action,mode=1): + """ + Transition Function. + Parameters: + - action: Price + - state: list in the latest stage (stage ,Demand Potential, Agent's Price, Adversary's price hisotry) + """ + if self.advNN is None: + adversaryAction = self.adversaryChoosePrice() + # myopicPrice = self.myopic() + self.updatePricesProfitDemand( + [self.myopic() - (self.actionStep* action), adversaryAction]) + else: + advState= self.getState(self.stage,player=1) + normAdvState=self.normalizeState(advState,mode=mode) + probs= self.advNN.policy(normAdvState) + distAction = Categorical(probs) + advAction = distAction.sample() + self.updatePricesProfitDemand( + [self.myopic() - (self.actionStep* action), self.myopic(player=1)-(self.actionStep*advAction)]) + + + done = (self.stage == self.T-1) + + reward = self.rewardFunction() + self.stage +=1 + + return self.getState(self.stage), reward, done + + def getState(self,stage,player=0): + #[one-hote encoding of stage, our demand, our price, adversary's price history] + # player=1 is the state for adversary, when we play against another NN, so advNN must be set + + stageEncode=[0]*self.T + if stage0): + advHistory = [0]*self.advHistoryNum + j = self.advHistoryNum-1 + for i in range(stage-1, max(-1, stage-1-self.advHistoryNum), -1): + advHistory[j] = self.prices[1-player][i] + j -= 1 + state+=advHistory + elif(player==1 and self.advNN.adv_hist>0): + advHistory = [0]*self.advNN.adv_hist + j = self.advNN.adv_hist-1 + for i in range(stage-1, max(-1, stage-1-self.advNN.adv_hist), -1): + advHistory[j] = self.prices[1-player][i] + j -= 1 + state+=advHistory + + return torch.tensor(state, dtype=torch.float32) + def normalizeState(self, state, mode=1): + # [stage one-hot encoded, agent's demand potential, agent's last price, history of adversary's prices] + + if mode == 1: + normalized = [0]*len(state) + for i in range(self.T): + normalized[i] = state[i] + for i in range(self.T, len(state)): + normalized[i] = state[i]/(self.totalDemand) + return torch.tensor(normalized) + elif mode == 2: + + normalized = torch.zeros(len(state)) + for i in range(self.T): + normalized[i] = state[i] + + normalized[self.T] = -self.our_target_demand + \ + state[self.T] # demand + + for i in range(self.T+1, len(state)): + normalized[i] = -(self.target_price) + \ + state[i] # both players' prices + return normalized + elif mode == 3: + return nn.functional.normalize(state, p=2.0, dim=0) + elif mode == 4: + normalized = [0]*len(state) + for i in range(self.T): + normalized[i] = state[i] + for i in range(self.T, len(state)): + normalized[i] = (state[i]-self.costs[0]) / \ + (self.totalDemand) + return torch.tensor(normalized) + + +class AdversaryModes(Enum): + myopic = 0 + constant_132 = 1 + constant_95 = 2 + imitation_132 = 3 + imitation_128 = 4 + fight_132 = 5 + fight_lb_132 = 6 + fight_125 = 7 + fight_lb_125 = 8 + fight_100 = 9 + guess_132 = 10 + guess_125 = 11 + diff --git a/mainGame/learningBase.py b/mainGame/learningBase.py new file mode 100644 index 0000000..5f09191 --- /dev/null +++ b/mainGame/learningBase.py @@ -0,0 +1,309 @@ +# Francisco, Sahar, Edward +# ReinforceAlgorithm Class: Solver. +import environmentModelBase as model +import torch +import torch.nn as nn +from torch.distributions import Categorical +import sys +import numpy as np # numerical python +import pandas as pd +from matplotlib import pyplot as plt +from openpyxl import load_workbook +import time +# printoptions: output limited to 2 digits after decimal point +np.set_printoptions(precision=2, suppress=False) + + +class Solver(): + + def __init__(self, numberEpisodes, Model, discountFactor, numberIterations): + self.numberEpisodes = numberEpisodes + self.env = Model + self.gamma = discountFactor + self.numberIterations = numberIterations + self.bestPolicy = None + self.probBreakLn = -0.001 + + + def write_to_excel(self, new_row): + """ + row includes: # ep adversary return advReturn loss actor critic lr gamma hist clc actions probs nn_name total_stages num_actions return_against_adversaries + """ + + path = 'results.xlsx' + wb = load_workbook(path) + sheet = wb.active + row = 2 + col = 1 + sheet.insert_rows(idx=row) + + for i in range(len(new_row)): + sheet.cell(row=row, column=col+i).value = new_row[i] + wb.save(path) + # print(new_row) + + +class ReinforceAlgorithm(Solver): + """ + Model Solver. + """ + + def __init__(self, Model, neuralNet, numberIterations, numberEpisodes, discountFactor) -> None: + super().__init__(numberEpisodes, Model, discountFactor, numberIterations) + + self.env.adversaryReturns = np.zeros(numberEpisodes) + self.neuralNetwork = neuralNet + self.policy = None + self.optim = None + self.bestAverageRetu = 0 + + self.returns = [] + self.loss = [] + # self.returns = np.zeros((numberIterations, numberEpisodes)) + # self.loss = np.zeros((numberIterations, numberEpisodes)) + + def resetPolicyNet(self): + """ + Reset Policy Neural Network. + """ + self.policy, self.optim = self.neuralNetwork.reset() + + # def saveResult(self): + # pass + + def returnsComputation(self, rewards, episodeMemory=None): + """ + Method computes vector of returns for every stage. The returns are the cumulative rewards from that stage. + output:tensor + + """ + + discRewards = torch.zeros(len(rewards)) + discRewards[-1] = rewards[-1] + for i in range(len(rewards)-2, -1, -1): + discRewards[i] = rewards[i] + self.gamma*discRewards[i+1] + return discRewards + + # return torch.tensor([torch.sum(rewards[i:] * (self.gamma ** torch.arange(0, (len(episodeMemory)-i)))) for i in range(len(episodeMemory))]) + + + + def solver(self, print_step=50_000, options=[1, 10000, 1, 1], converge_break=False): + self.returns = [] + self.loss = [] + + fig, axs = plt.subplots(self.numberIterations, 2, figsize=(15, 6*self.numberIterations)) + + for iter in range(self.numberIterations): + + self.resetPolicyNet() + self.returns.append([]) + self.loss.append([]) + + for stage in range(self.env.T-1, -1, -1): + self.learn_stage_onwards(iter,stage=stage, episodes=int(self.numberEpisodes/self.env.T), print_step=print_step, options=options, + prob_break_limit_ln=(self.probBreakLn if converge_break else None), write_save=True if stage==0 else False) + + axs[iter][0].scatter(range(len(self.returns[iter])), self.returns[iter]) + axs[iter][1].scatter(range(len(self.loss[iter])), self.loss[iter]) + + plt.show() + + + + + def learn_stage_onwards(self,iter,stage, episodes, print_step=10_000, prob_break_limit_ln=None, options=[1, 10000, 1, 2], lr=None, just_stage=False, write_save=False): + """ + Method that just learns the actions of stages after the input stage. + + """ + if self.policy == None: + self.resetPolicyNet() + + if lr is not None: + self.optim.lr = lr + + + for episode in range(episodes): + + episodeMemory = list() + state, reward, done = self.env.reset() + returns = 0 + probs_lst = [] + while not done: + prevState = state + normPrevState = self.env.normalizeState(prevState, mode=options[0]) + probs = self.policy(normPrevState) + distAction = Categorical(probs) + probs_lst.append(probs) + + action = distAction.sample() + + # if episode % 1000 == 0: + # print("-"*60) + # print("probs= ", probs) + + state, reward, done = self.env.step( + prevState, action.item()) + returns = returns + reward + episodeMemory.append((normPrevState, action, reward)) + + if episode == 0: + probs_lst_pre = probs_lst + + states = torch.stack([item[0] for item in episodeMemory]) + actions = torch.tensor([item[1] for item in episodeMemory]) + rewards = torch.tensor([item[2] + for item in episodeMemory])/options[1] + + action_probs = torch.stack(probs_lst) + action_dists = Categorical(action_probs) + + action_logprobs = action_dists.log_prob(actions) + + + + actionsLogProbs = action_logprobs[stage:] + discRewards = self.returnsComputation(rewards=rewards) + baseRewards = self.computeBase( + self.env.prices[1], initDemand=self.env.demandPotential[0][stage], startStage=stage)/options[1] + baseDiscReturns = discRewards-baseRewards + finalReturns = baseDiscReturns[stage:] + + if just_stage: + loss = -baseDiscReturns[stage]*action_logprobs[stage] + else: + loss = -(torch.sum(finalReturns*actionsLogProbs)) + + + shouldBreak = False + + if prob_break_limit_ln is not None and action_logprobs[stage] > prob_break_limit_ln: + shouldBreak = True + + if (episode % print_step == (print_step-1)) or shouldBreak: + print("-"*40) + + + print("iter ",iter," stage ",stage," ep ",episode, " adversary: ", self.env.adversaryMode) + print(" actions: ", actions) + + print("loss= ", loss, " , base rewards=", + baseRewards, "return= ", returns) + # print("states= ", states) + print("probs of actions: ", torch.exp( + action_logprobs)) + # print("action_logprobs: ", action_logprobs) + # print("probs=", probs_lst) + # print("discounted returns: ", baseDiscReturns) + print("rewards: ", rewards) + print("finalReturns: ", finalReturns) + + # print("nn 1st layer",self.policy[0].weight) + # print("nn 2nd layer",self.policy[2].weight) + # print("shouldBreak:", shouldBreak.item()) + # print("actionProbsDist",action_probs) + # print("action_dists",action_dists) + # print("action_logprobs",action_logprobs) + + probs_lst_pre = probs_lst + + self.policy.zero_grad() + loss.backward() + self.optim.step() + + # if episode != 0: + # self.meanStageValue = ( + # (self.meanStageValue*episode)+rewards)/(episode+1) + + # sum of the our player's rewards rounds 0-25 + # self.returns[iteration][episode] = returns + # self.loss[iteration][episode] = loss + self.returns[iter].append(returns) + self.loss[iter].append(loss.item()) + + # all probs >0.999 means coverged? break + if shouldBreak: + # self.returns[iteration] = self.returns[iteration][0:episode] + # self.loss[iteration] = self.loss[iteration][0:episode] + break + if write_save: + # advModeNames = "" + # for i in range(len(self.env.adversaryProbs)): + # if self.env.adversaryProbs[i] != 0: + # tmp = "{:.1f}".format(self.env.adversaryProbs[i]) + # advModeNames += f"{(model.AdversaryModes(i)).name}-{tmp}-" + + name = f"{self.env.advHistoryNum},[{self.neuralNetwork.lr},{self.gamma}]{str(options)},{int(time.time())}" + + # self.name = f"{[self.neuralNetwork.lr, self.gamma,clc]}-stage {stage}-{int(time.time())}" + self.neuralNetwork.save(name=name) + print(name, "saved") + # ep adversary return advReturn loss lr gamma hist actions probs nn_name total_stages num_actions return_against_adversaries + new_row = [len(self.returns[iter]), str(self.env.adversaryProbs), returns, sum(self.env.profit[1]), loss.item(), self.neuralNetwork.lr, self.gamma, self.env.advHistoryNum, str(actions), str((torch.exp(action_logprobs)).detach().numpy()), name, self.env.T, self.neuralNetwork.num_actions] + + for advmode in model.AdversaryModes: + new_row.append(np.array((self.playTrainedAgent(advmode,10))[0]).mean()) + + self.write_to_excel(new_row) + + + + + def computeBase(self, advPrices, startStage=0, initDemand=None): + """ + discounted rewards when we play myopic against the adversary + + """ + if initDemand is None: + initDemand = (self.env.getState(stage=0))[self.env.T] + profit = torch.zeros(self.env.T) + demand = initDemand + for i in range(startStage, self.env.T): + price = (demand + self.env.costs[0])/2 + + profit[i] = (demand-price)*(price-self.env.costs[0]) + demand += (advPrices[i]-price)/2 + return self.returnsComputation(rewards=profit) + + # def myopic_price(demand,cost): + # return (demand + cost)/2 + + def playTrainedAgent(self, advMode, iterNum,options=[1, 10000, 1, 1]): + advProbs = torch.zeros(len(model.AdversaryModes)) + advProbs[int(advMode.value)] = 1 + game = model.Model(totalDemand=self.env.totalDemand, + tupleCosts=self.env.costs, + totalStages=self.env.T, advHistoryNum=self.env.advHistoryNum, adversaryProbs=advProbs) + returns = torch.zeros(2,iterNum) + for episode in range(iterNum): + + episodeMemory = list() + state, reward, done = game.reset() + retu = 0 + + while not done: + prevState = state + normPrevState = self.env.normalizeState(prevState,mode=options[0]) + probs= self.policy(normPrevState) + distAction = Categorical(probs) + action = distAction.sample() + + state, reward, done = game.step( + prevState, action.item(),mode=options[0]) + retu = retu + reward + # episodeMemory.append((normPrevState, action, reward)) + + # states = torch.stack([item[0] for item in episodeMemory]) + # actions = torch.tensor([item[1] for item in episodeMemory]) + # rewards = torch.tensor([item[2] for item in episodeMemory]) + + # print(f"iteration {episode} return= {retu} \n\t actions: {actions}") + + # sum of the our player's rewards rounds 0-25 + returns[0][episode], returns[1][episode] = sum(game.profit[0]), sum(game.profit[1]) + + return returns + + # plt.plot(returns) + # plt.show() diff --git a/mainGame/neuralNetworkSimple.py b/mainGame/neuralNetworkSimple.py new file mode 100644 index 0000000..008715e --- /dev/null +++ b/mainGame/neuralNetworkSimple.py @@ -0,0 +1,90 @@ +import torch +import torch.nn as nn +from torch.nn import functional as F +import torch.multiprocessing as mp + + +class NNBase(): + + """ + Defines a three layer Neural Network that acts as the agent. The output is a tensor of probablities over actions. + + reset() function should be overwritten to define the policy and optimizer + """ + + save_path_format = './NNs/{name}.pt' + + def __init__(self, lr=.000001, num_input=3, num_actions=50, nn_dim=512,adv_hist=0) -> None: + + self.lr = lr + self.num_input = num_input + self.num_actions = num_actions + self.nn_dim = nn_dim + self.adv_hist = adv_hist + + self.nn_name = f"nn, lr={self.lr}, actions={self.num_actions}" + + def reset(self): + + self.policy = nn.Sequential( + nn.Linear(self.num_input, self.nn_dim), + nn.ReLU(), + # nn.Linear(self.nn_dim, self.nn_dim), + # nn.ReLU(), + nn.Linear(self.nn_dim, self.num_actions), + nn.Softmax(dim=0)) + + self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + # print(self.policy[0].weight) + # print(self.policy[2].weight) + print("policy reset") + return self.policy, self.optim + + def save(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + print("policy saved!") + return torch.save(self.policy.state_dict(), self.save_path_format.format(name=self.nn_name)) + + def load(self, name=None): + self.nn_name = (self.nn_name if name is None else name) + self.policy.load_state_dict( + torch.load(self.save_path_format.format(name=self.nn_name))) + print("policy loaded!") + + +# class PlicyGradient(): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# return + + +# class ActorCritic(nn.Module): +# def __init__(self, num_input=3, num_actions=50, nn_dim=100): +# super(ActorCritic, self).__init__() +# self.l1 = nn.Linear(num_input,nn_dim) +# self.l2 = nn.Linear(nn_dim,nn_dim) +# self.actor_lin1 = nn.Linear(nn_dim,num_actions) +# self.l3 = nn.Linear(nn_dim,nn_dim) +# self.critic_lin1 = nn.Linear(nn_dim,1) +# def forward(self,x): +# # print("nn state",x) +# #x = F.normalize(x,dim=0) +# y = F.relu(self.l1(x)) +# y = F.relu(self.l2(y)) +# actor = F.softmax(self.actor_lin1(y),dim=0) #C +# c = F.elu(self.l3(y.detach())) +# critic = F.elu(self.critic_lin1(c)) #D +# return actor, critic #E + +# class NeuralNetwork(NNBase): +# def __init__(self,lr=.00001, num_input=3, num_actions=50, nn_dim=100): +# super().__init__(lr=lr, num_input=num_input, num_actions=num_actions, nn_dim=nn_dim) + +# def reset(self): +# self.policy = ActorCritic(num_input=self.num_input, num_actions=self.num_actions, nn_dim=self.nn_dim) + +# self.optim = torch.optim.Adam(self.policy.parameters(), lr=self.lr) + +# return self.policy, self.optim + + # def optimizer(self,parameter): + \ No newline at end of file diff --git a/mainGame/play.py b/mainGame/play.py new file mode 100644 index 0000000..d9e5e7c --- /dev/null +++ b/mainGame/play.py @@ -0,0 +1,33 @@ +from MainGame import MainGame +from MainGame import Strategy +from MainGame import StrategyType +from environmentModelBase import Model, AdversaryModes +from neuralNetworkSimple import NNBase + +# const132=Strategy(StrategyType.static,name="const132",staticIndex=1) +# const95=Strategy(StrategyType.static,"const95",staticIndex=2) +# myopic=Strategy(StrategyType.static,"myopic",staticIndex=0) + +mainGame=MainGame() + +# mainGame._strategies.append(const132) +# mainGame._strategies.append(const95) +# mainGame._strategies.append(myopic) +# mainGame.fill_matrix() +# mainGame.write_all_matrix() + +nnMyopic=NNBase(num_input=27, num_actions=50, adv_hist=0) +nnMyopic.reset() +nnMyopic.load("0,[1e-05,1][1, 10000, 1, 1],1682423487") +nn1st=Strategy(StrategyType.neural_net,"nnMyopic",neuralNet=nnMyopic,history_num=0 ) +mainGame._strategies.append(nn1st) + + +nnConst=NNBase(num_input=27, num_actions=50, adv_hist=0) +nnConst.reset() +nnConst.load("0,[1e-05,1][1, 10000, 1, 1],1682506150") +mainGame._strategies.append(Strategy(StrategyType.neural_net,"nnConst",neuralNet=nnMyopic,history_num=0 )) + +mainGame.fill_matrix() + +mainGame.write_all_matrix() \ No newline at end of file diff --git a/mainGame/results.xlsx b/mainGame/results.xlsx new file mode 100644 index 0000000..ff4cae4 Binary files /dev/null and b/mainGame/results.xlsx differ diff --git a/tex/PGM.pdf b/tex/PGM.pdf new file mode 100644 index 0000000..6b2ebbe Binary files /dev/null and b/tex/PGM.pdf differ diff --git a/tex/PGM.tex b/tex/PGM.tex new file mode 100644 index 0000000..e1d22cd --- /dev/null +++ b/tex/PGM.tex @@ -0,0 +1,264 @@ +% Ploicy Gradient method in Evolutionary Pricing Games +\documentclass[a4paper,12pt]{article} %% important: a4paper first + +\usepackage{graphicx} +\graphicspath{{./img/}} +\usepackage[notcite,notref]{showkeys} +\pdfoutput=1 +\usepackage{natbib} +\usepackage{amsthm} +\usepackage{newpxtext,newpxmath} +\usepackage{microtype} +\linespread{1.10} % Palatino needs more leading (space between lines) +\usepackage{xcolor} +\usepackage{pict2e} + +\usepackage{tikz} +\usetikzlibrary{shapes} +\usetikzlibrary{arrows.meta} + +%\usepackage{smallsec} +\usepackage{graphicx} +%\usepackage[pdflatex]{hyperref} +\usepackage[hyphens]{url} +\usepackage[colorlinks,linkcolor=purple,citecolor=blue]{hyperref} +%\usepackage{hyperref} +\urlstyle{sf} +\usepackage[format=hang,justification=justified,labelfont=bf,labelsep=quad]{caption} +% \input macros-drawtree +\oddsidemargin=.46cm % A4 +\textwidth=15cm +\textheight=23.3cm +\topmargin=-1.3cm +\clubpenalty=10000 +\widowpenalty=10000 +\predisplaypenalty=1350 +\sfcode`E=1000 % normal spacing if E followed by period, as in "EFCE." +\sfcode`P=1000 % normal spacing if P followed by period, as in "NP." +\newdimen\einr +\einr1.7em +\newdimen\eeinr +\eeinr 1.7\einr +\def\aabs#1{\par\hangafter=1\hangindent=\eeinr + \noindent\hbox to\eeinr{\strut\hskip\einr#1\hfill}\ignorespaces} +\def\rmitem#1{\par\hangafter=1\hangindent=\einr + \noindent\hbox to\einr{\ignorespaces#1\hfill}\ignorespaces} +\newcommand\bullitem{\rmitem{\raise.17ex\hbox{\kern7pt\scriptsize$\bullet$}}} +\def\subbull{\vskip-.8\parskip\aabs{\raise.2ex\hbox{\footnotesize$\circ$}}} +\let\sfield\mathcal +\newtheorem{theorem}{Theorem} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{example}[theorem]{Example} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\theoremstyle{definition} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{definition}[theorem]{Definition} +\def\reals{{\mathbb R}} +\def\eps{\varepsilon} +\def\prob{\hbox{prob}} +\def\sign{\hbox{sign}} +\def\proof{\noindent{\em Proof.\enspace}} +\def\proofof#1{\noindent{\em Proof of #1.\enspace}} +\def\endproof{\hfill\strut\nobreak\hfill\tombstone\par\medbreak} +\def\tombstone{\hbox{\lower.4pt\vbox{\hrule\hbox{\vrule + \kern7.6pt\vrule height7.6pt}\hrule}\kern.5pt}} +\def\eqalign#1{\,\vcenter{\openup.7ex\mathsurround=0pt + \ialign{\strut\hfil$\displaystyle{##}$&$\displaystyle{{}##}$\hfil + \crcr#1\crcr}}\,} +\def\zw#1\par{\vskip2ex{\textbf{#1}}\par\nobreak} +\newdimen\pix % bounding box height for eps files +\pix0.08ex +\newsavebox{\figA} +\parindent0pt +\parskip1.3ex + +\title{% + Plicy Gradient methods in the Evolutionary Pricing Game +} + +\author{ +} + +%\date{Febuary 6, 2012} +\date{\today + \\[1ex] +} + +\begin{document} + \maketitle + + \begin{abstract} + The deep reinforcement learning model of an agent in duopoly multi-round pricing game and applying policy gradient methods to find the optimal strategy. + + % \noindent + % \textbf{ACM classification:} + % CCS + % $\to$ Theory of computation + % $\to$ Theory and algorithms for application domains + % $\to$ Algorithmic game theory and mechanism design + % $\to$ Solution concepts in game theory, + % exact and approximate computation of equilibria, + % representations of games and their complexity + % + % + % \strut + % + % \noindent + % \textbf{AMS subject classification:} + % 91A18 (Games in extensive form) + % + % \strut + % + % \noindent + % \textbf{JEL classification:} + % C72 (Noncooperative Games) + % + % \strut + % + % \noindent + % \textbf{Keywords:} + % extensive game, + % correlated equilibrium, + % polynomial-time algorithm, + % computational complexity. + % + \end{abstract} + + \section{Multi-round pricing game} + \subsection{End effect} + + \section{Naive Policy Gradient method} + + + + \begin{figure}[hbt] + \centering + \includegraphics[width=11cm]{states_model} + \caption{environment model} + \label{f1equi} + \end{figure} + + In \textit{action-value} methods such as Q-learning, the value of of each state or state-action pair is learned and based on these values, the policy would be determined. + However, in \textit{Policy Gradient} methods, the policy is learnt directly without using value functions for action selection. + + As a first step, we implemented a naive policy gradient algorithm. + + + Since the number of states in our model is large, we need a function approximator to parametrize the action preferences. We use a artificial neural network for this purpose and we show the vector of connection weights in our network as $ \theta $. + + The actions at each state are chosen in a way that action with higher valuation is more likely to be chosen. + + \subsection{Action space} + + The reward in each stage of the multi-round pricing game is determined by $ (D_i-P)\times(P-C) $ in which $ D_i $ is the agent's demand potential at the start of stage i and $ C $ is the agent's product cost. $ P^* = \frac{D_i + C}{2} $ maximises this quadratic concave function; we refer to $ P^* $ as \textit{myopic price} or \textit{monopoly price} at stage i. Playing the myopic price results in maximum payoff at the current stage but the demand potential for the next round would be affected, meaning it does\textbf{ not} necessarily result in the maximum overall return. + + We considered actions as the value below the monopoly price that should be played, in order to attract more demand and consequently more reward in later stages. In our model the action-space is discrete. In each stage, action $ a \in \lbrace0, 1, ..., 19\rbrace $ with step$ =3 $ that means the price can be $ 0, 3, 6, ... ,$ or $57 $ units less than the stage's myopic price. + + For example, for the low-cost player ( $ C=57 $), if $ D_i = 180 $ at the start of stage i and action $ a = 5 $: + \begin{equation*} + P^* = \frac{180 + 57}{2} = 118.5 \rightarrow P = P^*- ( a\times \text{step}) = 118.5 - 5\times 3 = 103.5 \\ + \end{equation*} + + The actions are determined by sampling from the probability distribution over the action space that is the output of neural network. + + \subsection{State representation} + + The state should provide all the information that is needed for making a decision at each state. + In our model, the state includes following : + \begin{itemize} + \item current stage of game + \item agent's current demand potential $ (d) $ + \item agent's price in the last stage + \item adversary's price history (last 3 stages) + \end{itemize} + + + \tikzset{every picture/.style={line width=0.75pt}} %set default line width to 0.75pt + + \begin{tikzpicture}[x=0.75pt,y=0.75pt,yscale=-1,xscale=1] + %uncomment if require: \path (0,300); %set diagram left start at 0, and has height of 300 + + %Shape: Rectangle [id:dp5062639226737371] + \draw [color={rgb, 255:red, 74; green, 74; blue, 74 } ,draw opacity=1 ] (53.4,101) -- (626.38,101) -- (626.38,140.24) -- (53.4,140.24) -- cycle ; + %Straight Lines [id:da37083328217168265] + \draw (262.06,101.39) -- (262.06,140.36) ; + %Straight Lines [id:da032007577187648906] + \draw (330.51,101.39) -- (330.51,140.36) ; + %Straight Lines [id:da4042348455753717] + \draw (394.55,101.39) -- (394.55,140.36) ; + + % Text Node + \draw (102.95,111.47) node [anchor=north west][inner sep=0.75pt] [font=\normalsize] [align=left] {encoding of stage}; + % Text Node + \draw (271.06,103.39) node [anchor=north west][inner sep=0.75pt] [font=\small] [align=left] {demand\\potential}; + % Text Node + \draw (345,105) node [anchor=north west][inner sep=0.75pt] [font=\small] [align=left] {\begin{minipage}[lt]{22.6pt}\setlength\topsep{0pt} + \begin{center} + last\\price + \end{center} + + \end{minipage}}; + % Text Node + \draw (433,111) node [anchor=north west][inner sep=0.75pt] [color={rgb, 255:red, 0; green, 0; blue, 0 } ,opacity=1 ] [align=left] {adversary's price history}; + + + \end{tikzpicture} + +\subsection{Adjustments to the learning} + After the basic implementation of the policy gradient algorithm, we noticed that the agent does not learn the end effect of the game. In the following, we explain the techniques we applied to our model to help it learn the end effect. + \subsubsection{one-hot encoding of stage} + In the basic model, stage was represented in the state as a real number in $ [0,1] $. To see the end effect more obvious, we used the one-hot encoding of stage in the state representation instead. + + \begin{table}[!h] + \centering + + \begin{tabular}{p{0.12\textwidth}p{0.04\textwidth}p{0.04\textwidth}p{0.06\textwidth}p{0.04\textwidth}p{0.04\textwidth}} + & $\displaystyle i_{1}$ & $\displaystyle i_{2}$ & ... & $\displaystyle i_{2}{}_{4}$ & $\displaystyle i_{2}{}_{5}$ \\ + \cline{2-6} + \multicolumn{1}{c|}{stage 1} & \multicolumn{1}{c|}{1} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{0} \\ + \cline{2-6} + \multicolumn{1}{c|}{stage 2} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{1} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{0} \\ + \cline{2-6} + \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{...} \\ + \cline{2-6} + \multicolumn{1}{c|}{stage 24} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{1} & \multicolumn{1}{c|}{0} \\ + \cline{2-6} + \multicolumn{1}{c|}{stage 25} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{...} & \multicolumn{1}{c|}{0} & \multicolumn{1}{c|}{1} \\ + \cline{2-6} + \end{tabular} + + \end{table} + The game has 25 stages so we use an array of size 25 and in each stage the corresponding index would be 1 and the other indices would be 0. + \subsubsection{Learning backwards} + Another technique we used to make the end-effect more clear to the learning agent, is learning backwards. + The game is played as before but the difference is that for the first episodes, only the weights of last action (action for the last stage) in our neural network would be updated. Then, for some episodes, just the weights for last 2 actions would be updated, and so on. In the last episodes, the weights for all the actions would be updated. + + In this way, the agent will have some time to optimize the action for last stage in the first steps which helps it understand the end-effect better. + + + \subsection{Structure of Neural Network} + + \subsection{Loss function} + + \subsection{Using Adam optimizer} + + + \subsection{Structure of neural network} + + \section{Monte Carlo Policy Gradient} + + \section{Reinforcement with Baseline} + + \section{Actor-Critic method} + + + + + %\bibliographystyle{ecta} + %\bibliographystyle{acm} + \small + \bibliographystyle{book} + \bibliography{bib-evol} + +\end{document} \ No newline at end of file diff --git a/tex/img/states_model.png b/tex/img/states_model.png new file mode 100644 index 0000000..7f6d13a Binary files /dev/null and b/tex/img/states_model.png differ