def __getitem__(self, index):
try:
if isinstance(index, slice):
molecules = []
info = list(self._molecules_ordered_all_gen())
for info in islice_extended(self._molecules_ordered_all_gen(),
index.start, index.stop,
index.step):
itp_index, gro_start, gro_end = info
residues = self.system_gro[gro_start:gro_end]
mol = self.different_molecules[itp_index].copy(residues)
molecules.append(mol)
return molecules
elif isinstance(index, int):
if index == -1:
info = last(self._molecules_ordered_all_gen())
else:
info = next(
islice_extended(self._molecules_ordered_all_gen(),
index, index + 1))
itp_index, gro_start, gro_end = info
residues = self.system_gro[gro_start:gro_end]
mol = self.different_molecules[itp_index].copy(residues)
return mol
else:
raise TypeError(('System indices must be integers or slices,'
f' not {type(index)}.'))
except StopIteration:
raise IndexError('Molecule index out of range')
def __getitem__(self, index):
try:
if isinstance(index, slice):
molecules = []
for _, start, len_mol in islice_extended(
self._molecules_ordered_all_gen(), index.start,
index.stop, index.step):
self._open_fgro.seek_atom(start)
molecules.append(
Residue([
AtomGro(next(self._open_fgro))
for _ in range(len_mol)
]))
return molecules
if isinstance(index, int):
if index == -1:
info = last(self._molecules_ordered_all_gen())
else:
info = next(
islice_extended(self._molecules_ordered_all_gen(),
index, index + 1))
_, start, len_mol = info
self._open_fgro.seek_atom(start)
return Residue(
[AtomGro(next(self._open_fgro)) for _ in range(len_mol)])
else:
raise TypeError(
('SystemGro indices must be integers or slices,'
f' not {type(index)}.'))
except StopIteration:
raise IndexError('Residue index out of range')
def write_to_folder(self,
folder: pathlib.Path,
*,
chunk: int = 10,
max_length: Optional[int] = None) -> Iterator[State]:
from .animating import animate
### Preparing folder: #################################################
# #
if not folder.exists():
folder.mkdir(parents=True)
assert folder.is_dir()
assert not any(folder.iterdir())
# #
### Finished preparing folder. ########################################
paths = ((folder / f'{i:06d}.json') for i in range(10**6))
state_iterator, state_iterator_copy = itertools.tee(
self.culture.iterate_game(self, max_length=max_length))
transition_iterator = animate(state_iterator_copy)
for path in paths:
chunked_iterator = more_itertools.islice_extended(
zip(state_iterator, transition_iterator, strict=True))[:chunk]
transition_chunk = []
for state, transition in chunked_iterator:
transition_chunk.append(transition)
yield state
if not transition_chunk:
# Game ended, either naturally or reached `max_length`.
return
assert len(transition_chunk) <= chunk
with path.open('w') as file:
json.dump(transition_chunk, file)
def make_initial(culture: Culture, *, board_size: int, starting_score: int = 0,
concurrent_food_tiles: int = 40) -> State:
n_players = len(culture.strategies)
random_positions_firehose = utils.iterate_deduplicated(
State.iterate_random_positions(board_size=board_size))
random_positions = tuple(
more_itertools.islice_extended(
random_positions_firehose)[:(n_players + concurrent_food_tiles)]
)
player_positions = random_positions[:n_players]
food_positions = frozenset(random_positions[n_players:])
assert len(food_positions) == concurrent_food_tiles
player_id_to_observation = {}
for letter, player_position in zip(LETTERS, player_positions):
player_id_to_observation[letter] = Observation(state=None, position=player_position,
score=starting_score, letter=letter,
last_action=None)
state = State(
culture=culture,
board_size=board_size,
player_id_to_observation=ImmutableDict(player_id_to_observation),
food_positions=food_positions,
)
for observation in player_id_to_observation.values():
observation.state = state
return state
def __getitem__(self, key: Union[int, slice]) -> Union[Any, "ObjectQuery"]:
"""
If key is an integer it evaluates query and returns item.
If key is a slice it returns another unevaluated ObjectQuery.
Parameters
----------
key: Union[int, slice]
Key represents index of item or slice object.
Returns
-------
Union [Any, ObjectQuery]
Returns item or list of items.
Examples
--------
>>> ObjectQuery(range(10))[5]
5
>>> list(ObjectQuery(range(10))[5:0:-1])
[5, 4, 3, 2, 1]
"""
if isinstance(key, slice):
return self.__class__(
islice_extended(self.objects_source, key.start, key.stop,
key.step))
return self._evaluate_query()[key]
def get_page_iterator(self, block_start, page):
# we always skip the last blocks of the page which corresponds to the footer
blocks = page.blocks[block_start:len(page.blocks) -
self.nb_blocks_footer_]
iterator = iter(self.get_next_word_from_blocks(blocks))
if self.nb_words_footer_ != 0:
return mit.islice_extended(iterator, None, -self.nb_words_footer_)
return iterator
def total_payoff(self, *, start: int = 0, discount: numbers.Real = 1):
assert start >= 0
assert 0 <= discount <= 1
wip_payoff = collections.defaultdict(lambda: 0)
payoffs = more_itertools.islice_extended(self.payoffs)[start:]
for i, payoff in enumerate(payoffs):
for player_id, reward in payoff.items():
wip_payoff[player_id] += (discount ** i) * reward
return aggregating.Payoff(wip_payoff)
def __init__(self, n_players: int = 20, *, board_size: int = 20,
core_strategies: Optional[Sequence[_GridRoyaleStrategy]] = None) -> None:
self.board_size = board_size
self.core_strategies = tuple(core_strategies or (Strategy(self) for _
in range(N_CORE_STRATEGIES)))
self.strategies = tuple(more_itertools.islice_extended(
itertools.cycle(self.core_strategies))[:n_players])
# self.executor = concurrent.futures.ProcessPoolExecutor(5)
gamey.Culture.__init__(self, state_type=State,
player_id_to_strategy=dict(zip(LETTERS, self.strategies)))
def test_simple():
culture = Culture({'A': Policy()})
game = Game.from_state_culture(State.make_initial(n_players=1), culture)
assert len(game) == 1
(state_0, ) = game.states
assert isinstance(state_0, State)
assert len(
state_0.food_positions) == grid_royale.constants.DEFAULT_N_FOOD_TILES
assert len(state_0) == 1 # One player makes for one observation.
assert state_0.board_size == grid_royale.constants.DEFAULT_BOARD_SIZE
assert not state_0.is_end
assert not state_0.bullets
state_0_again, state_1, state_2 = more_itertools.islice_extended(game)[:3]
assert state_0 is state_0_again
assert type(state_0) is type(state_1) is type(state_2) is State
assert len(game) == 3
observation: Observation = state_2['A']
assert observation.legal_actions
def cartesian_view(tensor1: torch.Tensor, tensor2: torch.Tensor, start: int,
end: int) -> Tuple[torch.Tensor, torch.Tensor]:
assert tensor1.dim() == tensor2.dim()
start1, start2 = tensor1.size()[:start], tensor2.size()[:start]
end1, end2 = tensor1.size()[end:], tensor2.size()[end:]
mid1, mid2, mid_common = [], [], []
for dim1, dim2 in islice_extended(zip(tensor1.size(), tensor2.size()),
start, end):
if dim1 != dim2:
mid1.extend((dim1, 1))
mid2.extend((1, dim2))
mid_common.extend((dim1, dim2))
else:
mid1.append(dim1)
mid2.append(dim2)
mid_common.append(dim1)
tensor1 = tensor1.view(*start1, *mid1,
*end1).expand(*start1, *mid_common, *end1)
tensor2 = tensor2.view(*start2, *mid2,
*end2).expand(*start2, *mid_common, *end2)
return tensor1, tensor2
self.train_iterate(make_initial_state,
n_games=n_games,
max_game_length=max_game_length,
n_phases=n_phases))
def train_iterate(self,
make_initial_state: Callable[[], gamey.State],
*,
n_games: int = 1_000,
max_game_length: Optional[int] = None,
n_phases: Optional[int] = None) -> Iterable[Policy]:
from .gaming import Game
culture = self
games = []
games_buffer_max_size = 10 * n_games
for _i_phase in more_itertools.islice_extended(
itertools.count())[:n_phases]:
games.extend(
Game.from_state_culture(make_initial_state(), culture)
for _ in range(n_games))
if len(
games
) >= games_buffer_max_size: # Truncate to avoid memory leaks
del games[:-games_buffer_max_size]
Game.multi_crunch(games, n=max_game_length)
culture = type(self)({
player_id: policy.train(
tuple(game.narratives[player_id] for game in games))
for player_id, policy in culture.items()
})
yield culture
def multi_crunch(games: Sequence[Game], n: Optional[int] = None) -> None:
for _ in more_itertools.islice_extended(Game.multi_iterate(games))[:n]:
pass
def crunch(self, n: Optional[int] = None) -> None:
for _ in more_itertools.islice_extended(self)[:n]:
pass
assert self.states[-1].is_end or len(self.states) == n
import fileinput
from more_itertools import islice_extended
for line in islice_extended(fileinput.input(), -10, None):
print(line, end='')
