def execute_use_potion(self):
if( self.level.get_current_room().creature != None ):
arena = Arena(self.player, self.level.get_current_room().creature)
if( len(self.player.potion) - 1 >= self.params and self.params >= 0 ):
arena.potion(self.params)
self.player.potion.pop(self.params)
else:
#use the potion
if( len(self.player.potion) - 1 >= self.params and self.params >= 0 ):
self.player.potion[self.params].attack_post(self.player, None)
self.player.potion.pop(self.params)
def main() :
bots = dict( line.strip("\n").split(" ") for line in open("botlist.txt").readlines() )
code = { bot: open(os.path.join("bots", bot)).read() + " " for bot in bots }
scores = { bot: 0 for bot in bots }
for fighters in itertools.combinations(bots, 2) :
cmd = {
"programs" : [code[f] for f in fighters],
"names" : [f.rsplit(".", 1)[0] for f in fighters]
}
results = [ Arena.tournament(cmd)[:] for _ in range(10) ]
score = [len([True for r in results if f.rsplit(".", 1)[0] in r[-1]]) for f in fighters]
for fig, sco in zip(fighters, score) :
scores[fig] += sco
total = "===== {} vs. {} finished with {}:{} =====".format(*list(fighters) + score)
### Uncomment below to generate logs
# log = open(os.path.join("logs", "{}_vs_{}.log".format(*[f.rsplit(".", 1)[0] for f in fighters])), "w")
# for res in results :
# log.write("\n".join(res) + "\n\n\n")
# log.write(total)
# log.close()
print(total)
scoreboard = generateScoreboard(bots, scores)
open("SCOREBOARD.md", "w").write(scoreboard)
if mini_othello:
n1.load_checkpoint('./pretrained_models/othello/pytorch/',
'6x100x25_best.h5')
else:
n1.load_checkpoint('./pretrained_models/othello/pytorch/',
'8x8_100checkpoints_best.h5')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
def n1p(x): return np.argmax(mcts1.getActionProb(x, temp=0))
if human_vs_cpu:
player2 = hp
else:
n2 = NNet(g)
n2.load_checkpoint('./pretrained_models/othello/pytorch/',
<<<<<<< HEAD
'8x8_100checkpoints_best.h5')
=======
'8x8_100checkpoints_best.pth.tar')
>>>>>>> 57d3f301dfe7a2ead8a1d99e9ee46a3d59f49a67
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
def n2p(x): return np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
arena = Arena.Arena(n1p, player2, g, display=OthelloGame.display)
print(arena.playGames(2, verbose=True))
import numpy as np
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = OthelloGame(6)
# all players
rp = RandomPlayer(g).play
gp = GreedyOthelloPlayer(g).play
hp = HumanOthelloPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./pretrained_models/othello/pytorch/',
'6x100x25_best.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
"""n2 = NNet(g)
n2.load_checkpoint('/dev/8x50x25/','best.pth.tar')
args2 = dotdict({'numMCTSSims': 25, 'cpuct':1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
"""
arena = Arena.Arena(n1p, hp, g, display=display)
print(arena.playGames(2, verbose=True))
cps = [1, 2, 5, 9, 17, 24, 36, 50, 63, 74, 85, 95, 99]
full_cps = [1, 2, 3, 5, 7, 8, 9, 11, 13, 17, 21, 24, 28, 29, 30, 31, 33, 36, 38,\
39, 40, 41, 42, 44, 48, 50 ,57, 59, 60, 61, 63, 67, 68, 69, 71, 72, 73,\
74, 78, 79, 85, 89, 91, 95, 99]
cur_cps = [36, 38, 39, 40, 41, 42, 44, 48, 50 ,57, 59, 60, 61, 63, 67, 68, 69, 71,\
72, 73, 74, 78, 79, 85, 89, 91, 95, 99]
for cp in cur_cps:
n1 = NNet(g)
n1.load_checkpoint('./pretrained_models/hex/pytorch/temp/',
'Copy of checkpoint_{}.pth.tar'.format(cp))
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts = MCTS(g, n1, args1)
azp = lambda x, player: np.argmax(mcts.getActionProb(x, player, temp=0))
arena = Arena.Arena(azp, rp.play, g, display=display)
print('=========== playing check point {} vs {} ==========='.format(
cp, 'random'))
az_won, rp_won, draws = arena.playGames(num, verbose=True)
print((az_won, rp_won, draws))
total_turn = arena.total_turn
print('sim count MCTS all', mcts.sim_count, 'avg game',
mcts.sim_count / num, 'avg turn', mcts.sim_count / total_turn)
res['random'][cp] = (az_won, num)
for depth in [1, 2]:
player = abps[depth]
player.sim_count = 0
mcts.sim_count = 0
arena = Arena.Arena(azp,
from Scoreboard import *
pygame.init()
p1_Banner = red
p2_Banner = blue
size = [700,600]
display = pygame.display.set_mode(size)
pygame.display.set_caption("PyPong")
clock = pygame.time.Clock()
player1 = Racquet(display,red,right)
player2 = ai_Racquet(display,blue,left)
ball1 = Ball(display,purple,center)
arena1 = Arena(display,lime_green)
scoreboard1 = Scoreboard(display,orange,p1_Banner,p2_Banner)
done = False
''' -------- Main Program Loop STARTS -------- '''
while done == False:
display.fill(black)
''' EVENT PROCESSING STARTS '''
for event in pygame.event.get():
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
keys_held = pygame.key.get_pressed()
if keys_held[K_UP]:
player1.moveUp()
if keys_held[K_DOWN]:
player1.moveDown()
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = GoGame(3)
# all players
rp = RandomPlayer(g).play
gp = GreedyGoPlayer(g).play
hp = HumanGoPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./temp/','best.pth.tar')
args1 = dotdict({'numMCTSSims': 10, 'cpuct':1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
n2 = NNet(g)
n2.load_checkpoint('./temp/','temp.pth.tar')
args2 = dotdict({'numMCTSSims': 10, 'cpuct':1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
arena = Arena.Arena(rp, n1p, g, display=display)
print(arena.playGames(100, verbose=True))
import Arena from MCTS import MCTS from checkers.CheckersGame import CheckersGame from checkers.CheckersPlayers import * from checkers.pytorch.NNet import NNetWrapper as NNet import numpy as np from utils import * """ use this script to play any two agents against each other, or play manually with any agent. """ g = CheckersGame(6) rp = RandomPlayer(g).play gp = GreedyCheckersPlayer(g).play hp = HumanCheckersPlayer(g).play arena = Arena.Arena(gp, hp, g, display=CheckersGame.display) print(arena.playGames(2, verbose=True))
def main():
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w',
0) # flush print output immediately
GB = GeneralBot(fname='gb_qtable_start.p')
agent_host = MalmoPython.AgentHost()
try:
agent_host.parse(sys.argv)
except RuntimeError as e:
print 'ERROR:', e
print agent_host.getUsage()
exit(1)
if agent_host.receivedArgument("help"):
print agent_host.getUsage()
exit(0)
my_mission_record = MalmoPython.MissionRecordSpec()
##########################################################
## Modify the below code in order to change the encounters
##########################################################
encounters = len(Arena.ENTITY_LIST) * 10
for n in range(encounters):
i = n % len(Arena.ENTITY_LIST)
enemy = Arena.malmoName(
Arena.ENTITY_LIST[i]) #"Zombie" if you want to run it exclusively
# against Zombies
print
print 'Mission %d of %d: %s' % (n + 1, encounters, enemy)
# Create the mission using the preset XML function fromarena_gen
missxml = Arena.create_mission(enemy)
my_mission = MalmoPython.MissionSpec(missxml, True)
my_mission.forceWorldReset() # RESET THE WORLD IN BETWEEN ENCOUNTERS
max_retries = 3
for retry in range(max_retries):
try:
agent_host.startMission(my_mission, my_mission_record)
break
except RuntimeError as e:
if retry == max_retries - 1:
print "Error starting mission:", e
exit(1)
else:
time.sleep(2)
print "Waiting for the mission to start",
world_state = agent_host.getWorldState()
while not world_state.has_mission_begun:
sys.stdout.write(".")
time.sleep(0.1)
world_state = agent_host.getWorldState()
for error in world_state.errors:
print "Error:", error.text
print
# -- run the agent in the world -- #
if n % 5 == 0 and n != 0:
print "Optimal Strategy so far..."
GB.runOptimal(agent_host)
else:
GB.run(agent_host)
print "Mission has stopped.\n"
# -- clean up -- #
time.sleep(2) # (let the Mod reset)
print "Done."
GB.log_Q()
GB.log_results('gb_results_base2.txt')
class Universe:
"""
All of the Entities are stored here and are used in either Overworld or Arena depending on what stage is currently active
"""
controls = ['w', 'a', 's', 'd']
def __init__(self, screen_width, screen_height):
self.screen = Screen(self, screen_width, screen_height)
self.screen_width = screen_width
self.screen_height = screen_height
start = Entity(0, 0, "", "", 45, 0)
start.setSprite("sprites/startingScreen.txt", )
start.drawArena(self.screen)
self.screen.print()
self.textBox = TextBox(0, 15)
self.isOverworld = True # False if the current stage is the Arena
self.overworld = Overworld(self,
width=40,
height=11,
overworld_x=60,
overworld_y=4)
self.player = Player(
overworld_x=81,
overworld_y=9,
sprites_path="sprites/player.txt",
overworldChar="P",
arena_x=50,
arena_y=10,
defensePower=100,
evade=0.2,
health=1000,
crit=0.2,
moveset=[
Attack(name='Heavy Attack',
damage=450,
hitChance=0.3,
statusEffect=StatusEffect(
name="Shock",
duration=6,
damagePerTurn=40,
sprite_path="sprites/shockEffect.csv")),
Attack(name='Regular Attack',
damage=150,
hitChance=0.7,
statusEffect=StatusEffect(
name="Poison",
duration=4,
damagePerTurn=20,
sprite_path="sprites/poisonEffect.csv")),
Attack(name='Light Attack',
damage=60,
hitChance=1,
statusEffect=StatusEffect(
name="Spice",
duration=6,
damagePerTurn=40,
sprite_path="sprites/spiceEffect.csv"))
])
# array containing all monsters
self.monsters = [
Monster(overworld_x=84,
overworld_y=11,
sprites_path='sprites/pepperSprite.txt',
overworldChar="M",
arena_x=30,
arena_y=10,
defensePower=20,
health=1000,
evade=0.1,
crit=0.3,
moveset=[
Attack(name='Ultimate attack',
damage=300,
hitChance=0.9999,
statusEffect=StatusEffect(
name="Poison",
duration=4,
damagePerTurn=37,
sprite_path="sprites/poisonEffect.csv")),
Attack(name='Spice Attack',
damage=160,
hitChance=0.7,
statusEffect=StatusEffect(
name="Shock",
duration=6,
damagePerTurn=8,
sprite_path="sprites/shockEffect.csv")),
Attack(name='Light Attack',
damage=120,
hitChance=1,
statusEffect=StatusEffect(
name="Spice",
duration=3,
damagePerTurn=14,
sprite_path="sprites/spiceEffect.csv"))
]),
#devil pepper ascci
Monster(overworld_x=74,
overworld_y=8,
sprites_path='sprites/pepperSprite.txt',
overworldChar="M",
arena_x=30,
arena_y=10,
defensePower=10,
health=600,
evade=0.1,
crit=0.6,
moveset=[
Attack(name='Ultimate attack',
damage=250,
hitChance=0.9999,
statusEffect=StatusEffect(
name="Spice",
duration=6,
damagePerTurn=38,
sprite_path="sprites/spiceEffect.csv")),
Attack(name='Regular Attack',
damage=240,
hitChance=0.6),
Attack(name='Light Attack',
damage=200,
hitChance=1,
statusEffect=StatusEffect(
name="Spice",
duration=3,
damagePerTurn=6,
sprite_path="sprites/spiceEffect.csv"))
]),
#fire pepper assci orsomething
Monster(overworld_x=88,
overworld_y=8,
sprites_path='sprites/pepperSprite.txt',
overworldChar="M",
arena_x=30,
arena_y=10,
defensePower=50,
health=1500,
evade=0.1,
crit=0.3,
moveset=[
Attack(name='Ultimate attack',
damage=100,
hitChance=0.9999,
statusEffect=StatusEffect(
name="Spice",
duration=4,
damagePerTurn=78,
sprite_path="sprites/spiceEffect.csv")),
Attack(name='Regular Attack',
damage=50,
hitChance=0.7,
statusEffect=StatusEffect(
name="Shock",
duration=4,
damagePerTurn=70,
sprite_path="sprites/shockEffect.csv")),
Attack(name='Light Attack',
damage=30,
hitChance=1,
statusEffect=StatusEffect(
name="Poison",
duration=5,
damagePerTurn=68,
sprite_path="sprites/poisonEffect.csv"))
])
]
self.playerHealthBar = HealthBar(self.player)
self.healthpot = [
HealthPot(overworld_x=78,
overworld_y=11,
overworldChar="+",
ASCII=["+"],
health=600),
HealthPot(overworld_x=84,
overworld_y=7,
overworldChar="+",
ASCII=["+"],
health=600)
]
#Counters for stats
self.damageInflicted = 0
self.damageReceived = 0
self.score = 0
self.arena = None
self.reset = False
self.exit = False
self.loop()
def startArena(self, monsterIndex):
"""
Instantiates the arena against a monster and changes the stage
:param monster:
"""
self.isOverworld = False
self.arena = Arena(self, self.player, monsterIndex)
self.currentMonsterHealthBar = HealthBar(self.monsters[monsterIndex])
self.arena.draw(self.screen)
self.screen.print()
def loop(self):
while not self.exit:
self.update(self.getInputs())
if not self.exit and self.isOverworld:
self.drawOverworld()
def getInputs(self):
return input('>> ')
def update(self, inputs):
"""
Updates either the Overworld or the Arena depending on which one is active
:param inputs: most recent input
"""
if self.isOverworld:
self.overworld.update(inputs)
else:
self.arena.update(inputs)
def drawOverworld(self):
"""
The Overworld is drawn and printed
:param screen:
"""
self.overworld.draw(self.screen)
self.screen.print()
from tictactoe.TicTacToeGame import TicTacToeGame, display from tictactoe.TicTacToePlayers import * #from gobang.GobangGame import GobangGame, display #from gobang.GobangPlayers import * import numpy as np from MCS import * from MCTS import * from Qlearning import * from utils import * """ use this script to play any two agents against each other, or play manually with any agent. """ #define games #g = Connect4Game(4) g = TicTacToeGame() #g = GobangGame(7) #define players rp = RandomPlayer(g).play mcsp = MCS(g, 100).play mctsp = MCTS(g, 100).play qlp = Qlearning(g, 100, 0.01, 0.9, 0.9).play arena_rp_op = Arena.Arena(mcsp, rp, g, display=display) print(arena_rp_op.playGames(10, verbose=False)) arena_rp_op = Arena.Arena(mctsp, rp, g, display=display) print(arena_rp_op.playGames(10, verbose=False)) arena_rp_op = Arena.Arena(qlp, rp, g, display=display) print(arena_rp_op.playGames(10, verbose=False))
def main(argv):
game_type = ''
player_types = ['random', 'heuristic', 'minimax', 'alphazero', 'human']
p1 = ''
p2 = ''
try:
opts, args = getopt.getopt(argv, "hp:o:",
["help", "player=", "opponent="])
except getopt.GetoptError:
print(
'pit_qubic.py -p <player type> -o <opponent type> (random, heuristic, minimax, alphazero, human)'
)
sys.exit(2)
if len(opts) != 2:
print(
'pit_qubic.py -p <player type> -o <opponent type> (random, heuristic, minimax, alphazero, human)'
)
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print(
'pit_qubic.py -p <player type> -o <opponent type> (random, heuristic, minimax, alphazero, human)'
)
sys.exit()
elif opt in ('-p', '--player'):
p1 = arg
elif opt in ('-o', '--opponent'):
p2 = arg
if ((p1 not in player_types) or (p2 not in player_types)):
print('Invalid player types. Valid player types are:')
print('random')
print('heuristic')
print('minimax')
print('alphazero')
print('human')
sys.exit(2)
args = dotdict({
'checkpoint':
'.qubic/temp/',
'load_folder_file':
('qubic/dev/models/8x100x50', 'qubic/best.pth.tar'),
})
g = QubicGame(4, 4, 4)
p1_ind = pselect(p1)
p2_ind = pselect(p2)
print('playing ' + player_types[p1_ind] + ' against ' +
player_types[p2_ind] + '...')
# all players
rp = RandomPlayer(g).play
gp = HeuristicQubicPlayer(g).play
mp = MiniMaxQubicPlayer(g).play
hp = HumanQubicPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint(folder=args.checkpoint, filename='temp.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
player_list = [rp, gp, mp, n1p, hp]
arena = Arena.Arena(player_list[p1_ind],
player_list[p2_ind],
g,
display=display)
print(arena.playGames(10, verbose=True))
snakes = pickle.load(file)
generation = 0
if args['start'] is not None:
start = args['start']
snakes = snakes[start:]
generation += start
file.close()
# pygame initialization
pygame.init()
pygame.font.init()
myfont = pygame.font.SysFont('Bitstream Vera Serif', 20)
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption('Generation : 0\t\tScore : 0')
# seed generated so that each snake sees same set of foods for performance comparison
seed = random.random()
arena = Arena(width, height, block_length)
for saved_snake in snakes:
t_snake = snake(width, height, brainLayer, block_length,
random_weights=False, random_bases=False)
t_snake.Brain.weights = saved_snake.Brain.weights
t_snake.Brain.bases = saved_snake.Brain.bases
random.seed(seed)
t_snake.Brain.setNextFood(arena.newFood(t_snake.list))
screen = arena.setup(screen, col.bg, col.gray)
screen = arena.drawFood(screen, col.pink)
screen = t_snake.draw(screen, col.blue)
pygame.display.update()
checkloop = False
while t_snake.isAlive():
# checking for key presses and close button presses and pause-continue funcionality
print(arena.playGames(30, verbose=False))#True))
print('CNN vs LSTM')
arena = Arena.Arena(n1p, n3p, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('CNN vs greedy')
arena = Arena.Arena(n1p, gp, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('CNN vs random')
arena = Arena.Arena(n1p, rp, g, display=display)
print(arena.playGames(30, verbose=False))#True))
'''
print('NN vs LSTM')
arena = Arena.Arena(n2p, n3p, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
'''
print('NN vs greedy')
arena = Arena.Arena(n2p, gp, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('NN vs random')
arena = Arena.Arena(n2p, rp, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('lstm vs greedy')
arena = Arena.Arena(n3p, gp, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('lstm vs random')
def __init__(self, params):
#params [studyNumber,animalNumber,leftLever,RightLever,lEnable,rEnable,success#]
self.animalNumber = params[1]
self.studyNumber = params[0]
#Arena handling class
self.arena = Arena()
#Parameters
self.vPositions = [0.00130, 0.00120, 0.00110]
self.hPositions = [0.00105, 0.00115, 0.00125, 0.00135, 0.00145]
self.thresholdLeft = 3200
self.thresholdRight = 3200
self.timeout = 4
self.maxSuccesses = 3
self.enableLeft = False
self.enableRight = True
self.noseThreshold = 100
#servos
self.hr = HR1
self.vr = VR1
self.vl = VL1
self.hl = HL1
self.servos = [self.hr, self.vr, self.vl, self.hl]
#adc channels
self.ly = LL0_CH0
self.lx = LL0_CH1
self.ry = RL0_CH0
self.rx = RL0_CH1
self.noseCH = BNC3_CH
#pump
self.pump = GPIO.PWM(PUMP1,1000)
#Data values
self.time = time.time()
self.leverL = 0
self.leverR = 0
self.nose = 0
self.index = 0
self.successes = 0
self.totalSuccesses = 0
self.reward = 0
self.rewardTime = -4
#io
self.pinLED = 15
self.pinSuccess = 14
#setup logging
##make folder if DNE
directory = "data/" + self.studyNumber + "/" + self.animalNumber
try:
os.makedirs(directory)
except OSError:
if not os.path.isdir(directory):
raise
fileName = (dt.fromtimestamp(time.time()).strftime("%y,%m,%d,%H,%M,%S"))
self.fileName = directory + "/" + fileName
with open(self.fileName, 'w') as data_file:
data_file.write("time,leverL,leverR,nose,thresholdL,thresholdR,horizontal,vertical,success\n")
self.updatePosition()
import sys
import os
import traceback
from Constants import *
from Arena import *
if __name__ == "__main__" :
map_file_name = "map.txt"
arena = Arena (map_file_name, sys.argv [1:])
# a desperate attempt to avoud zombies :
try :
for i in xrange (N_TURNS) :
arena.check_for_bot_crash ()
arena.get_moves ((i == 0))
arena.make_moves ()
arena.update_powers ()
arena.turn_count += 1
arena.map.log_updates (0, 0, "$", "$")
if arena.game_over == True :
break
arena.terminate_game ()
# can't put arena.terminate_game () into
# the "finally" clause because it prints the scores.
# The judge just looks at the last line of output and
# hence errors, if any, should come after the scones.
except (BotProcessDiedError,
rp = RandomPlayer(g).play
hp = HumanChessPlayer(g).play
# nnet players
'''
n1 = NNet(g)
if mini_othello:
n1.load_checkpoint('./pretrained_models/othello/pytorch/','6x100x25_best.pth.tar')
else:
n1.load_checkpoint('./pretrained_models/othello/pytorch/','8x8_100checkpoints_best.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct':1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
if human_vs_cpu:
player2 = hp
else:
n2 = NNet(g)
n2.load_checkpoint('./pretrained_models/othello/pytorch/', '8x8_100checkpoints_best.pth.tar')
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
'''
player1 = hp
player2 = hp
arena = Arena.Arena(player1, player2, g, display=ChessGame.display)
print(arena.playGames(2, verbose=True))
class LeverTask:
def __init__(self, params):
#params [studyNumber,animalNumber,leftLever,RightLever,lEnable,rEnable,success#]
self.animalNumber = params[1]
self.studyNumber = params[0]
#Arena handling class
self.arena = Arena()
#Parameters
self.vPositions = [0.00130, 0.00120, 0.00110]
self.hPositions = [0.00105, 0.00115, 0.00125, 0.00135, 0.00145]
self.thresholdLeft = 3200
self.thresholdRight = 3200
self.timeout = 4
self.maxSuccesses = 3
self.enableLeft = False
self.enableRight = True
self.noseThreshold = 100
#servos
self.hr = HR1
self.vr = VR1
self.vl = VL1
self.hl = HL1
self.servos = [self.hr, self.vr, self.vl, self.hl]
#adc channels
self.ly = LL0_CH0
self.lx = LL0_CH1
self.ry = RL0_CH0
self.rx = RL0_CH1
self.noseCH = BNC3_CH
#pump
self.pump = GPIO.PWM(PUMP1,1000)
#Data values
self.time = time.time()
self.leverL = 0
self.leverR = 0
self.nose = 0
self.index = 0
self.successes = 0
self.totalSuccesses = 0
self.reward = 0
self.rewardTime = -4
#io
self.pinLED = 15
self.pinSuccess = 14
#setup logging
##make folder if DNE
directory = "data/" + self.studyNumber + "/" + self.animalNumber
try:
os.makedirs(directory)
except OSError:
if not os.path.isdir(directory):
raise
fileName = (dt.fromtimestamp(time.time()).strftime("%y,%m,%d,%H,%M,%S"))
self.fileName = directory + "/" + fileName
with open(self.fileName, 'w') as data_file:
data_file.write("time,leverL,leverR,nose,thresholdL,thresholdR,horizontal,vertical,success\n")
self.updatePosition()
def update(self):
"""update state based on arena inputs values"""
oldNose = self.nose
oldLeverL = self.leverL
oldLeverR = self.leverR
self.time = time.time()
self.leverL = self.arena.analogRead(self.ly)
self.leverR = self.arena.analogRead(self.ry)
self.nose = self.arena.analogRead(self.noseCH)
self.nose = self.nose < self.noseThreshold
nose = self.nose
timeout = self.time > self.rewardTime
left = (self.leverL >= self.thresholdLeft) * self.enableLeft * nose * timeout
right = (self.leverR >= self.thresholdRight) * self.enableRight * nose * timeout
success = left or right
if (success):
self.rewardTime = time.time() + self.timeout
self.successes = self.successes + 1
self.totalSuccesses = self.totalSuccesses + 1
self.giveReward()
if (self.successes >= self.maxSuccesses):
self.setIndex(random.randint(0,14))
self.updatePosition()
"""log data"""
if ( self.nose != oldNose or self.leverL != oldLeverL or self.leverR != oldLeverR ):
"""log on change"""
dataFile = open(self.fileName, 'a') #open in append mode
dataFile.write(str(self.time) + "," + str(self.leverL) + "," +
str(self.leverR) + "," + str(self.nose) + "," +
str(self.thresholdLeft * self.enableLeft) + "," +
str(self.thresholdRight * self.enableRight) + "," +
str(self.hPositions[self.index % 5]) + "," +
str(self.vPositions[int(numpy.floor(self.index / 5))]) + "," +
str(success) + "\n")
dataFile.close()
#return vars [leftLever, rightLever, success, total,time]
return [self.leverL, self.leverR, self.successes, self.totalSuccesses]
def setIndex(self,index):
if index == self.index:
return
self.index = index
self.updatePosition()
def updatePosition(self):
"""advance to next position"""
self.successes = 0
horizontal = self.index % 5
vertical = int(numpy.floor(self.index / 5))
horizontal = self.hPositions[horizontal]
vertical = self.vPositions[vertical]
if (self.enableRight):
self.arena.setActuator(self.hr,horizontal)
self.arena.setActuator(self.vr,vertical)
if (self.enableLeft):
self.arena.setActuator(self.hl,horizontal)
self.arena.setActuator(self.vl,vertical)
def setPosition(self,lv,lh,rv,rh):
"""function to set actuators to new position
"""
self.arena.setActuator(self.vr,rv)
self.arena.setActuator(self.hr,rh)
self.arena.setActuator(self.vl,lv)
self.arena.setActuator(self.hl,lh)
def giveReward(self):
"""helper function to deliver reward in separate thread"""
pumpThread = threading.Thread(target=self.giveRewardThread)
pumpThread.start()
def giveRewardThread(self):
"""Helper function to deliver pump reward"""
self.pump.start(50)
self.arena.digitalWrite(self.pinLED, 1)
self.arena.digitalWrite(self.pinSuccess, 1)
time.sleep(0.3)
self.arena.digitalWrite(self.pinLED, 0)
self.arena.digitalWrite(self.pinSuccess, 0)
self.pump.stop()
def __init__(self):
self.callbacks_enabled = 0
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_icon_from_file(np("libglade/carNred64x64.png"))
self.window.set_title("PyTraffic")
self.window.set_resizable(False)
self.window.connect("delete_event", self.quit)
self.window.connect("destroy", self.quit)
vbox = gtk.VBox(False, 0)
self.window.add(vbox)
sound_menu = self.construct_sound_menu()
self.theme_engine = ThemeEngine.ThemeEngine()
self.create_theme_data()
theme_menu = self.construct_theme_menu()
self.menu_items=(
("/_File",None,None,0,"<Branch>"),
( "/File/_New","<control>N",self.new,0,None),
( "/File/S_tatistics","<alt>T",self.show_statistics,0,None),
( "/File/_Quit","<alt>Q",self.quit,0,None),
("/_Edit",None,None,0,"<Branch>"),
("/Edit/_First","<control>B",self.restart,0,None),
("/Edit/_Undo","<control>Z",self.undo,0,None),
("/Edit/_Redo","<control>R",self.redo,0,None),
("/Edit/_End","<control>E",self.gotoend,0,None),
("/_Settings",None,None,0,"<Branch>"),
("/Settings/_Difficulty",None,None,0,"<Branch>" ),
("/Settings/Difficulty/_Trivial",None,self.settype,0,"<RadioItem>"),
("/Settings/Difficulty/_Easy",None,self.settype,1,
"/Settings/Difficulty/Trivial"),
("/Settings/Difficulty/_Intermediate",None,self.settype,2,
"/Settings/Difficulty/Trivial"),
("/Settings/Difficulty/_Advanced",None,self.settype,3,
"/Settings/Difficulty/Trivial"),
("/Settings/Difficulty/_Expert",None,self.settype,4,
"/Settings/Difficulty/Trivial"),
("/Settings/Dummy",None,None,0,"<Separator>"),
("/Settings/_Warnings",None,self.setwarningsmode,0,"<CheckItem>"))\
+ theme_menu +\
(("/Settings/Dummy",None,None,0,"<Separator>"),
("/Settings/_Sound",None,self.setsound,0,"<CheckItem>"),
("/Settings/_Music",None,self.setmusic,0,"<CheckItem>"),
("/Settings/_Choose Music",None,self.choosemusic,0,None))\
+ sound_menu +\
(("/_Help",None,None,0,"<Branch>"),
("/Help/H_int","<alt>I",self.hint,0,None),
("/Help/_Demo","<control>D",self.setdemomode,0,"<CheckItem>"),
("/Help/_Show readme",None,self.readme,0,None),
("/Help/_About","<control>H",self.about,0,None)
)
accel_group = gtk.AccelGroup()
self.item_factory = item_factory = gtk.ItemFactory(
gtk.MenuBar, "<main>", accel_group)
item_factory.create_items(self.menu_items)
self.window.add_accel_group(accel_group)
menubar = item_factory.get_widget("<main>")
vbox.pack_start(menubar, False, True, 0)
self.extract_sound_menu_items(item_factory)
self.extract_theme_menu_items(item_factory)
self.new_ = item_factory.get_widget("/File/New")
self.restart_ = item_factory.get_widget("/Edit/First")
self.undo_ = item_factory.get_widget("/Edit/Undo")
self.redo_ = item_factory.get_widget("/Edit/Redo")
self.end_ = item_factory.get_widget("/Edit/End")
self.trivial_ = item_factory.get_widget("/Settings/Difficulty/Trivial")
self.easy_ = item_factory.get_widget("/Settings/Difficulty/Easy")
self.intermediate_=item_factory.get_widget(\
"/Settings/Difficulty/Intermediate")
self.advanced_ = item_factory.get_widget(
"/Settings/Difficulty/Advanced")
self.expert_ = item_factory.get_widget("/Settings/Difficulty/Expert")
self.animation_ = item_factory.get_widget("/Settings/Animation")
self.warningsmode_ = item_factory.get_widget("/Settings/Warnings")
self.sound_ = item_factory.get_widget("/Settings/Sound")
self.music_ = item_factory.get_widget("/Settings/Music")
self.choose_music_ = item_factory.get_widget("/Settings/Choose Music")
# self.fancy_=item_factory.get_widget("/Settings/Theme/Fancy")
# self.minimal_=item_factory.get_widget("/Settings/Theme/Minimal")
self.demo_ = item_factory.get_widget("/Help/Demo")
self.hint_ = item_factory.get_widget("/Help/Hint")
self.readme_ = item_factory.get_widget("/Help/Show readme")
toolbar = gtk.Toolbar()
self.new_button = toolbar.insert_stock(gtk.STOCK_NEW, "New level", "",
self.new, None, -1)
self.restart_button = toolbar.insert_stock(gtk.STOCK_GOTO_FIRST,
"Restart level", "",
self.restart, None, -1)
self.undo_button = toolbar.insert_stock(gtk.STOCK_UNDO,
"Undo last move", "",
self.undo, None, -1)
self.redo_button = toolbar.insert_stock(gtk.STOCK_REDO,
"Redo last move", "",
self.redo, None, -1)
self.end_button = toolbar.insert_stock(gtk.STOCK_GOTO_LAST,
"Goto end of history", "",
self.gotoend, None, -1)
self.hint_button = toolbar.insert_stock(gtk.STOCK_HELP, "Ask for hint",
"", self.hint, None, -1)
vbox.pack_start(toolbar, False, False, 0)
statusbar = BottomBar.BottomBar(False, 0)
self.type_label = statusbar.add(" Intermediate ")
self.finished = statusbar.add(" Unsolved ")
self.hints = statusbar.add(" Hint : 100 ")
self.moves = statusbar.add(" 0/100 ")
self.time_label = statusbar.empty
self.time_label.set_text("")
self.time_label.set_anchor('e')
vbox.pack_end(statusbar, False, False, 0)
self.sound_server = SoundServer.SoundServer(self.theme_engine)
self.music_server = MusicServer.MusicServer(self.sound_server)
self.music_server.connect("notify::status", self.music_status_change)
self.music_server.connect("no_files_loaded", self.no_files_loaded)
self.step = 0.01
self.al = 0.5
self.music_server.connect("progress", self.music_progress)
self.music_chooser = MusicChooser.MusicChooser(self.theme_engine,
self.music_server)
self.statisticsdialog = Statistics.StatisticsDialog(self.window)
self.artwork = ArtWork.ArtWork(self)
self.gamestate = GameState.GameState()
self.propertybag = PropertyBag.PropertyBag(
configfile=np(Misc.default_configfile),
comment="This is a generated file!")
self.arena = Arena.Arena(self)
vbox.pack_start(self.arena, False, False)
self.arena.connect("button_press_event", self.stop_demo)
self.window.connect("key_release_event", self.stop_demo_key)
self.on = 1
self.clock()
self.timer = Timer.Timer(interval=1000)
self.timer.connect("tick", self.clock)
self.timer.set_running(1)
self.demo_timer = Timer.Timer(interval=1500)
self.demo_timer.connect("tick", self.demo_step)
tree = gtk.glade.XML(np("libglade/AboutDialog.glade"))
self.about_dialog = tree.get_widget("AboutDialog")
config_db = PropertyBag.PropertyBag(
configfile=np(Misc.default_config_db))
config_db.load(all=True)
self.about_dialog.set_version(
"%s-%s" % (config_db["version"], config_db["release"]))
events = {
"on_AboutDialog_response": self.about_dialog_close,
"on_AboutDialog_close": self.about_dialog_close,
"on_AboutDialog_delete_event": self.about_dialog_close
}
tree.signal_autoconnect(events)
self.callbacks_enabled = 1
self.newgame()
self.window.show_all()
# Hack to take focus away from "new" button?
# What is the correct method?
self.new_button.set_sensitive(False)
self.new_button.set_sensitive(True)
import numpy as np
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = WatchGame(maxi=24)
# all players
rp = RandomPlayer(g).play
# gp = GreedyOthelloPlayer(g).play
hp = HumanPlayer(g).play
# nnet players
# n1 = nn(g)
# n1.load_checkpoint('./pretrained_models/othello/pytorch/','6x100x25_best.pth.tar')
# args1 = dotdict({'numMCTSSims': 50, 'cpuct':1.0})
# mcts1 = MCTS(g, n1, args1)
# n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
#n2 = NNet(g)
#n2.load_checkpoint('/dev/8x50x25/','best.pth.tar')
#args2 = dotdict({'numMCTSSims': 25, 'cpuct':1.0})
#mcts2 = MCTS(g, n2, args2)
#n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
arena = Arena.Arena(hp, rp, g, display=display)
print(arena.playGame(verbose=True))
hp = HumanOthelloPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./pretrained_models/ultimate_tictactoe/keras/',
'ultimate_tictactoe_100_eps_20_epoch_checkpoint_9.h5')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
if human_vs_cpu:
player2 = hp
elif random_vs_cpu:
player2 = rp
else:
n2 = NNet(g)
n2.load_checkpoint('./pretrained_models/ultimate_tictactoe/keras/',
'ultimate_tictactoe_100_eps_10_epoch_checkpoint_3.h5')
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
arena = Arena.Arena(player1=n1p,
player2=player2,
game=g,
display=UltimateTicTacToeGame.display)
print(arena.playGames(num_games, verbose=False))
# all players
rp1 = RandomPlayer(g).play
rp2 = RandomPlayer(g).play
gp1 = GreedyPlayer(g).play
# nnet players
n21 = NNet(g)
n21.load_checkpoint('./pretrained_models/minichess/keras/','best.pth.tar')
args1 = dotdict({'numMCTSSims': 200, 'cpuct':1.0})
mcts1 = MCTS(g, n21, args1)
n21p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
verbose = False
print('')
print(' Neural Network (v21) vs Random Player')
print('----------------------------------------')
arena = Arena.Arena(n21p, rp1, g, display=display)
print(arena.playGames(20, verbose=verbose))
print('')
print(' Neural Network (v21) vs Greedy Player')
print('----------------------------------------')
arena = Arena.Arena(n21p, gp1, g, display=display)
print(arena.playGames(20, verbose=verbose))
args1 = dotdict({'numMCTSSims': 200, 'cpuct':1.0})
mcts1 = MCTS(g, n15, args1)
n15p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
print('')
print(' Neural Network (v21) vs Neural Network (v15)')
if human_vs_cpu:
player2 = hp
else:
if (ai):
n2 = NNet(g)
n2.load_checkpoint('./temp/', 'best.pth.tar')
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
else:
player2 = rp2
if profiling:
_output_file = 'perfTesting.prof'
pr = cProfile.Profile()
pr.enable()
arena = Arena.Arena(rp, player2, g, display=AzulGame.display)
print(arena.playGames(100, verbose=False))
if profiling:
pr.disable()
pr.dump_stats(_output_file)
with open(_output_file, 'w') as f:
ps = pstats.Stats(pr, stream=f)
ps.strip_dirs()
ps.sort_stats(SortKey.CUMULATIVE)
ps.print_stats()
round_count += 1
championship = False
this_round = next_round
if len(this_round) == 2:
championship = True
next_round = []
while this_round:
random.shuffle(this_round)
p1 = this_round.pop()
p2 = this_round.pop()
print('player 1: iteration %d' % victories[p1][0])
print('player 2: iteration %d' % victories[p2][0])
settled = False
while not settled:
arena = Arena.Arena(p1, p2, g, display=str)
result = arena.playGames(num_games, verbose=False)
if result[0] > result[1]:
next_round.append(p1)
print(result)
settled = True
if championship:
runner_up[p2][1] += 1
elif result[1] > result[0]:
next_round.append(p2)
print(result)
settled = True
if championship:
runner_up[p1][1] += 1
else:
print(result)
import Arena
a = Arena.Create(60, 60)
a.LoadTexture("tree", "Data/Tree.png", False)
a.LoadTexture("grass", "Data/Grass.png", False)
a.GroundTexture = a.GetTexture("grass")
a.SetDisplayAreaRange(-30, 30, -30, 30)
a.AddBlockEntity("tree", 0, 10, -0.0001, 20, 20, True, False)
from utils import *
"""
"""
g = MorpionSolitaireGame(20)
# all players
rp = RandomPlayer(g).play
#rp2 = RandomPlayer(g).play
#gp = GreedyOthelloPlayer(g).play
#hp = HumanOthelloPlayer(g).play
# nnet players
nn = NNet(g)
nn.load_checkpoint('../morpionsolitairewithouttree20/models',
'100_best.pth.tar')
args = dotdict({'numMCTSSims': 1000, 'cpuct': 1.0})
nntbasedMCTSPlayer = NNtBasedMCTSPlayer(g, nn, args, temp=0).play
#purenntplayer=PureNNtPlayer(g, nn, args, temp=0).play
#n2 = NNet(g)
#n2.load_checkpoint('/dev/8x50x25/','best.pth.tar')
#args2 = dotdict({'numMCTSSims': 25, 'cpuct':1.0})
#mcts2 = MCTS(g, n2, args2)
#n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
arena = Arena.Arena(nntbasedMCTSPlayer, g, display=display)
print(arena.playGames(1, verbose=False))
#print(results)
#import game classes from other python files
from Player import *
from Arena import *
from Arrows import *
from BadGuys import *
#Initialize the pygame
pygame.init()
####game variables####
#Color for background
GREEN = (0, 168, 42)
#False if game quit
gameActive = True
#Create the Arena, holds the surface we are drawing the game on
arena = Arena(640, 480, GREEN)
#The player, holds the image and position of the player
player = Player(arena, "../images/dude.png")
#Holds arrows in flight
arrows = Arrows("../images/arrow.png")
#Holds bag guys on the arena
badGuys = BadGuys("../images", 42)
#Holds the current direction(s) the player is moving. Set to no movement
# left-a right-d up-w down-s
keys = {K_a: 0, K_d: 0, K_w: 0, K_s: 0, K_f: 0, K_ESCAPE: 0}
arena.StartGame()
#Main Game loop. The game runs for ever.
while not arena.Status.TimeUp() and player.Alive() and gameActive:
#Move the player, arrows and bad guys
any agent.
Author: Gideon Hanse, Dyon van Vreumingen
"""
import numpy as np
import py_compile as cmp
from utils import *
from Arena import *
from gobang.GobangGame import GobangGame, display
from gobang.GobangPlayers import *
from MCS import MCSPlayer
from Qlearning import QlearningPlayer
#from MCTS import MCTSPlayer
cmp.compile("gobang/GobangPlayers.py")
g = GobangGame(9)
# p1 = MCSPlayer(g)
p1 = QlearningPlayer(g)
p1.train(10000)
p2 = RandomPlayer(g)
print("Gobang")
arena = Arena(p1.play, p2.play, g, display=display)
print(arena.playGames(1000, verbose=False))
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = OthelloGame(8)
# all players
rp = RandomPlayer(g)
gp = GreedyOthelloPlayer(g)
hp = HumanOthelloPlayer(g)
edax = EdaxPlayer(3, g)
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./temp/','restart.pth.tar')
#n1.load_checkpoint('./pretrained_models/othello/pytorch','restart.pth.tar')
args1 = dotdict({'numMCTSSims': 100, 'cpuct':1.0})
n1p = NeuralPlayer(g, n1, args1)
n2 = NNet(g)
n2.load_checkpoint('./pretrained_models/othello/pytorch','8x8_100checkpoints_best.pth.tar')
args2 = dotdict({'numMCTSSims': 200, 'cpuct':1.0})
n2p = NeuralPlayer(g, n2, args2, False)
arena = Arena.Arena(n1p, edax, g, display=display)
print(arena.playGames(10, verbose=True))
# Name and class picking
print("Welcome to the battle arena!")
p1 = char_decision(name_pick("Player 1"), char_pick())
name = name_pick("Player 2")
while name == p1.name:
input("You cannot pick the same name like your opponent!")
os.system('clear')
name = name_pick("Player 2")
p2 = char_decision(name, char_pick())
while p1.char == p2.char:
input("You cannot pick the same class like your opponent!")
os.system('clear')
p2 = char_decision(name, char_pick())
input("Let the game begin!\nPress enter for continue...")
game = Arena.Arena(p1, p2)
# Random start
if random.randint(0, 1):
(p1, p2) = (p2, p1)
# game loop
loop = 1
while not game.is_over():
os.system('clear')
if not game.is_over():
game.round(p1, p2, loop)
else:
break
input("Press enter to continue...")
from Board import *
from Arena import *
from optparse import OptionParser
myparser = OptionParser()
myparser.add_option("-f", dest="batchfile", default="boards", help="-f for input file", type="string")
myparser.add_option("-n", dest="boardnum", default="0", help="-n for board number", type="string")
(input, args) = myparser.parse_args(args=sys.argv)
tk = Tk() # Create a Tk top-level widget
puz = Board(input.batchfile, int(input.boardnum))
arena = Arena(tk, puz) # Create an Arena widget, arena
arena.pack() # Tell arena to pack itself on screen
tk.mainloop()
def experiment(game):
np.random.seed(556)
height = game[0]
width = game[1]
win_streak = game[2]
g = Connect4Game(height, width, win_streak)
if game == (4, 5, 3):
total_episodes = n_episodes[0]
ep_step = 10000
ep_range = np.arange(0, total_episodes + ep_step, ep_step) + 1
ep_range[0] = 0
ep_range = ep_range.astype(int)
elif game == (5, 6, 4):
total_episodes = n_episodes[1]
ep_step = 20000
ep_range = np.arange(0, total_episodes + ep_step, ep_step) + 1
ep_range[0] = 0
ep_range = ep_range.astype(int)
else:
total_episodes = n_episodes[2]
ep_step = 28000
ep_range = np.arange(0, total_episodes + ep_step, ep_step) + 1
ep_range[0] = 0
ep_range = ep_range.astype(int)
for lr in lrs:
for i in epsilon_config:
print('Config: Game', game, 'lr', lr, 'epsilon', i)
test_wr_list = []
test_wr_list_op = []
test_wr = []
test_wr_op = []
if i == 'f':
q_agent = QAgent(g,
episodes=total_episodes,
lr=lr,
epsilon=0.2,
dc=1,
e_min=0.001,
ep_arena=ep_step)
rp = RandomPlayer(g).play
op = OneStepLookaheadConnect4Player(g, verbose=False).play
q_agent_play = q_agent.play
else:
q_agent = QAgent(g,
episodes=total_episodes,
lr=lr,
epsilon=1,
dc=0.99,
e_min=0.001,
ep_arena=ep_step)
rp = RandomPlayer(g).play
op = OneStepLookaheadConnect4Player(g, verbose=False).play
q_agent_play = q_agent.play
start = time()
for idx, episode in enumerate(ep_range):
if episode == ep_range[-1]:
break
if episode == 0:
print('Training for Episodes ',
0,
' to ',
ep_range[idx + 1] - 1,
'...',
sep='')
elif episode == ep_range[-2]:
print('Training for Episodes ',
episode - 1,
' to ',
total_episodes,
'...',
sep='')
else:
print('Training for Episodes ',
episode - 1,
' to ',
ep_range[idx + 1] - 1,
'...',
sep='')
q_agent.train(cur_episode=episode)
print('Training Finished.')
print('Playing in Arena...')
wins = 0
temp = []
for repet in range(reps):
arena_rp_op = Arena.Arena(q_agent_play,
rp,
g,
display=display)
w, _, _ = arena_rp_op.playGames(n_games, verbose=False)
temp.append(w / n_games)
wins += w
test_wr_list.append(temp)
test_wr.append(wins / (reps * n_games))
print('\n')
wins_op = 0
temp = []
for repet in range(reps):
arena_rp_op = Arena.Arena(q_agent_play,
op,
g,
display=display)
w_op, _, _ = arena_rp_op.playGames(n_games, verbose=False)
temp.append(w_op / n_games)
wins_op += w_op
test_wr_list_op.append(temp)
test_wr_op.append(wins_op / (reps * n_games))
print('\n')
end = time()
training_time = np.array([end - start])
np.save(
'train_wr_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_rp', q_agent.total_wins)
np.save(
'train_ep_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_rp', q_agent.total_eps)
np.save(
'test_wr_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_rp', test_wr)
np.save(
'test_wr_list_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_rp', test_wr_list)
np.save(
'training_time_' + str(game) + '_' + str(lr) + '_' + str(i) +
'_rp', training_time)
np.save(
'test_wr_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_op', test_wr_op)
np.save(
'test_wr_list_connect4_' + str(game) + '_' + str(lr) + '_' +
str(i) + '_op', test_wr_list_op)
print('\n')
def execute_magic_attack(self):
arena = Arena(self.player, self.level.get_current_room().creature)
if( len(self.player.spells) - 1 >= self.params and self.params >= 0 ):
arena.magic_attack(self.params)
self.player.spells.pop(self.params)
string = string + " ] "
print('Total so far = ', len(dictionary))
print(string)
# MAIN=======================================
#valids = pickle.load( open( "save.txt", "rb" ))##a2
#venueDic = ArenaData.getDic()
#print(venueDic)
validsGlobal = {}
venueDic = {}
venueDic = ArenaData.getDic()
def load():
if (os.stat("save.txt").st_size == 0):
valids = {}
else:
valids = pickle.load(open("save.txt", "rb")) ##a2
#print ('loaded valid')
return valids
def runVisualClassifier(framePath, name, type, limit):
venueDic = ArenaData.getDic()
if (framePath != '-1'):
validsGlobal = load()
print(arena.playGames(30, verbose=False))#True))
print('cnn vs lstm256')
arena = Arena.Arena(cnn, lstm256, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('nn64 vs nn128')
arena = Arena.Arena(nn64, nn128, g, display=display)
print(arena.playGames(30, verbose=False))#True))
print('nn64 vs nn256')
arena = Arena.Arena(nn64, nn256, g, display=display)
print(arena.playGames(30, verbose=False))#True))
'''
print('nn64 vs lstm64')
arena = Arena.Arena(nn64, lstm64, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('nn64 vs lstm128')
arena = Arena.Arena(nn64, lstm128, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('nn64 vs lstm256')
arena = Arena.Arena(nn64, lstm256, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('nn128 vs nn256')
arena = Arena.Arena(nn128, nn256, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('nn128 vs lstm64')
def main(argv):
parameters = dict()
config = Config.Configuration(parameters)
try:
opts, args = getopt.getopt(argv, "vgi:o:a:d:p:m:x:y:h:w:s:")
except getopt.GetoptError:
usage()
for opt, arg in opts:
if opt in ("-v"): # -v verbose
parameters['verbose'] = True
elif opt in ("-m"):
parameters['plotSamples'] = True
elif opt in ("-g"):
parameters['plotGraphics'] = True
elif opt in ("-o"):
parameters['outputPath'] = arg
elif opt in ("-a"):
parameters['arenaFilename'] = arg
elif opt in ("-d"):
parameters['dataFilename'] = arg
elif opt in ("-s"):
parameters[
'serverIP'] = arg # Server IP address fro getting data from robot
elif opt in ("-i"):
parameters['iterations'] = int(
arg) # Number of times the robot is moved
elif opt in ("-p"):
parameters['numberOfParticles'] = int(arg)
elif opt in ("-x"):
parameters['robotX'] = int(arg)
elif opt in ("-y"):
parameters['robotY'] = int(arg)
elif opt in ("-h"):
parameters['robotH'] = float(arg)
elif opt in ("-w"):
parameters['initialWeightThres'] = float(arg)
if config.verify(parameters):
usage()
print("Initializing arena")
try:
parameters['arena'] = Arena.Arena(parameters)
except Exception as e:
print("Failure loading arena: " + str(e))
usage()
datalogger_object = DataLogger.DataLogger()
if 'dataFilename' in parameters:
print("Initializing datalogger")
datalogger_object.startDataLogger(parameters)
prediction = (0, 0, 0)
robot_server = rs.RobotServer(parameters)
if robot_server.start(parameters) < 0:
print("Failure starting the server")
sys.exit(-2)
for iteration in range(parameters['iterations']):
start_time = time.perf_counter()
dtext = [("Iteration %d" % iteration, False)] # Only output to console
state = robot_server.getDataFromRobot(parameters, dtext)
prediction = TrackingFilter.particleFilter(parameters, state, dtext)
elapsed_time = time.perf_counter() - start_time
dtext.append(("TT:%f" % elapsed_time, False))
for field in dtext:
print(field[0], end=" ")
print()
if parameters['plotGraphics']:
filename = parameters['outputPath'] + "/iteration" + str(iteration)
Display.Display(parameters, filename, dtext, prediction)
if parameters['plotSamples']:
self.datalogger_object.plotSamples(
parameters,
parameters['outputPath'] + "/lidar" + str(iteration))
def runGame(self):
for i in range(10):
globals()["bird" + str(i)] = Bird()
globals()["bird" + str(i) + "Show"] = 1
globals()["bird" + str(i)].birdPosition = (BirdPosition[0],
np.random.randint(
200, 300))
vector = Vector
arena = Arena()
pipeHeight = arena.upperPipe1.get_height()
running = True
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
surface = pygame.Surface(screen.get_size())
surface = surface.convert()
clock = pygame.time.Clock()
passing = [1] * 10
while running:
clock.tick(30)
arena.moveImage()
arena.drawBackground(surface)
arena.drawPipe(surface)
arena.drawBase(surface)
arena.drawScore(surface)
sum = 0
for i in range(10):
if passing[i] == 1:
globals()["bird" + str(i) +
"Show"], pipePosition = self.gameOver(
eval("bird" + str(i)), arena)
eval("bird" + str(i)).drawBIrd(surface)
eval("bird" + str(i)).movement()
passing[i] = globals()["bird" + str(i) + "Show"]
horizontalDistance, verticalDistance = vector.distance(
eval("bird" + str(i)).birdPosition, pipePosition,
pipeHeight)
input = np.array([horizontalDistance, verticalDistance])
# Working with Neural Network
feedForward = self.neuralNetwork.feedForward(
input,
eval("neuralNetwork" + str(i))[0],
eval("neuralNetwork" + str(i))[1])
eval("bird" + str(i)).neuralNetworkJump(feedForward)
elif passing[i] == 0:
continue
screen.blit(surface, (0, 0))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if np.sum(passing) == 0:
break
def execute_attack(self):
arena = Arena(self.player, self.level.get_current_room().creature)
arena.attack()
# all players
rp = RandomPlayer(g).play
gp = GreedyGoPlayer(g).play
hp = HumanGoPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint(
'./trained_models/go/', 'best.pth.tar'
) #./pretrained_models/tictacote/keras/, best-25eps-25sim-10epch
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda state, player: np.argmax(
mcts1.getActionProb(state, player, temp=0))
if human_vs_cpu:
player2 = hp
else:
n2 = NNet(g)
n2.load_checkpoint('./trained_models/go/', 'best.pth.tar')
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda state, player: np.argmax(
mcts2.getActionProb(state, player, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
arena = Arena.Arena(n1p, player2, g, display=GoGame.display)
print(arena.playGames(2, verbose=True))
