def predict_next_block(self,
X_block,
X_position,
block_override=-1,
blacklist=[],
block_preds=None):
if block_override != -1:
next_block = block_override
else:
if block_preds is None:
block_preds = self.block_model.predict(X_block)[0]
block_preds = block_preds * TECH_BLOCK_WEIGHTS
for bid in blacklist:
block_preds[bid - 1] = 0
next_block = self.sample(block_preds) + 1
for i in range(1, self.lookback):
X_position[0][i - 1] = X_position[0][i]
X_position[0][-1] = block_to_vec((next_block, 0, 0, 0, 0),
self.inp_len, len(STADIUM_BLOCKS),
self.scaler, False)
pos_preds = self.position_model.predict(X_position)
pos_vec, pos_rot = self.unpack_position_preds_vector(pos_preds)
return (next_block, pos_vec[0], pos_vec[1], pos_vec[2],
pos_rot), block_preds
def append_blocks(blocks_in, block_out, X, y_pos, y_rot):
end_idx = len(blocks_in) - 1
X.append([
block_to_vec(block, INP_LEN, len(STADIUM_BLOCKS), scaler, i != end_idx)
for i, block in enumerate(blocks_in)
])
y_pos.append(block_out[BX:BZ + 1])
y_rot.append(one_hot_rotation(block_out[BROT]))
def prepare_inputs(self):
X_block = np.zeros((1, self.lookback, len(STADIUM_BLOCKS)),
dtype=np.bool)
X_position = np.zeros((1, self.lookback, self.inp_len))
blocks = self.gmap.track[-self.lookback:]
i = -1
for block in reversed(blocks):
X_position[0][i] = block_to_vec(block, self.inp_len,
len(STADIUM_BLOCKS), self.scaler,
True)
X_block[0][i] = one_hot_bid(block[BID], len(STADIUM_BLOCKS))
i -= 1
return X_block, X_position
def prepare_inputs(self):
'''
Prepares the block and position vector encodings used by predict_next_block.
Returns:
tuple: (X_block: np.array, X_position: np.array)
'''
X_block = np.zeros((1, self.lookback, len(STADIUM_BLOCKS)), dtype=np.bool)
X_position = np.zeros((1, self.lookback, self.inp_len))
blocks = self.gmap.track[-self.lookback:]
i = -1
for block in reversed(blocks):
X_position[0, i] = block_to_vec(block, self.inp_len, len(STADIUM_BLOCKS), self.scaler, True)
X_block[0, i] = one_hot_bid(block[BID], len(STADIUM_BLOCKS))
i -= 1
return X_block, X_position
def predict_next_block(self, X_block: np.array, X_position: np.array, block_override: int=-1,
blacklist: list=[], block_preds: np.array=None):
'''
Predicts the next block in the main building loop.
Asks the block model for prediction of the next block type
based on the encoded previous blocks and then feeds the
output to the position model.
Args:
X_block (np.array): encoded block types of shape (1, lookback, blocks_len)
X_position (np.array): encoded blocks of shape (1, lookback, inp_len)
block_override (int): the block type to use instead of predicting it
blacklist (list): the list containing block IDs that should not
be considered when sampling
block_preds (list): cached array of block predictions from the previous
prediction, used when backtracking
Returns:
tuple: (predicted_block: tuple, block_preds: np.array)
'''
if block_override != -1:
next_block = block_override
else:
if block_preds is None:
block_preds = self.block_model.predict(X_block)[0]
block_preds = block_preds * TECH_BLOCK_WEIGHTS
block_preds[np.asarray(blacklist, dtype=int) - 1] = 0
next_block = self.sample(block_preds) + 1
X_position = np.roll(X_position, -1, 1)
X_position[0, -1] = block_to_vec((next_block, 0, 0, 0, 0), self.inp_len, len(STADIUM_BLOCKS), self.scaler, False)
pos_preds = self.position_model.predict(X_position)
pos_vec, pos_rot = self.unpack_position_preds_vector(pos_preds)
return (next_block, *pos_vec, pos_rot), block_preds