class LearningOptimizer(object):
    """docstring for LearningOptimizer"""

    def __init__(self):
        self.game = CoopGame(render=False, max_moves=1000)

    def run(self, players, teams, learn_max, **kwargs):
        assert len(players) == teams[0] * teams[1]

        results = np.zeros((teams[0], teams[1], 2))

        # Initialize all of the players once
        for t in range(teams[0]):
            for p in range(teams[1]):
                players[t * teams[1] + p].initialize_player(t, p)

        learn_every = 100
        for learning in range(learn_max):
            print("Starting Round {}".format(learning + 1))
            start = time()

            for i in range(learn_every):
                self.game.play(players, results)
            mid = time()
            print("Played {} matches in {}s, learning...".format(learn_every, mid - start))

            for player in players:
                player.learn()
                player.reset()

            end = time()
            print("Finished Round {} in {}s".format(learning + 1, end - start))
            print("-" * 20)
 def __init__(self):
     self.game = CoopGame(render=False, max_moves=1000)
Ejemplo n.º 3
0
 def __init__(self, game_format):
     self.format = game_format
     self.game = CoopGame(
         render=False,
         max_moves=1000
     )
Ejemplo n.º 4
0
class TeamTournament(object):
    """
    Takes a set of populations of neural nets and has them compete in a
    tournament to determine fitness
    """

    results = None

    def __init__(self, game_format):
        self.format = game_format
        self.game = CoopGame(
            render=False,
            max_moves=1000
        )

    def setup(self, populations, players):
        self.rounds = 0
        self.numGames = 0
        self.players = players
        self.populations = populations

        if(self.results == None):
            self.results = np.zeros((populations.shape[0], populations.shape[1], 2), dtype=np.float32)
        else:
            self.results.fill(0.0)

    def _generateMatchups(self, min_matches=10):
        """
        Generate a list of matchups, ensures all players get at least min_match
        matches
        """
        shape = self.populations.shape

        teams = np.zeros((shape[0], self.format[1]))
        for t_index in range(shape[0]):
            for p_index in range(shape[1]):

                for match in range(min_matches):
                    #Assemble teams for each player
                    for t in range(shape[0]):
                        teams[t, :] = np.random.choice(range(shape[1]), self.format[1], replace=False)

                    #Ensure that player is in the game!
                    if(p_index not in teams[t_index,:]):
                        teams[t_index, 0] = p_index

                    yield teams


    def _oneGame(self):
        """ play one game between teams of agents"""
        self.numGames += 1
        return self.game.play(self.players, self.results)

    def play_tournament(self, populations, players, repeat=1):
        """ Play agents against one another """
        self.setup(populations, players)

        for dummy in range(repeat):
            self.rounds += 1

            for teams in self._generateMatchups():

                # Prepare the players
                for t in range(teams.shape[0]):
                    for p in range(teams.shape[1]):
                        self.players[t*teams.shape[1] + p].initialize_player(t,teams[t][p])
                        self.players[t*teams.shape[1] + p].set_params(self.populations[t,teams[t][p],:])

                self._oneGame()

                # Retrieve the players
                for t in range(teams.shape[0]):
                    for p in range(teams.shape[1]):
                        self.populations[t,teams[t][p],:] = self.players[t*teams.shape[1] + p].get_params()

        self.results[:,:,0] /= self.results[:,:,1]
        return self.results[:,:,0]
Ejemplo n.º 5
0
import pickle
import numpy as np

from colearning.game import CoopGame
from colearning.players import TurretPlayer

print("Loading players from players.cln...")
with open("players.cln", "r") as f:
    players = pickle.load(f)

#players = [TurretPlayer(), TurretPlayer()]
#players[0].initialize_player(0,0)
#players[1].initialize_player(1,0)

for player in players:
    print(type(player))

teams = (2, 1)
results = np.zeros((teams[0], teams[1], 2))

game = CoopGame(
    render=True,
    max_moves=1000
)

print("Playing game...")
game.play(players, results)