def noise(self, value):
if value is None:
self._noise = None
else:
v = torch.as_tensor(value)
assert v > 0
self._noise = Parameter(free_form(v))
self.params.append(self._noise)
def signal(self, value):
if value is None:
self._signal = None
else:
v = torch.as_tensor(value)
assert v > 0
self._signal = Parameter(free_form(v))
self.params.append(self._signal)
def scales(self, value):
if value is None:
v = torch.ones(self.soap.dim)
else:
v = torch.as_tensor(value).view(-1)
assert (v > 0).all()
self._scales = Parameter(free_form(v))
self.params.append(self._scales)
def __init__(self, X, Z, Y, chunks=None, derivatives=None):
super(GPR, self).__init__() # TODO: if Z is None: do full GPR
self.X = X
# values
if Y is not None:
self.chunks = chunks
if chunks: # TODO: generalize Const mean to more general types
_s = torch.as_tensor(chunks).type(Y.dtype)
self.mean = (Y / _s).mean()
else:
_s = 1
self.mean = Y.mean()
data = [Y - self.mean * _s]
self.use_values = True
else:
self.mean = 0
data = []
self.use_values = False
# derivatives
if derivatives is not None:
self.dX_dt = torch.as_tensor(derivatives[0])
data += [torch.as_tensor(derivatives[1]).view(-1)]
self.use_derivatives = True
else:
self.use_derivatives = False
# parameters
self._noise = Parameter(free_form(torch.tensor(1., dtype=X.dtype)))
self.Z = Z # Parameter or not is controled from SparseGPR
self.kern = RBF(torch.ones_like(X[0]), torch.tensor(1., dtype=X.dtype))
# combine values and derivatives:
self.Y = torch.cat(data)
self.zeros = torch.zeros_like(self.Y)
self.ones = torch.ones_like(self.Y)
def __init__(self, dim, tasks):
super().__init__()
# TODO: this is redundant as only diagonal elements are used
self._scale = Parameter(free_form(torch.ones(tasks, tasks, dim)))
self._variance = Parameter(free_form(torch.ones(tasks, tasks)))
def __init__(self, scale, variance):
super(Cauchy, self).__init__()
self._scale = Parameter(free_form(scale))
self._variance = Parameter(free_form(variance))
def beta(self, value):
self._beta = Parameter(free_form(torch.as_tensor(value)))