def __call__(self, x: NDArray) -> NDArray:
"""Evaluate randomized IR (i.e. its random realization) at given points
Args:
x (NDArray): query points for IR. If x is 1D, single realization of RIR is evaluated;
if x is 2D, signature is (N_query, N_batch): for each row new realization is generated
Returns:
NDArray: realization of randomized IR, same size
"""
if len(x.shape) == 1:
x = x.reshape((x.size, 1))
N_query, N_batch = x.shape
if self.factor_generator is not None:
factors = self.factor_generator(N_batch).reshape((1, N_batch))
else:
factors = np.ones((1, N_batch))
if self.base_ir_type == 'frozen':
realization_interp = self._interp_realization(self.base_ir_frozen)
y = realization_interp(x).reshape((N_query, N_batch))
elif self.base_ir_type == 'generated':
y = np.zeros((N_query, N_batch))
for i_batch, x_query in enumerate(x.T):
realization_interp = self._interp_realization(self.base_ir_generator())
y[:, i_batch] = realization_interp(x_query)
return factors * y
def encode_state(self, image: NDArray):
"""
Function for converting the image got from the environment to
its feature-representation
Args:
image: Image obtained from the environment
Returns:
Feature-state representation of the image given
"""
in_image = image.reshape((1, ) + image.shape)
return self.features(in_image)
def __init__(self,
obs: NDArray,
n_outputs: int,
kernel=(3, 3),
padding='same',
stride=2,
nFilters=32):
super(InvModel, self).__init__()
inp_layer = tf.keras.Input(shape=obs.shape)
self.conv1 = tf.keras.layers.Conv2D(nFilters,
kernel,
strides=stride,
padding=padding,
activation='elu')
self.conv2 = tf.keras.layers.Conv2D(nFilters,
kernel,
strides=stride,
padding=padding,
activation='elu')
self.conv3 = tf.keras.layers.Conv2D(nFilters,
kernel,
strides=stride,
padding=padding,
activation='elu')
self.conv4 = tf.keras.layers.Conv2D(nFilters,
kernel,
strides=stride,
padding=padding,
activation='elu')
self.flat1 = tf.keras.layers.Flatten()
self.concat = tf.keras.layers.Concatenate(axis=1)
self.dense1 = tf.keras.layers.Dense(256, activation='elu')
self.dense2 = tf.keras.layers.Dense(n_outputs, activation='softmax')
self.features_out = self.flat1(
self.conv4(self.conv3(self.conv2(self.conv1(inp_layer)))))
self.features = tf.keras.Model(inputs=[inp_layer],
outputs=[self.features_out],
name='Inverse Model')
state = self.features(obs.reshape((1, ) + obs.shape))
self.prevState = tf.convert_to_tensor(state, dtype=tf.float32)
self.out = self.call(inp_layer)
super(InvModel, self).__init__(inputs=inp_layer, outputs=self.out)
def concat_vectors_as_cols(v1: NDArray, v2: NDArray) -> NDArray:
n = v1.size
return np.concatenate((v1.reshape(n, 1), v2.reshape(n, 1)), axis=1)