def __init__(self, creator: TensorCreator, device, params: CartographicParams):
self._params = params.clone()
super().__init__(device)
self.map_rgb = creator.zeros(
self._params.shape, device=device)
self.map_raw = creator.zeros(
self._params.shape[:-1], device=device)
self.cmap = cm.get_cmap(
self._params.colormap)
self.cnorm = colors.Normalize(
vmin=self._params.cmin,
vmax=self._params.cmax)
self.initdone = False
self.tartget_x = 0
self.tartget_y = 0
# Smoothing Kernel
if self._params.smoothing:
self.kernel = (torch.ones(
(self._params.kernel_shape[0],
self._params.kernel_shape[1]))) / (self._params.kernel_shape[0] * self._params.kernel_shape[1])
self.kernel = self.kernel.to(device='cuda')
self.kernel = self.kernel.unsqueeze(0).unsqueeze(0)
def __init__(self, creator: TensorCreator, network: nn.Module,
optimizer: Optimizer, storage: ObservationStorage,
params: NNetParams):
"""Unit constructor.
Args:
creator: creator of this node
network: pytorch neural network module
optimizer: pytorch optimizer object
storage: baselines observation storage object
params: baselines parameter object
"""
super().__init__(creator.device)
self.params = params
self.network = network
self.optimizer = optimizer
self.storage = storage
self.device = creator.device
self.output = creator.zeros(
SpaceEngineersConnectorConfig().task_to_agent_buffer_size,
dtype=self._float_dtype,
device=self._device)
self.label = creator.zeros(
SpaceEngineersConnectorConfig().task_to_agent_buffer_size,
dtype=self._float_dtype,
device=self._device)
self.task_control = creator.zeros(4, device=self._device)
self.cur_train_step = 0
self.last_train_loss = 0
def __init__(self, creator: TensorCreator, input_dims, device, channel_first=False):
super().__init__(device)
self.creator = creator
self._input_dims = input_dims
self._channel_first = channel_first
self.r_output_tensor = creator.zeros(input_dims, device=device, dtype=self._float_dtype)
self.g_output_tensor = creator.zeros(input_dims, device=device, dtype=self._float_dtype)
self.b_output_tensor = creator.zeros(input_dims, device=device, dtype=self._float_dtype)
self.concat_output_tensor = creator.zeros([input_dims[0]*3] + list(input_dims[1:]), device=device, dtype=self._float_dtype)
def __init__(self, creator: TensorCreator, seq: SequenceGenerator):
super().__init__(creator.device)
self._seq = seq
self._creator = creator
self.output = creator.zeros(1,
dtype=self._float_dtype,
device=self._device)
self.sequence_number = creator.zeros(1,
dtype=self._float_dtype,
device=self._device)
def __init__(self,
creator: TensorCreator,
lower_bound: int,
upper_bound: int,
random: np.random,
generate_new_every_n: int = 1,
generate_random_intervals=False):
super().__init__(creator.device)
self._generate_new_every_n = generate_new_every_n
self._next_generation = generate_new_every_n
self._step = -1
self._lower_bound = lower_bound
self._upper_bound = upper_bound
self._random = random
self._random_generation_intervals = generate_random_intervals
self._scalar_output = creator.full([1],
fill_value=FLOAT_NAN,
dtype=self._float_dtype,
device=self._device)
self._one_hot_output = creator.full([self._upper_bound],
fill_value=FLOAT_NAN,
dtype=self._float_dtype,
device=self._device)
self._current_value = creator.zeros((1, ), dtype=creator.long)
def __init__(self, creator: TensorCreator,
actions_descriptor: AgentActionsDescriptor):
super().__init__(creator.device)
self.action_output = creator.zeros(len(
actions_descriptor.action_names()),
dtype=self._float_dtype,
device=self._device)
def __init__(self,
creator: TensorCreator,
output_height: int,
output_width: int,
params: WeightedAvgNodeParams,
num_weights: int = 0):
super().__init__(creator.device)
self._params = params
self._creator = creator
if self._params.weights_on_input:
self.num_weights = num_weights
weights = np.ones((output_height, output_width, self.num_weights))
else:
assert len(
self._params.weights) != 0, 'Parametric weights not set!'
assert self._params.num_inputs == len(self._params.weights)
self.num_weights = len(self._params.weights)
weights = np.ones((output_height, output_width, self.num_weights))
for i in range(self.num_weights):
weights[i] = np.dot(weights[i], params.weights[i])
self.node_weights = creator.tensor(weights,
dtype=creator.float,
device=creator.device)
self.last_output = creator.zeros([output_width, output_height],
dtype=creator.float,
device=creator.device)
def __init__(self, output_shape, creator: TensorCreator,
squeeze_channel: bool):
super().__init__(creator.device)
self.output = creator.zeros(output_shape,
dtype=self._float_dtype,
device=self._device)
self._squeeze_channel = squeeze_channel
def __init__(self, creator: TensorCreator, device, mapping: torch.Tensor,
output_shape, dimension: int):
super().__init__(device)
self.dimension = dimension
self._mapping = mapping
self.output = creator.zeros(output_shape,
dtype=self._float_dtype,
device=device)
def __init__(self, func, output_shapes, creator: TensorCreator):
super().__init__(creator.device)
self.func = func
self.outputs = []
for shape in output_shapes:
self.outputs.append(
creator.zeros(shape,
dtype=self._float_dtype,
device=self._device))
def _init_node(self, creator: TensorCreator):
device = self._device
if self._seq_params is not None:
# each _init_node, also the new SequenceGenerator should be created (reset the current position etc)
# self._seq = SequenceGenerator.from_params(self._seq_params, random=self._random)
transition_probs = self._seq_params.transition_probs if self._seq_params.transition_probs is not None \
else SequenceGenerator.default_transition_probs(self._seq_params.seqs)
self._seq = SequenceGenerator(self._seq_params.seqs,
transition_probs,
random=self._random)
self._update_class_filter_by_sequences()
else:
self._seq = None
self._sanitize_class_filter()
class_filter = self._params.class_filter
dataset_result = self._dataset.get_filtered(
class_filter
) if class_filter is not None else self._dataset.get_all()
self._data = dataset_result.data.type(FLOAT_TYPE_CPU) / 255.0
self._labels = dataset_result.labels
self._data_seq = self._get_data_sequence_iterator()
# init the output tensors
self.label_tensor = creator.zeros(1, device=device, dtype=torch.int64)
self.output_sequence_id = creator.zeros(1,
device=device,
dtype=torch.int64)
self.output_data = creator.zeros((28, 28),
device=device,
dtype=self._float_dtype)
if self._params.one_hot_labels:
self.output_label = creator.zeros(10,
device=device,
dtype=self._float_dtype)
else:
self.output_label = creator.zeros(1,
device=device,
dtype=torch.int64)
def __init__(self, creator: TensorCreator, input_height: int,
input_width: int, output_height: int, output_width: int,
num_channels: int, params: FocusNodeParams):
super().__init__(creator.device)
self._width = output_width
self._height = output_height
self._num_channels = num_channels
self._params = params
self._creator = creator
self.last_mask = creator.zeros(
[input_height, input_width, num_channels],
dtype=creator.float,
device=creator.device)
self.last_output = creator.zeros(
[output_height, output_width, num_channels],
dtype=creator.float,
device=creator.device)
def __init__(self,
creator: TensorCreator,
shape: List[int],
distribution: Distribution = Distribution.Uniform,
amplitude: float = 1.,
has_input: bool = True):
super().__init__(creator.device)
self.distribution = distribution
self.amplitude = amplitude
if has_input:
self._image_buffer = creator.zeros(*shape,
dtype=self._float_dtype,
device=self._device)
self._random_numbers = creator.zeros(*shape,
dtype=self._float_dtype,
device=self._device)
self.output = creator.zeros(*shape,
dtype=self._float_dtype,
device=self._device)
def __init__(self, creator: TensorCreator,
params: DatasetSimplePointGravityParams, random: np.random):
super().__init__(creator.device)
self._random = random
self.point_pos = params.point_pos
self.attractor_distance = params.attractor_distance
self.output_data = creator.zeros(*params.canvas_shape,
device=self._device)
self._state = States.BLANK
self.move_strategy = params.move_strategy
self._frame_backbuffer = creator.zeros_like(self.output_data)
def __init__(self, creator: TensorCreator, output_height: int,
output_width: int, num_channels: int,
params: VisitedAreaParams):
super().__init__(creator.device)
self._creator = creator
self._params = params
self.last_visited_area = creator.zeros(
[output_height, output_width, num_channels],
dtype=creator.float,
device=creator.device)
def __init__(self,
creator: TensorCreator,
height: int,
width: int,
num_channels: int,
params: MotionDetectionParams):
super().__init__(creator.device)
self._height = height
self._width = width
self._num_channels = num_channels
self._params = params
self._has_previous_image = False
bw_shape = [self._height, self._width]
self.previous_image = creator.zeros(bw_shape, dtype=creator.float, device=creator.device)
self.temp_image = creator.zeros(bw_shape, dtype=creator.float, device=creator.device)
self.motion_map = creator.zeros(bw_shape, dtype=creator.float, device=creator.device)
def __init__(self,
creator: TensorCreator,
params: DatasetAlphabetParams,
random: Optional[RandomState] = None):
super().__init__(creator.device)
self._validate_params(params)
random = random or np.random.RandomState()
# Generate all symbols
generator = AlphabetGenerator(params.padding_right)
all_symbols = generator.create_symbols(params.symbols)
self.all_symbols = creator.zeros_like(all_symbols)
self.all_symbols.copy_(all_symbols.to(creator.device))
# Create output tensors
shape = list(self.all_symbols.shape)
self.output_data = creator.zeros(shape[1:], device=creator.device)
self.output_label = creator.zeros(1,
dtype=torch.int64,
device=creator.device)
self.output_sequence_id = creator.zeros(1,
dtype=torch.int64,
device=creator.device)
self.output_sequence_id_one_hot = creator.zeros(
(1, len(params.sequence_probs.seqs)),
dtype=self._float_dtype,
device=creator.device)
if params.mode == DatasetAlphabetMode.SEQUENCE_PROBS:
seqs = [
self.convert_string_to_positions(params.symbols, seq)
for seq in params.sequence_probs.seqs
]
transition_probs = params.sequence_probs.transition_probs or SequenceGenerator.default_transition_probs(
seqs)
self.seq = SequenceGenerator(seqs, transition_probs, random=random)
self._current = next(self.seq)
self._n_symbols = shape[0]
def __init__(self, creator: TensorCreator, noise_amplitude=0.2):
super().__init__(creator.device)
self._noise_amplitude = noise_amplitude
self.bitmap = creator.zeros([1, 2],
dtype=self._float_dtype,
device=self._device)
self._current_step = 0
self._data = creator.tensor([[0., 0], [1., 0], [0., 1], [1, 1]],
dtype=self._float_dtype,
device=self._device)
self._no_data = self._data.shape[1]
def __init__(self, creator: TensorCreator,
params: DisentangledWorldNodeParams):
super().__init__(creator.device)
self._params = copy.copy(params)
self._render_world = params.render_world_class(
(params.sx, params.sy), **params.render_world_params)
width = self._render_world.world_size[0]
height = self._render_world.world_size[1]
self.bitmap = creator.zeros((width, height, 3),
dtype=self._float_dtype,
device=self._device)
def __init__(self,
creator: TensorCreator,
data_size: Tuple[int, ...],
input_dims: Tuple[int, int, int],
parent_rf_dims: Size2D,
parent_rf_stride_dims: Stride = None,
flatten_output_grid_dimensions=False):
super().__init__(creator.device)
self._parent_rf_dims = parent_rf_dims
self._parent_rf_stride_dims = parent_rf_stride_dims
self.creator = creator
self._rf_mapping = self.create_rf_mapping(input_dims,
parent_rf_dims,
parent_rf_stride_dims,
flatten_output_grid_dimensions,
self._device)
self.output_tensor = creator.zeros(data_size, device=self._device, dtype=self._float_dtype)
def __init__(self, creator: TensorCreator, input_tensor_shapes, dtype, dim=0, flatten=False):
"""Usage of flatten: flatten input vectors first."""
super().__init__(creator.device)
self._flatten = flatten
self._dim = dim
self._input_tensor_shapes = input_tensor_shapes
if not flatten:
output_dims = list(input_tensor_shapes[0])
output_dims[dim] = 0
for input_shape in input_tensor_shapes:
self._check_shape(input_shape, output_dims, dim)
output_dims[dim] += input_shape[dim]
else:
self._flatten_input_shapes = [reduce(lambda a, b: a * b, x) for x in input_tensor_shapes]
output_dims = (sum(self._flatten_input_shapes),)
self.output = creator.zeros(*output_dims, dtype=dtype, device=self._device)
def __init__(self, creator: TensorCreator, dim, input_shape, split_sizes,
dtype):
super().__init__(creator.device)
self._input_shape = input_shape
self._split_sizes = split_sizes
self._dim = dim
self.output_tensors = []
self._indices = []
if -1 in split_sizes:
raise InvalidParameterException(
"Automatic split size not supported")
input_dim_size = input_shape[dim]
outputs_size = sum(split_sizes)
if outputs_size > input_dim_size:
message = f"The combined output size ({outputs_size} is larger than dimension {dim}: {input_dim_size})"
raise InvalidParameterException(message)
split_start = 0
for split in split_sizes:
output_dims = list(input_shape)
output_dims[dim] = split
output_tensor = creator.zeros(output_dims,
dtype=dtype,
device=self._device)
self.output_tensors.append(output_tensor)
# Create the index which will be used for the data splitting.
index = creator.arange(split_start,
split_start + split,
dtype=torch.long,
device=self._device)
self._indices.append(index)
split_start += split
def __init__(self, input_shape, random: np.random.RandomState,
creator: TensorCreator, first_non_expanded_dim, n_outputs,
n_samples):
super().__init__(creator.device)
self.n_outputs = n_outputs
input_shape = tuple(input_shape)
total_size = dim_prod(input_shape[first_non_expanded_dim:])
filters_sparse = []
self.counts = torch.zeros(input_shape[first_non_expanded_dim:],
dtype=self._float_dtype,
device=self._device)
for _ in range(n_outputs):
filter_dense = random.choice(total_size, n_samples, replace=False)
filter_sparse = np.zeros(total_size)
filter_sparse[filter_dense] = 1
filter_sparse = torch.tensor(filter_sparse,
dtype=self._float_dtype,
device=self._device)
filter_sparse = filter_sparse.view(
input_shape[first_non_expanded_dim:])
self.counts += filter_sparse
filter_sparse = filter_sparse.expand(input_shape)
filters_sparse.append(filter_sparse)
self.filters = filters_sparse
if (self.counts == 0).any().item() == 1:
logger.warning("Some subset of receptive field is not included.")
self.counts = self.counts.expand(input_shape)
self.output_tensors = \
[creator.zeros(input_shape, dtype=self._float_dtype, device=self._device) for _ in range(n_outputs)]
def __init__(self, creator: TensorCreator, input_shape, start_dim: int, end_dim: int):
super().__init__(creator.device)
if start_dim < 0:
start_dim = len(input_shape) + start_dim
if end_dim < 0:
end_dim = len(input_shape) + end_dim
if not (0 <= start_dim < len(input_shape)):
raise ValueError(f"start_dim {start_dim} out of input_shape {input_shape}.")
if not (0 <= end_dim < len(input_shape)):
raise ValueError(f"end_dim {end_dim} out of input_shape {input_shape}.")
self.input_shape = input_shape
self.start_dim = start_dim
self.end_dim = end_dim
dim_product = int(torch.prod(torch.tensor(input_shape[start_dim:end_dim + 1])).item())
self.new_shape = input_shape[:start_dim] + (dim_product,)
if end_dim + 1 < len(input_shape):
self.new_shape += input_shape[end_dim + 1:]
self.output = creator.zeros(tuple(self.new_shape), dtype=self._float_dtype, device=self._device)
def __init__(self, creator: TensorCreator, shape, dim):
super().__init__(creator.device)
self.dim = dim
self.output = creator.zeros(shape, dtype=self._float_dtype, device=creator.device)
def __init__(self, creator: TensorCreator, params: GridWorldParams):
super().__init__(creator.device)
self.validate_params(params)
self.params = params
# render a world map
tile_size = self.params.tile_size
width = self.params.world_width * self.params.tile_size
height = self.params.world_height * self.params.tile_size
self.bit_map = creator.zeros([height, width], dtype=torch.uint8)
if isinstance(creator, MeasuringCreator):
self.last_image = creator.zeros([height, width], dtype=self._float_dtype, device=self._device)
self.circle = creator.zeros([tile_size, tile_size], dtype=self._float_dtype, device=self._device)
self.circle_wall = creator.zeros([tile_size, tile_size, 3], dtype=self._float_dtype, device=self._device)
self.triangle_wall = creator.zeros([tile_size, tile_size, 3], dtype=self._float_dtype, device=self._device)
else:
self.circle = interpolate(creator.tensor(self.circle_template).view(1, 1, 9, 9),
size=[tile_size, tile_size]).view(tile_size, tile_size).type(torch.uint8)
self.triangle_wall = interpolate(creator.tensor(self.triangle_wall_template).view(1, 1, 9, 9),
size=[tile_size, tile_size]).view(tile_size, tile_size).type(torch.uint8)
self.circle_wall = interpolate(creator.tensor(self.circle_wall_template).view(1, 1, 9, 9),
size=[tile_size, tile_size]).view(tile_size, tile_size).type(torch.uint8)
self.bit_map_last_action = creator.zeros([height + 1, width], dtype=self._float_dtype, device=self._device)
self.bit_map_padding = width - 4
self.render_map(self.bit_map)
self.pos = creator.tensor(self.params.agent_pos[::-1], dtype=self._float_dtype, device=self._device)
self.last_position = creator.zeros(2, dtype=self._float_dtype, device=self._device)
self.last_position_one_hot_matrix = creator.zeros((params.world_height, params.world_width),
dtype=self._float_dtype, device=self._device)
self.last_action = creator.zeros(4, dtype=self._float_dtype, device=self._device)
self.reward = creator.zeros(1, dtype=self._float_dtype, device=self._device)
width = self.params.egocentric_width * self.params.tile_size
height = self.params.egocentric_height * self.params.tile_size
self.egocentric_image = creator.zeros((width, height), dtype=self._float_dtype, device=self._device)
self.ego_last_action = creator.zeros((width+1, height), dtype=self._float_dtype, device=self._device)
self.ego_padding = height - 4
if not isinstance(creator, MeasuringCreator):
# Initial rendering of the outputs, all further renderings will be just updates
self.last_image = creator.tensor(self.bit_map, dtype=self._float_dtype, device=self._device)
self.last_position.copy_(self.pos)
self._render_outputs()
def __init__(self, params: ExpertParams, creator: TensorCreator = None):
"""Initialises the flock.
Args:
params (ExpertParams): The contain for the parameters which will be used for this flock
creator (TensorCreator): The creator which will allocate the tensors
"""
super().__init__(params, creator.device)
self.n_cluster_centers = params.n_cluster_centers
self.flock_size = params.flock_size
self.enable_learning = params.spatial.enable_learning
float_dtype = get_float(self._device)
sp_params = params.spatial
self.input_size = sp_params.input_size
self.buffer_size = sp_params.buffer_size
self.batch_size = sp_params.batch_size
self.learning_period = sp_params.learning_period
self.max_boost_time = sp_params.max_boost_time
self.cluster_boost_threshold = sp_params.cluster_boost_threshold
self.learning_rate = sp_params.learning_rate
self._boost = sp_params.boost
self._sampling_method = sp_params.sampling_method
self.buffer = SPFlockBuffer(creator=creator,
flock_size=self.flock_size,
buffer_size=self.buffer_size,
input_size=self.input_size,
n_cluster_centers=self.n_cluster_centers)
# The initial clusters are randomised
self.cluster_centers = creator.zeros(
(self.flock_size, self.n_cluster_centers, self.input_size),
device=self._device,
dtype=float_dtype)
self.initialize_cluster_centers()
self.cluster_boosting_durations = creator.full(
(self.flock_size, self.n_cluster_centers),
fill_value=self.cluster_boost_threshold,
device=self._device,
dtype=creator.int64)
self.prev_boosted_clusters = creator.zeros(
(self.flock_size, self.n_cluster_centers),
device=self._device,
dtype=creator.uint8)
# For holding the targets and deltas of the cluster centers
self.cluster_center_targets = creator.zeros(
(self.flock_size, self.n_cluster_centers, self.input_size),
device=self._device,
dtype=float_dtype)
self.cluster_center_deltas = creator.zeros(
(self.flock_size, self.n_cluster_centers, self.input_size),
device=self._device,
dtype=float_dtype)
self.boosting_targets = creator.zeros(
(self.flock_size, self.n_cluster_centers),
device=self._device,
dtype=creator.int64)
self.tmp_boosting_targets = creator.zeros(
(self.flock_size, self.n_cluster_centers),
device=self._device,
dtype=creator.int64)
# Output tensor of cluster center vectors into which to integrate the forward pass stuff
self.forward_clusters = creator.zeros(
(self.flock_size, self.n_cluster_centers),
device=self._device,
dtype=float_dtype)
self.predicted_clusters = creator.zeros(
(self.flock_size, self.n_cluster_centers),
device=self._device,
dtype=float_dtype)
self.current_reconstructed_input = creator.zeros(
(self.flock_size, self.input_size),
device=self._device,
dtype=float_dtype)
self.predicted_reconstructed_input = creator.zeros(
(self.flock_size, self.input_size),
device=self._device,
dtype=float_dtype)
# How many times did the spatial pooler forward and learning process run
self.execution_counter_forward = creator.zeros((self.flock_size, 1),
device=self._device,
dtype=creator.int64)
self.execution_counter_learning = creator.zeros((self.flock_size, 1),
device=self._device,
dtype=creator.int64)
def _cat_dim_1(creator: TensorCreator):
return creator.cat([creator.zeros((3, 1)), creator.ones((3, 3))], dim=1)
def _zeros_single_dim(creator: TensorCreator):
return creator.zeros(6, device='cpu')
def _zeros(creator: TensorCreator):
return creator.zeros((6, 5, 2), device='cpu')