def __init__(self, height, width, lr = 1, aux_loss = False, ray_tracing = False):
super(Depth3DGridGen_with_mask, self).__init__()
self.height, self.width = height, width
self.aux_loss = aux_loss
self.lr = lr
self.ray_tracing = ray_tracing
self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32)
self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0)
self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0)
self.grid[:,:,2] = np.ones([self.height, width])
self.grid = torch.from_numpy(self.grid.astype(np.float32))
self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2
self.phi = self.grid[:,:,1] * np.pi
self.x = torch.sin(self.theta) * torch.cos(self.phi)
self.y = torch.sin(self.theta) * torch.sin(self.phi)
self.z = torch.cos(self.theta)
self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32))
self.grid3d[:,:,0] = self.x
self.grid3d[:,:,1] = self.y
self.grid3d[:,:,2] = self.z
self.grid3d[:,:,3] = self.grid[:,:,2]
def test_inference_sgpr():
N = 1000
X = dist.Uniform(torch.zeros(N), torch.ones(N)*5).sample()
y = 0.5 * torch.sin(3*X) + dist.Normal(torch.zeros(N), torch.ones(N)*0.5).sample()
kernel = RBF(input_dim=1)
Xu = torch.arange(0, 5.5, 0.5)
sgpr = SparseGPRegression(X, y, kernel, Xu)
sgpr.optimize(optim.Adam({"lr": 0.01}), num_steps=1000)
Xnew = torch.arange(0, 5.05, 0.05)
loc, var = sgpr(Xnew, full_cov=False)
target = 0.5 * torch.sin(3*Xnew)
assert_equal((loc - target).abs().mean().item(), 0, prec=0.07)
def test_inference_whiten_vsgp():
N = 1000
X = dist.Uniform(torch.zeros(N), torch.ones(N)*5).sample()
y = 0.5 * torch.sin(3*X) + dist.Normal(torch.zeros(N), torch.ones(N)*0.5).sample()
kernel = RBF(input_dim=1)
Xu = torch.arange(0, 5.5, 0.5)
vsgp = VariationalSparseGP(X, y, kernel, Xu, Gaussian(), whiten=True)
vsgp.optimize(optim.Adam({"lr": 0.01}), num_steps=1000)
Xnew = torch.arange(0, 5.05, 0.05)
loc, var = vsgp(Xnew, full_cov=False)
target = 0.5 * torch.sin(3*Xnew)
assert_equal((loc - target).abs().mean().item(), 0, prec=0.07)
def forward(self, depth, trans0, trans1, rotate):
self.batchgrid3d = torch.zeros(torch.Size([depth.size(0)]) + self.grid3d.size())
for i in range(depth.size(0)):
self.batchgrid3d[i] = self.grid3d
self.batchgrid3d = Variable(self.batchgrid3d)
self.batchgrid = torch.zeros(torch.Size([depth.size(0)]) + self.grid.size())
for i in range(depth.size(0)):
self.batchgrid[i] = self.grid
self.batchgrid = Variable(self.batchgrid)
if depth.is_cuda:
self.batchgrid = self.batchgrid.cuda()
self.batchgrid3d = self.batchgrid3d.cuda()
x_ = self.batchgrid3d[:,:,:,0:1] * depth + trans0.view(-1,1,1,1).repeat(1, self.height, self.width, 1)
y_ = self.batchgrid3d[:,:,:,1:2] * depth + trans1.view(-1,1,1,1).repeat(1, self.height, self.width, 1)
z = self.batchgrid3d[:,:,:,2:3] * depth
#print(x.size(), y.size(), z.size())
rotate_z = rotate.view(-1,1,1,1).repeat(1,self.height, self.width,1) * np.pi
x = x_ * torch.cos(rotate_z) - y_ * torch.sin(rotate_z)
y = x_ * torch.sin(rotate_z) + y_ * torch.cos(rotate_z)
r = torch.sqrt(x**2 + y**2 + z**2) + 1e-5
#print(r)
theta = torch.acos(z/r)/(np.pi/2) - 1
#phi = torch.atan(y/x)
if depth.is_cuda:
phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.cuda.FloatTensor) * (y.ge(0).type(torch.cuda.FloatTensor) - y.lt(0).type(torch.cuda.FloatTensor))
else:
phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.FloatTensor) * (y.ge(0).type(torch.FloatTensor) - y.lt(0).type(torch.FloatTensor))
phi = phi/np.pi
output = torch.cat([theta,phi], 3)
return output
def _setUp(self, double=False, cuda=False):
device = torch.device("cuda") if cuda else torch.device("cpu")
dtype = torch.double if double else torch.float
train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1)
train_y = torch.sin(train_x * (2 * math.pi)).squeeze(-1)
train_yvar = torch.tensor(0.1 ** 2, device=device)
noise = torch.tensor(NOISE, device=device, dtype=dtype)
self.train_x = train_x
self.train_y = train_y + noise
self.train_yvar = train_yvar
self.bounds = torch.tensor([[0.0], [1.0]], device=device, dtype=dtype)
model_st = SingleTaskGP(self.train_x, self.train_y)
self.model_st = model_st.to(device=device, dtype=dtype)
self.mll_st = ExactMarginalLogLikelihood(
self.model_st.likelihood, self.model_st
)
self.mll_st = fit_gpytorch_model(self.mll_st, options={"maxiter": 5})
model_fn = FixedNoiseGP(
self.train_x, self.train_y, self.train_yvar.expand_as(self.train_y)
)
self.model_fn = model_fn.to(device=device, dtype=dtype)
self.mll_fn = ExactMarginalLogLikelihood(
self.model_fn.likelihood, self.model_fn
)
self.mll_fn = fit_gpytorch_model(self.mll_fn, options={"maxiter": 5})
def draw(
self, n: int = 1, out: Optional[Tensor] = None, dtype: torch.dtype = torch.float
) -> Optional[Tensor]:
r"""Draw `n` qMC samples from the standard Normal.
Args:
n: The number of samples to draw.
out: An option output tensor. If provided, draws are put into this
tensor, and the function returns None.
dtype: The desired torch data type (ignored if `out` is provided).
Returns:
A `n x d` tensor of samples if `out=None` and `None` otherwise.
"""
# get base samples
samples = self._sobol_engine.draw(n, dtype=dtype)
if self._inv_transform:
# apply inverse transform (values to close to 0/1 result in inf values)
v = 0.5 + (1 - 1e-10) * (samples - 0.5)
samples_tf = torch.erfinv(2 * v - 1) * math.sqrt(2)
else:
# apply Box-Muller transform (note: [1] indexes starting from 1)
even = torch.arange(0, samples.shape[-1], 2)
Rs = (-2 * torch.log(samples[:, even])).sqrt()
thetas = 2 * math.pi * samples[:, 1 + even]
cos = torch.cos(thetas)
sin = torch.sin(thetas)
samples_tf = torch.stack([Rs * cos, Rs * sin], -1).reshape(n, -1)
# make sure we only return the number of dimension requested
samples_tf = samples_tf[:, : self._d]
if out is None:
return samples_tf
else:
out.copy_(samples_tf)
def _get_random_data(n, **tkwargs):
train_x1 = torch.linspace(0, 0.95, n + 1, **tkwargs) + 0.05 * torch.rand(
n + 1, **tkwargs
)
train_x2 = torch.linspace(0, 0.95, n, **tkwargs) + 0.05 * torch.rand(n, **tkwargs)
train_y1 = torch.sin(train_x1 * (2 * math.pi)) + 0.2 * torch.randn_like(train_x1)
train_y2 = torch.cos(train_x2 * (2 * math.pi)) + 0.2 * torch.randn_like(train_x2)
return train_x1.unsqueeze(-1), train_x2.unsqueeze(-1), train_y1, train_y2
def backward(ctx, grad_output):
input, = ctx.saved_tensors
grad_input = torch.stack((grad_output, torch.zeros_like(grad_output)), dim=len(grad_output.shape))
phase_input = angle(input)
phase_input = torch.stack((torch.cos(phase_input), torch.sin(phase_input)), dim=len(grad_output.shape))
grad_input = multiply_complex(phase_input, grad_input)
return 0.5*grad_input
def _getModel(self, double=False, cuda=False):
device = torch.device("cuda") if cuda else torch.device("cpu")
dtype = torch.double if double else torch.float
train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1)
noise = torch.tensor(NOISE, device=device, dtype=dtype)
train_y = torch.sin(train_x.view(-1) * (2 * math.pi)) + noise
model = SingleTaskGP(train_x, train_y)
mll = ExactMarginalLogLikelihood(model.likelihood, model)
return mll.to(device=device, dtype=dtype)
def neg_michalewicz(X: Tensor) -> Tensor:
r"""Negative 10-dim Michalewicz test function.
10-dim function (usually evaluated on hypercube [0, pi]^10):
`M(x) = sum_{i=1}^10 sin(x_i) (sin(i x_i^2 / pi)^20)`
Args:
X: A Tensor of size `10` or `k x 10` (`k` batch evaluations).
Returns:
`-M(X)`, the negative value of the Michalewicz function.
"""
batch = X.ndimension() > 1
X = X if batch else X.unsqueeze(0)
a = 1 + torch.arange(10, device=X.device, dtype=X.dtype)
result = torch.sum(torch.sin(X) * torch.sin(a * X ** 2 / math.pi) ** 20, dim=-1)
return result if batch else result.squeeze(0)
def forward(ctx, input):
assert input.shape[-1]==2, "Complex tensor should have real and imaginary parts."
output = input.clone()
amplitude = torch.exp(input[..., 0])
# amplitude = input[..., 0]
output[..., 0] = amplitude*torch.cos(input[..., 1])
output[..., 1] = amplitude*torch.sin(input[..., 1])
ctx.save_for_backward(output)
return output
def __init__(self, input_dim: int, max_len: int = 5000) -> None:
super().__init__()
# Compute the positional encodings once in log space.
positional_encoding = torch.zeros(max_len, input_dim, requires_grad=False)
position = torch.arange(0, max_len).unsqueeze(1).float()
div_term = torch.exp(torch.arange(0, input_dim, 2).float() * -(math.log(10000.0) / input_dim))
positional_encoding[:, 0::2] = torch.sin(position * div_term)
positional_encoding[:, 1::2] = torch.cos(position * div_term)
positional_encoding = positional_encoding.unsqueeze(0)
self.register_buffer('positional_encoding', positional_encoding)
def _get_random_data(batch_shape, num_outputs, n=10, **tkwargs):
train_x = torch.linspace(0, 0.95, n, **tkwargs).unsqueeze(-1) + 0.05 * torch.rand(
n, 1, **tkwargs
).repeat(batch_shape + torch.Size([1, 1]))
train_y = torch.sin(train_x * (2 * math.pi)) + 0.2 * torch.randn(
n, num_outputs, **tkwargs
).repeat(batch_shape + torch.Size([1, 1]))
if num_outputs == 1:
train_y = train_y.squeeze(-1)
return train_x, train_y
def __init__(self, d_model, dropout, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = torch.nn.Dropout(p=dropout)
pe = torch.zeros(max_len, d_model)
position = torch.arange(0., max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0., d_model, 2) * -(math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
self.register_buffer("pe", pe)
def _get_random_mt_data(**tkwargs):
train_x = torch.linspace(0, 0.95, 10, **tkwargs) + 0.05 * torch.rand(10, **tkwargs)
train_y1 = torch.sin(train_x * (2 * math.pi)) + torch.randn_like(train_x) * 0.2
train_y2 = torch.cos(train_x * (2 * math.pi)) + torch.randn_like(train_x) * 0.2
train_i_task1 = torch.full_like(train_x, dtype=torch.long, fill_value=0)
train_i_task2 = torch.full_like(train_x, dtype=torch.long, fill_value=1)
full_train_x = torch.cat([train_x, train_x])
full_train_i = torch.cat([train_i_task1, train_i_task2])
full_train_y = torch.cat([train_y1, train_y2])
train_X = torch.stack([full_train_x, full_train_i.type_as(full_train_x)], dim=-1)
train_Y = full_train_y
return train_X, train_Y
def __init__(self, dropout, dim, max_len=5000):
pe = torch.zeros(max_len, dim)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0, dim, 2) *
-(math.log(10000.0) / dim))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(1)
super(PositionalEncoding, self).__init__()
self.register_buffer('pe', pe)
self.dropout = nn.Dropout(p=dropout)
self.dim = dim
def add_positional_features(tensor: torch.Tensor,
min_timescale: float = 1.0,
max_timescale: float = 1.0e4):
# pylint: disable=line-too-long
"""
Implements the frequency-based positional encoding described
in `Attention is all you Need
<https://www.semanticscholar.org/paper/Attention-Is-All-You-Need-Vaswani-Shazeer/0737da0767d77606169cbf4187b83e1ab62f6077>`_ .
Adds sinusoids of different frequencies to a ``Tensor``. A sinusoid of a
different frequency and phase is added to each dimension of the input ``Tensor``.
This allows the attention heads to use absolute and relative positions.
The number of timescales is equal to hidden_dim / 2 within the range
(min_timescale, max_timescale). For each timescale, the two sinusoidal
signals sin(timestep / timescale) and cos(timestep / timescale) are
generated and concatenated along the hidden_dim dimension.
Parameters
----------
tensor : ``torch.Tensor``
a Tensor with shape (batch_size, timesteps, hidden_dim).
min_timescale : ``float``, optional (default = 1.0)
The smallest timescale to use.
max_timescale : ``float``, optional (default = 1.0e4)
The largest timescale to use.
Returns
-------
The input tensor augmented with the sinusoidal frequencies.
"""
_, timesteps, hidden_dim = tensor.size()
timestep_range = get_range_vector(timesteps, get_device_of(tensor)).data.float()
# We're generating both cos and sin frequencies,
# so half for each.
num_timescales = hidden_dim // 2
timescale_range = get_range_vector(num_timescales, get_device_of(tensor)).data.float()
log_timescale_increments = math.log(float(max_timescale) / float(min_timescale)) / float(num_timescales - 1)
inverse_timescales = min_timescale * torch.exp(timescale_range * -log_timescale_increments)
# Broadcasted multiplication - shape (timesteps, num_timescales)
scaled_time = timestep_range.unsqueeze(1) * inverse_timescales.unsqueeze(0)
# shape (timesteps, 2 * num_timescales)
sinusoids = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 1)
if hidden_dim % 2 != 0:
# if the number of dimensions is odd, the cos and sin
# timescales had size (hidden_dim - 1) / 2, so we need
# to add a row of zeros to make up the difference.
sinusoids = torch.cat([sinusoids, sinusoids.new_zeros(timesteps, 1)], 1)
return tensor + sinusoids.unsqueeze(0)
def invert(self, head_coords, segment_len, mean_angle, eigenworms):
angles = torch.matmul(eigenworms, self.eigen_components)
angles += mean_angle.view(-1, 1)
ske_x = torch.sin(angles).view(-1, self.n_angles, 1)
ske_y = torch.cos(angles).view(-1, self.n_angles, 1)
skels_n = torch.cat([ske_x, ske_y], 2)*segment_len.view(-1, 1, 1)
skels_n = torch.cat([head_coords.view(-1, 1, 2), skels_n], 1)
skels_n = torch.cumsum(skels_n, dim=1)
return skels_n
def test_gpytorch_model(self):
train_X = torch.rand(5, 1)
train_Y = torch.sin(train_X.squeeze())
# basic test
model = SimpleGPyTorchModel(train_X, train_Y)
test_X = torch.rand(2, 1)
posterior = model.posterior(test_X)
self.assertIsInstance(posterior, GPyTorchPosterior)
self.assertEqual(posterior.mean.shape, torch.Size([2, 1]))
# test observation noise
posterior = model.posterior(test_X, observation_noise=True)
self.assertIsInstance(posterior, GPyTorchPosterior)
self.assertEqual(posterior.mean.shape, torch.Size([2, 1]))
def __init__(self, _, **kwargs):
super(PositionalLookupTableEmbeddings, self).__init__(_, **kwargs)
self.dropout = nn.Dropout(kwargs.get('dropout', 0.1))
# This could get us in trouble, if in doubt, pick something big
mxlen = kwargs.get('mxlen', 1000)
max_timescale = kwargs.get('max_timescale', 1.0e4)
log_timescale_increment = math.log(max_timescale) / self.dsz
inv_timescales = torch.exp(torch.arange(0, self.dsz, 2).float() * -log_timescale_increment)
pe = torch.zeros(mxlen, self.dsz)
position = torch.arange(0, mxlen).float().unsqueeze(1)
pe[:, 0::2] = torch.sin(position * inv_timescales)
pe[:, 1::2] = torch.cos(position * inv_timescales)
pe = pe.unsqueeze(0)
self.register_buffer('pe', pe)
def positional_encodings_like(x, t=None):
if t is None:
positions = torch.arange(0, x.size(1))
if x.is_cuda:
positions = positions.cuda(x.get_device())
else:
positions = t
encodings = torch.zeros(*x.size()[1:])
if x.is_cuda:
encodings = encodings.cuda(x.get_device())
for channel in range(x.size(-1)):
if channel % 2 == 0:
encodings[:, channel] = torch.sin(
positions / 10000 ** (channel / x.size(2)))
else:
encodings[:, channel] = torch.cos(
positions / 10000 ** ((channel - 1) / x.size(2)))
return Variable(encodings)
def _setUp(self, double=False, cuda=False, expand=False):
device = torch.device("cuda") if cuda else torch.device("cpu")
dtype = torch.double if double else torch.float
train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1)
train_y = torch.sin(train_x * (2 * math.pi)).squeeze(-1)
noise = torch.tensor(NOISE, device=device, dtype=dtype)
self.train_x = train_x
self.train_y = train_y + noise
if expand:
self.train_x = self.train_x.expand(-1, 2)
ics = torch.tensor([[0.5, 1.0]], device=device, dtype=dtype)
else:
ics = torch.tensor([[0.5]], device=device, dtype=dtype)
self.initial_conditions = ics
self.f_best = self.train_y.max().item()
model = SingleTaskGP(self.train_x, self.train_y)
self.model = model.to(device=device, dtype=dtype)
self.mll = ExactMarginalLogLikelihood(self.model.likelihood, self.model)
self.mll = fit_gpytorch_model(self.mll, options={"maxiter": 1})
def forward(self, X, Z=None, diag=False):
if diag:
variance = self.get_param("variance")
return variance.expand(X.shape[0])
if Z is None:
Z = X
X = self._slice_input(X)
Z = self._slice_input(Z)
if X.shape[1] != Z.shape[1]:
raise ValueError("Inputs must have the same number of features.")
variance = self.get_param("variance")
lengthscale = self.get_param("lengthscale")
period = self.get_param("period")
d = X.unsqueeze(1) - Z.unsqueeze(0)
scaled_sin = torch.sin(math.pi * d / period) / lengthscale
return variance * torch.exp(-2 * (scaled_sin ** 2).sum(-1))
def __init__(self, values, env_to_world = torch.eye(4, 4)):
# Convert to constant texture if necessary
if isinstance(values, torch.Tensor):
values = pyredner.Texture(values)
assert(values.texels.is_contiguous())
assert(values.texels.dtype == torch.float32)
if pyredner.get_use_gpu():
assert(values.texels.is_cuda)
else:
assert(not values.texels.is_cuda)
assert(env_to_world.dtype == torch.float32)
# Build sampling table
luminance = 0.212671 * values.texels[:, :, 0] + \
0.715160 * values.texels[:, :, 1] + \
0.072169 * values.texels[:, :, 2]
# For each y, compute CDF over x
sample_cdf_xs_ = torch.cumsum(luminance, dim = 1)
y_weight = torch.sin(\
math.pi * (torch.arange(luminance.shape[0],
dtype = torch.float32, device = luminance.device) + 0.5) \
/ float(luminance.shape[0]))
# Compute CDF for x
sample_cdf_ys_ = torch.cumsum(sample_cdf_xs_[:, -1] * y_weight, dim = 0)
pdf_norm = (luminance.shape[0] * luminance.shape[1]) / \
(sample_cdf_ys_[-1].item() * (2 * math.pi * math.pi))
# Normalize to [0, 1)
sample_cdf_xs = (sample_cdf_xs_ - sample_cdf_xs_[:, 0:1]) / \
torch.max(sample_cdf_xs_[:, (luminance.shape[1] - 1):luminance.shape[1]],
1e-8 * torch.ones(sample_cdf_xs_.shape[0], 1, device = sample_cdf_ys_.device))
sample_cdf_ys = (sample_cdf_ys_ - sample_cdf_ys_[0]) / \
torch.max(sample_cdf_ys_[-1], torch.tensor([1e-8], device = sample_cdf_ys_.device))
self.values = values
self.env_to_world = env_to_world
self.world_to_env = torch.inverse(env_to_world).contiguous()
self.sample_cdf_ys = sample_cdf_ys.contiguous()
self.sample_cdf_xs = sample_cdf_xs.contiguous()
self.pdf_norm = pdf_norm
def _h_eigenworms_inv_T(head_x, head_y, segment_l,
mean_angle, eigenworms):
'''
Convert the eigen value transformed data into xy coordinates
'''
n_components = eigenworms.size(0)
angles = torch.mm(eigenworms.view(1, -1), EIGENWORMS_COMPONENTS_T[:n_components])
angles += mean_angle
ske_x = torch.sin(angles)*segment_l
ske_x = torch.cat([head_x.view(1,1), ske_x], 1)
ske_x = torch.cumsum(ske_x, dim=1)
ske_y = torch.cos(angles)*segment_l
ske_y = torch.cat([head_y.view(1,1), ske_y], 1)
ske_y = torch.cumsum(ske_y, dim=1)
skels_n = torch.cat((ske_x.view(-1, 1), ske_y.view(-1, 1)), 1)
return skels_n
def _get_model(self, cuda=False, dtype=torch.float):
device = torch.device("cuda") if cuda else torch.device("cpu")
state_dict = {
"mean_module.constant": torch.tensor([-0.0066]),
"covar_module.raw_outputscale": torch.tensor(1.0143),
"covar_module.base_kernel.raw_lengthscale": torch.tensor([[-0.99]]),
"covar_module.base_kernel.lengthscale_prior.concentration": torch.tensor(
3.0
),
"covar_module.base_kernel.lengthscale_prior.rate": torch.tensor(6.0),
"covar_module.outputscale_prior.concentration": torch.tensor(2.0),
"covar_module.outputscale_prior.rate": torch.tensor(0.1500),
}
train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype)
train_y = torch.sin(train_x * (2 * math.pi))
noise = torch.tensor(NEI_NOISE, device=device, dtype=dtype)
train_y += noise
train_yvar = torch.full_like(train_y, 0.25 ** 2)
train_x = train_x.view(-1, 1)
model = FixedNoiseGP(train_X=train_x, train_Y=train_y, train_Yvar=train_yvar)
model.load_state_dict(state_dict)
model.to(train_x)
model.eval()
return model
def init_foveated_lattice(img_shape, scale, n_rings, spacing=0., std=1.,
n_rf=None, offset=[0.,0.], min_ecc=0.5,
rotate_rings=True, rotate=0., keep_all_RFs=False):
"""
Creates a foveated lattice of kernel centers (mu) and
stantard deviations (sigma)
Parameters
----------
img_shape : tuple
shape of image
scale : float
rate at which receptive field radius scales with eccentricity
n_rings : int
number of concentric rings in foveated array
spacing : float
spacing between receptive field centers (as fraction of radius)
std : float
standard deviation multiplier [default: 1.]
n_rf : int
number of RFs per ring [default: None, set to np.pi / scale]
offset : list of floats
(x,y) offset from center of image [default: [0.,0.]]
min_ecc : float
minimum eccentricity for gaussian rings [default: 1.]
rotate_rings : bool
rotate receptive fields between rings [default: False]
rotate : float
rotation (in radians, counterclockwise) to apply to the entire array
keep_all_RFs : boolean
True/False keep all RFs regardless of whether they are fully contained
within the image space
[default: False, remove RFs 1 sigma outside image space]
Returns
-------
mu : torch.Tensor
kernel x-y coordinate centers with shape (n_kernels, 2) and dtype
torch.int32
sigma : torch.Tensor
kernel standard deviations with shape (n_kernels, 1)
Examples
--------
# generate a "V3" lattice on a 200x200 image
>>> img_shape = (200,200)
>>> scale = 0.25
>>> spacing = 0.15
>>> min_ecc = 1.
>>> mu, sigma = init_foveated_lattic(img_shape, scale, spacing, min_ecc)
Notes
-----
sigma will always be >= 1. (pixel space)
References
----------
(Winawer & Horiguchi, 2015) https://archive.nyu.edu/handle/2451/33887
"""
assert scale > 0.
assert min_ecc > 0.
# get number of receptive fields in ring
if n_rf is None:
n_rf = np.floor(np.pi/scale)
else:
n_rf = n_rf + 1
# get angular positions for each receptive field
angles = 2. * np.pi * torch.linspace(0., 1., int(n_rf))[:-1]
x_mu = torch.cos(angles)
y_mu = torch.sin(angles)
# get base sigma
base_sigma = torch.as_tensor((1. - spacing) * scale, dtype=torch.float32)
# eccentricity factor
eFactor = (1. + scale) / (1. - scale)
# get rotation angle between each ring
if rotate_rings:
rot_angle = torch.as_tensor(np.pi / n_rf, dtype=torch.float32)
x_mu_rot = torch.cos(rot_angle)*x_mu + torch.sin(rot_angle)*y_mu
y_mu_rot = -torch.sin(rot_angle)*x_mu + torch.cos(rot_angle)*y_mu
# append mu, sigma for each eccentricity
ecc = min_ecc * eFactor
mu = []
sigma = []
for n in range(n_rings):
if rotate_rings and np.mod(n, 2):
mu.append(torch.stack([ecc*x_mu_rot, ecc*y_mu_rot], dim=-1))
else:
mu.append(torch.stack([ecc*x_mu, ecc*y_mu], dim=-1))
sigma.append(torch.mul(ecc, base_sigma).repeat(mu[-1].shape[0]))
ecc *= eFactor
# set mu, sigma
mu = torch.as_tensor(torch.cat(mu, dim=0), dtype=torch.float32)
sigma = torch.cat(sigma, 0).unsqueeze(1)
# rotate mu
rx = np.cos(rotate) * mu[:,0] - np.sin(rotate) * mu[:,1]
ry = np.sin(rotate) * mu[:,0] + np.cos(rotate) * mu[:,1]
mu = torch.stack([rx,ry], dim=-1)
# set offset of mu
mu = mu + torch.as_tensor(offset, dtype=mu.dtype)
# multiply by std
sigma = torch.mul(sigma, std)
# check if mu + sigma (along radial direction from fovea) is in image
r = torch.sqrt(torch.sum(torch.pow(mu, 2), 1))
r_sigma = r - sigma.flatten()
theta = torch.atan2(*mu.t())
h_w = torch.mul(torch.stack([torch.sin(theta), torch.cos(theta)], 1),
r_sigma.reshape(-1,1))
# remove mu, sigma outside image frame
center = torch.as_tensor(img_shape, dtype=mu.dtype).unsqueeze(0) / 2.
keep_idx = torch.prod(torch.lt(torch.abs(h_w), center), -1).bool()
# add img_shape//2 to mu
mu = torch.add(mu, center)
if keep_all_RFs:
return mu, sigma
return mu[keep_idx], sigma[keep_idx]
def reset(self, **kwargs):
"""
Function to reset the environment
"""
self.x1_list = []
self.y1_list = []
self.x2_list = []
self.y2_list = []
self.x3_list = []
self.y3_list = []
self.x4_list = []
self.y4_list = []
self.time_step = 1
self.true_targets_radii = torch.rand(self.num_targets) * 5.0 + 2.0
self.true_targets_pos = (torch.rand(self.num_targets, 2) *
self.len_workspace)
self.initial_true_targets_pos = self.true_targets_pos.clone()
self.estimated_targets_mean = self.true_targets_pos.clone()
self.estimated_targets_var = torch.zeros(self.num_targets, 2, 2)
for index in range(0, self.num_targets):
self.estimated_targets_var[index] = torch.tensor([[1, 0], [0, 1]])
self.target_motion_omegas = torch.rand(self.num_targets) * 100.0
self.robot_movement_x = []
self.robot_movement_y = []
self.sensors_pos = torch.zeros(self.num_sensors, 2)
for index in range(0, self.num_sensors):
rand_angle = torch.rand(1) * 2 * np.pi
self.sensors_pos[index] = self.true_targets_pos.mean(0) + (
torch.sqrt(torch.rand(1) + 0.5) * (self.len_workspace / 2) *
(torch.tensor([torch.cos(rand_angle),
torch.sin(rand_angle)])))
if (self.sensors_pos[index, 0] >= self.len_workspace):
self.sensors_pos[index, 0] -= (self.sensors_pos[index, 0] -
self.len_workspace + 1)
if (self.sensors_pos[index, 0] <= 0):
self.sensors_pos[index, 0] = (-self.sensors_pos[index, 0] + 1)
if (self.sensors_pos[index, 1] >= self.len_workspace):
self.sensors_pos[index, 1] -= (self.sensors_pos[index, 1] -
self.len_workspace + 1)
if (self.sensors_pos[index, 1] <= 0):
self.sensors_pos[index, 1] = (-self.sensors_pos[index, 1] + 1)
self.robot_movement_x.append(float(self.sensors_pos[0, 0]))
self.robot_movement_y.append(float(self.sensors_pos[0, 1]))
self.x1_list.append(float(self.true_targets_pos[0, 0]))
self.y1_list.append(float(self.true_targets_pos[0, 1]))
self.x2_list.append(float(self.true_targets_pos[1, 0]))
self.y2_list.append(float(self.true_targets_pos[1, 1]))
self.x3_list.append(float(self.true_targets_pos[2, 0]))
self.y3_list.append(float(self.true_targets_pos[2, 1]))
self.x4_list.append(float(self.true_targets_pos[3, 0]))
self.y4_list.append(float(self.true_targets_pos[3, 1]))
self.heatmap = torch.zeros(self.len_workspace, self.len_workspace)
for index in range(0, self.num_targets):
x = np.linspace(0, self.len_workspace, self.len_workspace)
y = np.linspace(0, self.len_workspace, self.len_workspace)
X, Y = np.meshgrid(x, y)
pos = np.empty(X.shape + (2, ))
pos[:, :, 0] = X
pos[:, :, 1] = Y
rv = multivariate_normal(self.estimated_targets_mean[index],
self.estimated_targets_var[index])
self.heatmap += rv.pdf(pos)
true_obs = self.heatmap.flatten()
self.state = torch.cat(
(self.sensors_pos[0], torch.tensor(true_obs).float()))
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=self.state.shape,
dtype='float32')
return self.state, self.sensors_pos, self.estimated_targets_mean, self.true_targets_radii, self.target_motion_omegas
def ciede2000_diff(lab1, lab2, device):
'''
CIEDE2000 metric to claculate the color distance map for a batch of image tensors defined in CIELAB space
'''
lab1 = lab1.to(device)
lab2 = lab2.to(device)
L1 = lab1[:, 0, :, :]
A1 = lab1[:, 1, :, :]
B1 = lab1[:, 2, :, :]
L2 = lab2[:, 0, :, :]
A2 = lab2[:, 1, :, :]
B2 = lab2[:, 2, :, :]
kL = 1
kC = 1
kH = 1
mask_value_0_input1 = ((A1 == 0) * (B1 == 0)).float()
mask_value_0_input2 = ((A2 == 0) * (B2 == 0)).float()
mask_value_0_input1_no = 1 - mask_value_0_input1
mask_value_0_input2_no = 1 - mask_value_0_input2
B1 = B1 + 0.0001 * mask_value_0_input1
B2 = B2 + 0.0001 * mask_value_0_input2
C1 = torch.sqrt((A1**2.) + (B1**2.))
C2 = torch.sqrt((A2**2.) + (B2**2.))
aC1C2 = (C1 + C2) / 2.
G = 0.5 * (1. - torch.sqrt((aC1C2**7.) / ((aC1C2**7.) + (25**7.))))
a1P = (1. + G) * A1
a2P = (1. + G) * A2
c1P = torch.sqrt((a1P**2.) + (B1**2.))
c2P = torch.sqrt((a2P**2.) + (B2**2.))
h1P = hpf_diff(B1, a1P)
h2P = hpf_diff(B2, a2P)
h1P = h1P * mask_value_0_input1_no
h2P = h2P * mask_value_0_input2_no
dLP = L2 - L1
dCP = c2P - c1P
dhP = dhpf_diff(C1, C2, h1P, h2P)
dHP = 2. * torch.sqrt(c1P * c2P) * torch.sin(radians(dhP) / 2.)
mask_0_no = 1 - torch.max(mask_value_0_input1, mask_value_0_input2)
dHP = dHP * mask_0_no
aL = (L1 + L2) / 2.
aCP = (c1P + c2P) / 2.
aHP = ahpf_diff(C1, C2, h1P, h2P)
T = 1. - 0.17 * torch.cos(radians(aHP - 39)) + 0.24 * torch.cos(
radians(2. * aHP)) + 0.32 * torch.cos(
radians(3. * aHP + 6.)) - 0.2 * torch.cos(radians(4. * aHP - 63.))
dRO = 30. * torch.exp(-1. * (((aHP - 275.) / 25.)**2.))
rC = torch.sqrt((aCP**7.) / ((aCP**7.) + (25.**7.)))
sL = 1. + ((0.015 * ((aL - 50.)**2.)) / torch.sqrt(20. + ((aL - 50.)**2.)))
sC = 1. + 0.045 * aCP
sH = 1. + 0.015 * aCP * T
rT = -2. * rC * torch.sin(radians(2. * dRO))
# res_square=((dLP / (sL * kL)) ** 2.) + ((dCP / (sC * kC)) ** 2.) + ((dHP / (sH * kH)) ** 2.) + rT * (dCP / (sC * kC)) * (dHP / (sH * kH))
res_square = ((dLP /
(sL * kL))**2.) + ((dCP / (sC * kC))**2.) * mask_0_no + (
(dHP / (sH * kH))**2.) * mask_0_no + rT * (
dCP / (sC * kC)) * (dHP / (sH * kH)) * mask_0_no
mask_0 = (res_square <= 0).float()
mask_0_no = 1 - mask_0
res_square = res_square + 0.0001 * mask_0
res = torch.sqrt(res_square)
res = res * mask_0_no
return res
def mse(u, t):
true_u = torch.sin(t)
return torch.mean((u - true_u) ** 2)
def __init__(self,
char_embedding_dim: int,
out_dim: int,
image_feature_dim: int = 512,
nheaders: int = 8,
nlayers: int = 6,
feedforward_dim: int = 2048,
dropout: float = 0.1,
max_len: int = 100,
image_encoder: str = 'resnet50',
roi_pooling_mode: str = 'roi_align',
roi_pooling_size: Tuple[int, int] = (7, 7)):
'''
convert image segments and text segments to node embedding.
:param char_embedding_dim:
:param out_dim:
:param image_feature_dim:
:param nheaders:
:param nlayers:
:param feedforward_dim:
:param dropout:
:param max_len:
:param image_encoder:
:param roi_pooling_mode:
:param roi_pooling_size:
'''
super().__init__()
self.dropout = dropout
assert roi_pooling_mode in [
'roi_align', 'roi_pool'
], 'roi pooling model: {} not support.'.format(roi_pooling_mode)
self.roi_pooling_mode = roi_pooling_mode
assert roi_pooling_size and len(
roi_pooling_size) == 2, 'roi_pooling_size not be set properly.'
self.roi_pooling_size = tuple(roi_pooling_size) # (h, w)
transformer_encoder_layer = nn.TransformerEncoderLayer(
d_model=char_embedding_dim,
nhead=nheaders,
dim_feedforward=feedforward_dim,
dropout=dropout)
self.transformer_encoder = nn.TransformerEncoder(
transformer_encoder_layer, num_layers=nlayers)
if image_encoder == 'resnet18':
self.cnn = resnet.resnet18(output_channels=out_dim)
elif image_encoder == 'resnet34':
self.cnn = resnet.resnet34(output_channels=out_dim)
elif image_encoder == 'resnet50':
self.cnn = resnet.resnet50(output_channels=out_dim)
elif image_encoder == 'resnet101':
self.cnn = resnet.resnet101(output_channels=out_dim)
elif image_encoder == 'resnet152':
self.cnn = resnet.resnet152(output_channels=out_dim)
else:
raise NotImplementedError()
self.conv = nn.Conv2d(image_feature_dim, out_dim,
self.roi_pooling_size)
self.bn = nn.BatchNorm2d(out_dim)
self.projection = nn.Linear(2 * out_dim, out_dim)
self.norm = nn.LayerNorm(out_dim)
# Compute the positional encodings once in log space.
position_embedding = torch.zeros(max_len, char_embedding_dim)
position = torch.arange(0, max_len).unsqueeze(1).float()
div_term = torch.exp(
torch.arange(0, char_embedding_dim, 2).float() *
-(math.log(10000.0) / char_embedding_dim))
position_embedding[:, 0::2] = torch.sin(position * div_term)
position_embedding[:, 1::2] = torch.cos(position * div_term)
position_embedding = position_embedding.unsqueeze(0).unsqueeze(
0) # 1, 1, max_len, char_embedding_dim
self.register_buffer('position_embedding', position_embedding)
self.pe_droput = nn.Dropout(self.dropout)
from neural_decomposition import ND
from math import pi
import torch
import matplotlib.pyplot as plt
t = torch.linspace(0, 2 * pi, 40)
x = torch.sin(t)
nd = ND(5).init(x)
y = []
for i in range(40):
nd.fit(x, lr=0.002)
y += [nd(t).detach()]
for yi in y:
plt.plot(yi)
plt.plot(x, color="black", linestyle="dashed")
plt.show()
def forward(self, y, x):
# Calculate rho_0
with torch.no_grad():
# Dimensions: [Batch, Time, Embedding]
sin_phi_D = x[:, :self.N - 1, 1]
cos_phi_D = x[:, :self.N - 1, 3]
# exp_phi_D = cos_phi_D + 1j * sin_phi_D
rho_0_real = torch.full((x.shape[0], 2, 2), 0.5)
rho_0_imag = torch.zeros((x.shape[0], 2, 2))
rho_0_real[:, 1, 0] *= cos_phi_D[:, 0]
rho_0_real[:, 0, 1] *= cos_phi_D[:, 0]
rho_0_imag[:, 1, 0] = 0.5 * sin_phi_D[:, 0]
rho_0_imag[:, 0, 1] = -0.5 * sin_phi_D[:, 0]
# Calculate unitary evolution operators
# No grad for drive side
with torch.no_grad():
# H_D: [batch, time, 2x2 matrix]
sin_theta_D = x[:, :self.N - 1, 0]
# H_D = torch.zeros((x.shape[0], self.N - 1, 2, 2), dtype=torch.cdouble)
# H_D[:, :, 1, 0] = exp_phi_D * sin_theta_D / 2
# H_D[:, :, 0, 1] = torch.conj(exp_phi_D) * sin_theta_D / 2
H_D_real = torch.zeros((x.shape[0], self.N - 1, 2, 2))
H_D_imag = torch.zeros((x.shape[0], self.N -1, 2, 2))
H_D_real[:, :, 1, 0] = 0.5 * sin_theta_D * cos_phi_D
H_D_real[:, :, 0, 1] = 0.5 * sin_theta_D * cos_phi_D
H_D_imag[:, :, 1, 0] = 0.5 * sin_theta_D * sin_phi_D
H_D_imag[:, :, 0, 1] = -0.5 * sin_theta_D * sin_phi_D
# H_T: [batch, time, 2x2]
# H_T = torch.zeros((y.shape[0], self.N, 2, 2), dtype=torch.cdouble)
theta_T = torch.atan2(y[:, :, 0], y[:, :, 2])
phi_T = torch.atan2(y[:, :, 1], y[:, :, 3])
# H_T[:, :, 1, 0] = (torch.cos(phi_T) + 1j * torch.sin(phi_T)) * torch.sin(theta_T) / 2
# H_T[:, :, 0, 1] = (torch.cos(phi_T) - 1j * torch.sin(phi_T)) * torch.sin(theta_T) / 2
H_T_real = torch.zeros((y.shape[0], self.N, 2, 2))
H_T_imag = torch.zeros((y.shape[0], self.N, 2, 2))
H_T_real[:, :, 1, 0] = torch.cos(phi_T) * torch.sin(theta_T) / 2
H_T_real[:, :, 0, 1] = torch.cos(phi_T) * torch.sin(theta_T) / 2
H_T_imag[:, :, 1, 0] = torch.sin(phi_T) * torch.sin(theta_T) / 2
H_T_imag[:, :, 0, 1] = -1 * torch.sin(phi_T) * torch.sin(theta_T) / 2
# Abs value of alpha = delta + tau
# shape: [batch, 2]
abs_alpha = torch.sqrt(torch.pow(torch.sin(theta_T[:, :self.N - 1]), 2) + torch.pow(sin_theta_D[:, :self.N - 1], 2) + 2 * torch.sin(theta_T[:, :self.N - 1]) * sin_theta_D[:, :self.N - 1] * (torch.cos(phi_T[:, :self.N - 1]) * cos_phi_D[:, :self.N - 1] + torch.sin(phi_T[:, :self.N - 1]) * sin_phi_D[:, :self.N - 1])) / 2
alpha_real = 0.5 * (sin_theta_D[:, :self.N - 1] * cos_phi_D[:, :self.N - 1] + torch.sin(theta_T[:, :self.N - 1]) * torch.cos(phi_T[:, :self.N - 1]))
alpha_imag = 0.5 * (sin_theta_D[:, :self.N - 1] * sin_phi_D[:, :self.N - 1] + torch.sin(theta_T[:, :self.N - 1]) * torch.sin(phi_T[:, :self.N - 1]))
# Unitary evolution operator
# Shape: [batch, N-1, 2, 2]
U_real = torch.zeros((x.shape[0], self.N - 1, 2, 2))
U_imag = torch.zeros((x.shape[0], self.N - 1, 2, 2))
# Helpers
c = torch.cos(abs_alpha * self.dt)
s = torch.div(torch.sin(abs_alpha * self.dt), abs_alpha)
U_real[:, :, 0, 0] = c
U_real[:, :, 1, 1] = c
U_real[:, :, 0, 1] = torch.mul(-1 * alpha_imag, s)
U_real[:, :, 1, 0] = torch.mul(alpha_imag, s)
U_imag[:, :, 0, 1] = torch.mul(-1 * alpha_real, s)
U_imag[:, :, 1, 0] = torch.mul(-1 * alpha_real, s)
# U_1 = matexp(H_D[:, 0] + H_T[:, 0], self.dt)
# U_2 = matexp(H_D[:, 1] + H_T[:, 1], self.dt)
# helper_real, helper_imag = real_matmul(U_real[:, 0], U_imag[:, 0], rho_0_real, rho_0_imag)
# rho_1_real, rho_1_imag = real_matmul(helper_real, helper_imag, torch.transpose(U_real[:, 0], 1, 2), -1 * torch.transpose(U_imag[:, 0], 1, 2))
#
# A_1_real, A_1_imag = real_matmul(rho_1_real, rho_1_imag, (H_T_real[:, 1] - H_T_real[:, 0]), (H_T_imag[:, 1] - H_T_imag[:, 0]))
# W_1 = A_1_real[:, 0, 0] + A_1_real[:, 1, 1]
#
# help2_real, help2_imag = real_matmul(U_real[:, 1], U_imag[:, 1], rho_1_real, rho_1_imag)
# rho_2_real, rho_2_imag = real_matmul(help2_real, help2_imag, torch.transpose(U_real[:, 1], 1, 2), torch.transpose(-1 * U_imag[:, 1], 1, 2))
#
# A_2_real, A_2_imag = real_matmul(rho_2_real, rho_2_imag, H_T_real[:, 2] - H_T_real[:, 1], H_T_imag[:, 2] - H_T_imag[:, 1])
# W_2 = A_2_real[:, 0, 0] + A_2_real[:, 1, 1]
W = torch.zeros((x.shape[0]))
rho_real = rho_0_real
rho_imag = rho_0_imag
for i in range(self.N - 1):
helper_real, helper_imag = real_matmul(U_real[:, i], U_imag[:, i], rho_real, rho_imag)
rho_real, rho_imag = real_matmul(helper_real, helper_imag, torch.transpose(U_real[:, i], 1, 2), -1 * torch.transpose(U_imag[:, i], 1, 2))
A_real, A_imag = real_matmul(rho_real, rho_imag, (H_T_real[:, i+1] - H_T_real[:, i]), (H_T_imag[:, i+1] - H_T_imag[:, i]))
W += A_real[:, 0, 0] + A_real[:, 1, 1]
return torch.mean(W)
def control(self, arena, dt):
#kajagyűjtés
foodat=arena.get_food(self.f_p)*(~(self.food_carry > 0))
self.food_carry+=foodat
# self.phis += ( np.pi + t.atan2(self.ys,self.xs) - self.phis)*(foodat > 0)
# arena.update_food(-foodat,self.f_p)
#kajalerakás
based = arena.get_base(self.f_p)
self.food_accum += (based*self.food_carry).sum("EX")
self.food_carry *= ~(based > 0)
fooded = (self.food_carry> 0)
unfooded = ~fooded
#feromonok
phero = self.phero_dens*t.stack((fooded.rename(None), unfooded.rename(None)), -1).refine_names("B", "EX", "ST").align_as(self.phero_dens)
arena.update_pheros(phero.sum("ST"), self.f_p)
xleft,yleft = self.xs + self.lookforward*self.v*t.cos(self.phis+0.5),self.ys + self.lookforward*self.v*t.sin(self.phis+0.5)
xright,yright = self.xs + self.lookforward*self.v*t.cos(self.phis-0.5),self.ys + self.lookforward*self.v*t.sin(self.phis-0.5)
f_l, f_r = arena.get_index(arena.colomap, xleft, yleft), arena.get_index(arena.colomap, xright, yright)
phero_left, phero_right = arena.get_pheros(f_l), arena.get_pheros(f_r)
dpher = phero_left-phero_right
self.phis+= (( dpher[:,:,0])*unfooded +(dpher[:,:,1])*fooded)*self.turn_pher
#ez a random fordulás+bázis fele ha van kaja
turn_prob = self.turn_prob*(t.exp(-(phero_left + phero_right)[:,:,0]*unfooded -(phero_left + phero_right)[:,:,1]*fooded))#+ fooded)
turn = t.distributions.bernoulli.Bernoulli(turn_prob.rename(None)*dt).sample()
amount = t.randn_like(turn)#*(unfooded) + ( np.pi + t.atan2(self.ys,self.xs) - self.phis)*fooded
self.phis += 1.0*turn*amount
#akadálykikerülés
xleft,yleft=self.xs + self.lookforward*self.v*t.cos(self.phis+0.5),self.ys + self.lookforward*self.v*t.sin(self.phis+0.5)
xright,yright=self.xs + self.lookforward*self.v*t.cos(self.phis-0.5),self.ys + self.lookforward*self.v*t.sin(self.phis-0.5)
f_l, f_r = arena.get_index(arena.colomap, xleft, yleft), arena.get_index(arena.colomap, xright, yright)
obs_left, obs_right = arena.get_obst(f_l), arena.get_obst(f_r)
self.phis += -obs_left*self.turn_obst*dt + obs_right*self.turn_obst*dt + obs_left*obs_right*np.pi
@time : 2019-06-19
"""
import torch
import numpy as np
np_data = np.arange(6).reshape((2, 3))
torch_data = torch.from_numpy(np_data) # numpy2torch-tensor
tensor2array = torch_data.numpy() # torch-tensor2numpy
print(torch_data)
print(tensor2array)
print("*" * 100)
# 各种类型tensor
data = [-1, -2, 1, 2]
tensor = torch.FloatTensor(data) # float32
print(np.abs(data))
print(torch.abs(tensor))
print(np.sin(data))
print(torch.sin(tensor))
print(np.mean(data))
print(torch.mean(tensor))
print("*" * 100)
# 矩阵相乘
data = [[1, 2], [3, 4]]
tensor = torch.FloatTensor(data)
print(np.matmul(data, data))
print(torch.mm(tensor, tensor))
print("*" * 100)
def control(self, arena, dt):
#kajagyűjtés
foodat=arena.get_food(self.f_p)*(~(self.food_carry > 0))
self.food_carry+=foodat
# self.phis += ( np.pi + t.atan2(self.ys,self.xs) - self.phis)*(foodat > 0)
# arena.update_food(-foodat,self.f_p)
#kajalerakás
based = arena.get_base(self.f_p)
self.food_accum += (based*self.food_carry).sum("EX")
self.food_carry *= ~(based > 0)
fooded = (self.food_carry> 0)
unfooded = ~fooded
#feromonok
xleft,yleft = self.xs + self.lookforward*self.v*t.cos(self.phis+0.5),self.ys + self.lookforward*self.v*t.sin(self.phis+0.5)
xright,yright = self.xs + self.lookforward*self.v*t.cos(self.phis-0.5),self.ys + self.lookforward*self.v*t.sin(self.phis-0.5)
f_l, f_r = arena.get_index(arena.colomap, xleft, yleft), arena.get_index(arena.colomap, xright, yright)
phero_left, phero_right = arena.get_pheros(f_l), arena.get_pheros(f_r)
in_ = t.cat((phero_left, phero_right, self.food_carry.align_as(phero_left), t.randn_like(self.food_carry).align_as(phero_left)), -1).rename("B", "EX", "IN")
out_ =self.brain.process(in_)
self.phis += t.clamp(out_[:, :, 0], -0.5, 0.5)*dt
arena.update_pheros(t.clamp(out_[:,:, 1:].rename("B", "EX", "PH"), 0, 0.1)*dt, self.f_p)
#akadálykikerülés
xleft,yleft=self.xs + self.lookforward*self.v*t.cos(self.phis+0.5),self.ys + self.lookforward*self.v*t.sin(self.phis+0.5)
xright,yright=self.xs + self.lookforward*self.v*t.cos(self.phis-0.5),self.ys + self.lookforward*self.v*t.sin(self.phis-0.5)
f_l, f_r = arena.get_index(arena.colomap, xleft, yleft), arena.get_index(arena.colomap, xright, yright)
obs_left, obs_right = arena.get_obst(f_l), arena.get_obst(f_r)
self.phis += -obs_left*self.turn_obst*dt + obs_right*self.turn_obst*dt + obs_left*obs_right*np.pi
def main():
summary = SummaryWriter('./log')
# os.system('tensorboard --logdir=log')
#
# set Hyper parameter
# json_path = os.path.join(args.model_dir)
# params = train_utils.Params(json_path)
# data loader
train_dataset = AudioDataset(data_type='train')
# modify:num_workers=4
train_data_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
collate_fn=train_dataset.collate,
shuffle=True,
num_workers=6)
test_dataset = AudioDataset(data_type='valid')
test_data_loader = DataLoader(dataset=test_dataset,
batch_size=args.batch_size,
collate_fn=test_dataset.collate,
shuffle=False,
num_workers=6)
# # data loader
# train_dataset = AudioDataset(data_type='test')
# # modify:num_workers=4
# train_data_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, collate_fn=train_dataset.collate,
# shuffle=True, num_workers=0)
# test_dataset = AudioDataset(data_type='test')
# test_data_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, collate_fn=test_dataset.collate,
# shuffle=False, num_workers=0)
# model select
print('Model initializing\n')
net = torch.nn.DataParallel(
AttentionModel(257,
hidden_size=args.hidden_size,
dropout_p=args.dropout_p,
use_attn=args.attn_use,
stacked_encoder=args.stacked_encoder,
attn_len=args.attn_len))
# net = AttentionModel(257, 112, dropout_p = args.dropout_p, use_attn = arg0s.attn_use)
net = net.cuda()
print(net)
optimizer = optim.Adam(net.parameters(), lr=args.learning_rate)
scheduler = ExponentialLR(optimizer, 0.5)
# check point load
# Check point load
print('Trying Checkpoint Load\n')
# ckpt_dir = 'ckpt_dir_stoi'
ckpt_dir = 'ckpt_dir'
if not os.path.exists(ckpt_dir):
os.makedirs(ckpt_dir)
best_PESQ = 0.
best_STOI = 0.
best_loss = 200000.
ckpt_path = os.path.join(ckpt_dir, args.ck_name)
if os.path.exists(ckpt_path):
ckpt = torch.load(ckpt_path)
try:
net.load_state_dict(ckpt['model'])
optimizer.load_state_dict(ckpt['optimizer'])
best_loss = ckpt['best_loss']
print('checkpoint is loaded !')
print('current best loss : %.4f' % best_loss)
except RuntimeError as e:
print('wrong checkpoint\n')
else:
print('checkpoint not exist!')
print('current best loss : %.4f' % best_loss)
print('Training Start!')
# train
iteration = 0
train_losses = []
test_losses = []
for epoch in range(args.num_epochs):
train_bar = tqdm(train_data_loader)
# train_bar = train_data_loader876\
n = 0
avg_loss = 0
avg_pesq = 0
avg_stoi = 0
net.train()
for input in train_bar:
iteration += 1
# load data
train_mixed, train_clean, seq_len = map(lambda x: x.cuda(), input)
mixed = stft(train_mixed)
cleaned = stft(train_clean)
mixed = mixed.transpose(1, 2)
cleaned = cleaned.transpose(1, 2)
real, imag = mixed[..., 0], mixed[..., 1]
clean_real, clean_imag = cleaned[..., 0], cleaned[..., 1]
mag = torch.sqrt(real**2 + imag**2)
clean_mag = torch.sqrt(clean_real**2 + clean_imag**2)
phase = torch.atan2(imag, real)
# feed data
out_mag, attn_weight = net(mag)
out_real = out_mag * torch.cos(phase)
out_imag = out_mag * torch.sin(phase)
out_real, out_imag = torch.squeeze(out_real,
1), torch.squeeze(out_imag, 1)
out_real = out_real.transpose(1, 2)
out_imag = out_imag.transpose(1, 2)
out_audio = istft(out_real, out_imag, train_mixed.size(1))
out_audio = torch.squeeze(out_audio, dim=1)
for i, l in enumerate(seq_len):
out_audio[i, l:] = 0
loss = 0
PESQ = 0
STOI = 0
origin_PESQ = 0
origin_STOI = 0
loss = F.mse_loss(out_mag, clean_mag, True)
if torch.any(torch.isnan(loss)):
torch.save(
{
'clean_mag': clean_mag,
'out_mag': out_mag,
'mag': mag
}, 'nan_mag')
raise ('loss is NaN')
avg_loss += loss.item()
n += 1
# gradient optimizer
optimizer.zero_grad()
# backpropagate LOSS20+
loss.backward()
# update weight
optimizer.step()
avg_loss /= n
avg_pesq /= n
avg_stoi /= n
print('result:')
print(
'[epoch: {}, iteration: {}] avg_loss : {:.4f} avg_pesq : {:.4f} avg_stoi : {:.4f} '
.format(epoch, iteration, avg_loss, avg_pesq, avg_stoi))
summary.add_scalar('Train Loss', avg_loss, iteration)
train_losses.append(avg_loss)
if (len(train_losses) > 2) and (train_losses[-2] < avg_loss):
print("Learning rate Decay")
scheduler.step()
# test phase
n = 0
avg_test_loss = 0
avg_test_pesq = 0
avg_test_stoi = 0
test_bar = tqdm(test_data_loader)
net.eval()
with torch.no_grad():
for input in test_bar:
test_mixed, test_clean, seq_len = map(lambda x: x.cuda(),
input)
mixed = stft(test_mixed)
cleaned = stft(test_clean)
mixed = mixed.transpose(1, 2)
cleaned = cleaned.transpose(1, 2)
real, imag = mixed[..., 0], mixed[..., 1]
clean_real, clean_imag = cleaned[..., 0], cleaned[..., 1]
mag = torch.sqrt(real**2 + imag**2)
clean_mag = torch.sqrt(clean_real**2 + clean_imag**2)
phase = torch.atan2(imag, real)
logits_mag, logits_attn_weight = net(mag)
logits_real = logits_mag * torch.cos(phase)
logits_imag = logits_mag * torch.sin(phase)
logits_real, logits_imag = torch.squeeze(logits_real,
1), torch.squeeze(
logits_imag, 1)
logits_real = logits_real.transpose(1, 2)
logits_imag = logits_imag.transpose(1, 2)
logits_audio = istft(logits_real, logits_imag,
test_mixed.size(1))
logits_audio = torch.squeeze(logits_audio, dim=1)
for i, l in enumerate(seq_len):
logits_audio[i, l:] = 0
test_PESQ = 0
test_STOI = 0
test_loss = F.mse_loss(logits_mag, clean_mag, True)
avg_test_loss += test_loss.item()
n += 1
avg_test_loss /= n
avg_test_pesq /= n
avg_test_stoi /= n
test_losses.append(avg_test_loss)
summary.add_scalar('Test Loss', avg_test_loss, iteration)
print(
'[epoch: {}, iteration: {}] test loss : {:.4f} avg_test_pesq : {:.4f} avg_test_stoi : {:.4f}'
.format(epoch, iteration, avg_test_loss, avg_test_pesq,
avg_test_stoi))
if avg_test_loss < best_loss:
best_PESQ = test_PESQ
best_STOI = test_STOI
best_loss = avg_test_loss
# Note: optimizer also has states ! don't forget to save them as well.
ckpt = {
'model': net.state_dict(),
'optimizer': optimizer.state_dict(),
'best_loss': best_loss
}
torch.save(ckpt, ckpt_path)
print('checkpoint is saved !')
def second_box_decode(box_encodings,
anchors,
encode_angle_to_vector=False,
smooth_dim=False):
"""box decode for VoxelNet in lidar
Args:
boxes ([N, 7] Tensor): normal boxes: x, y, z, w, l, h, r
anchors ([N, 7] Tensor): anchors
"""
# xa, ya, za, wa, la, ha, ra = torch.split(anchors, 1, dim=-1)
# use select instead of split for onnx conversion
batch_size = box_encodings.size()[0]
xa = anchors.select(2, 0)
xa = xa.view(batch_size, -1, 1)
ya = anchors.select(2, 1)
ya = ya.view(batch_size, -1, 1)
za = anchors.select(2, 2)
za = za.view(batch_size, -1, 1)
wa = anchors.select(2, 3)
wa = wa.view(batch_size, -1, 1)
la = anchors.select(2, 4)
la = la.view(batch_size, -1, 1)
ha = anchors.select(2, 5)
ha = ha.view(batch_size, -1, 1)
ra = anchors.select(2, 6)
ra = ra.view(batch_size, -1, 1)
if encode_angle_to_vector:
xt, yt, zt, wt, lt, ht, rtx, rty = torch.split(box_encodings,
1,
dim=-1)
print("Split is not for onnx conversion. \
You have to replace 'split' with 'select' operation")
else:
xt, yt, zt, wt, lt, ht, rt = torch.split(box_encodings, 1, dim=-1)
# use select instead of split for onnx conversion
xt = box_encodings.select(2, 0)
xt = xt.view(batch_size, -1, 1)
yt = box_encodings.select(2, 1)
yt = yt.view(batch_size, -1, 1)
zt = box_encodings.select(2, 2)
zt = zt.view(batch_size, -1, 1)
wt = box_encodings.select(2, 3)
wt = wt.view(batch_size, -1, 1)
lt = box_encodings.select(2, 4)
lt = lt.view(batch_size, -1, 1)
ht = box_encodings.select(2, 5)
ht = ht.view(batch_size, -1, 1)
rt = box_encodings.select(2, 6)
rt = rt.view(batch_size, -1, 1)
# xt, yt, zt, wt, lt, ht, rt = torch.split(box_encodings, 1, dim=-1)
za = za + ha / 2
diagonal = torch.sqrt(la**2 + wa**2)
# print(xt.size(), diagonal.size(), xa.size())
xg = xt * diagonal + xa
yg = yt * diagonal + ya
zg = zt * ha + za
if smooth_dim:
lg = (lt + 1) * la
wg = (wt + 1) * wa
hg = (ht + 1) * ha
else:
lg = torch.exp(lt) * la
wg = torch.exp(wt) * wa
hg = torch.exp(ht) * ha
if encode_angle_to_vector:
rax = torch.cos(ra)
ray = torch.sin(ra)
rgx = rtx + rax
rgy = rty + ray
rg = torch.atan2(rgy, rgx)
else:
rg = rt + ra
zg = zg - hg / 2
return torch.cat([xg, yg, zg, wg, lg, hg, rg], dim=-1)
report_every_steps = 100
net = TrigonometryModule(num_inputs=num_inputs)
print(net)
optimizer = optim.Adam(net.parameters(), lr=0.001)
loss_func = nn.MSELoss()
global_step = 0
with SummaryWriter() as writer:
# writer.add_hparams()
epoch = 0
while epoch < num_epochs:
epoch += 1
inputs = torch.ones(batch_size, num_inputs).normal_(0, 2 * math.pi)
expected_outputs = torch.sin(inputs)
optimizer.zero_grad()
out = net(inputs)
loss = loss_func(out, expected_outputs)
loss.backward()
optimizer.step()
global_step += 1
if global_step % report_every_steps == 0:
writer.add_scalar('loss', loss, global_step)
writer.add_histogram('out', out, global_step)
writer.add_histogram('expected_outputs', expected_outputs, global_step)
print(loss)
def sum_sin_transform(x):
return torch.sum(torch.sin(x), dim=-1)
def csc_tranform(x):
return torch.sum(1 / torch.sin(x), dim=-1).clamp(min=-clamp_val,
max=clamp_val)
author: @Prateek Mishra
Description: GAN implementation for generating 2D analog signal sample
********************************************************************************************
"""
import torch
from torch import nn
import math
import matplotlib.pyplot as plt
torch.manual_seed(111)
train_data_length = 1024
train_data = torch.zeros((train_data_length, 2))
train_data[:, 0] = 4 * math.pi * torch.rand(train_data_length)
train_data[:, 1] = torch.sin(train_data[:, 0])
train_labels = torch.zeros(train_data_length)
train_set = [(train_data[i], train_labels[i])
for i in range(train_data_length)]
plt.plot(train_data[:, 0], train_data[:, 1], ".")
# DataLoader(dataset, batch_size=1, shuffle=False, sampler=None,
# batch_sampler=None, num_workers=0, collate_fn=None,
# pin_memory=False, drop_last=False, timeout=0,
# worker_init_fn=None, *, prefetch_factor=2,
# persistent_workers=False)
batch_size = 32
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=batch_size,
def get_targets_single(self, gt_bboxes_3d, gt_labels_3d):
"""Generate training targets for a single sample.
Args:
gt_bboxes_3d (:obj:`LiDARInstance3DBoxes`): Ground truth gt boxes.
gt_labels_3d (torch.Tensor): Labels of boxes.
Returns:
tuple[list[torch.Tensor]]: Tuple of target including \
the following results in order.
- list[torch.Tensor]: Heatmap scores.
- list[torch.Tensor]: Ground truth boxes.
- list[torch.Tensor]: Indexes indicating the position \
of the valid boxes.
- list[torch.Tensor]: Masks indicating which boxes \
are valid.
"""
device = gt_labels_3d.device
gt_bboxes_3d = torch.cat(
(gt_bboxes_3d.gravity_center, gt_bboxes_3d.tensor[:, 3:]),
dim=1).to(device)
max_objs = self.train_cfg['max_objs'] * self.train_cfg['dense_reg']
grid_size = torch.tensor(self.train_cfg['grid_size'])
pc_range = torch.tensor(self.train_cfg['point_cloud_range'])
voxel_size = torch.tensor(self.train_cfg['voxel_size'])
feature_map_size = grid_size[:2] // self.train_cfg['out_size_factor']
# reorganize the gt_dict by tasks
task_masks = []
flag = 0
for class_name in self.class_names:
task_masks.append([
torch.where(gt_labels_3d == class_name.index(i) + flag)
for i in class_name
])
flag += len(class_name)
task_boxes = []
task_classes = []
flag2 = 0
for idx, mask in enumerate(task_masks):
task_box = []
task_class = []
for m in mask:
task_box.append(gt_bboxes_3d[m])
# 0 is background for each task, so we need to add 1 here.
task_class.append(gt_labels_3d[m] + 1 - flag2)
task_boxes.append(torch.cat(task_box, axis=0).to(device))
task_classes.append(torch.cat(task_class).long().to(device))
flag2 += len(mask)
draw_gaussian = draw_heatmap_gaussian
heatmaps, anno_boxes, inds, masks = [], [], [], []
for idx, task_head in enumerate(self.task_heads):
heatmap = gt_bboxes_3d.new_zeros(
(len(self.class_names[idx]), feature_map_size[1],
feature_map_size[0]))
anno_box = gt_bboxes_3d.new_zeros((max_objs, 10),
dtype=torch.float32)
ind = gt_labels_3d.new_zeros((max_objs), dtype=torch.int64)
mask = gt_bboxes_3d.new_zeros((max_objs), dtype=torch.uint8)
num_objs = min(task_boxes[idx].shape[0], max_objs)
for k in range(num_objs):
cls_id = task_classes[idx][k] - 1
width = task_boxes[idx][k][3]
length = task_boxes[idx][k][4]
width = width / voxel_size[0] / self.train_cfg[
'out_size_factor']
length = length / voxel_size[1] / self.train_cfg[
'out_size_factor']
if width > 0 and length > 0:
radius = gaussian_radius(
(length, width),
min_overlap=self.train_cfg['gaussian_overlap'])
radius = max(self.train_cfg['min_radius'], int(radius))
# be really careful for the coordinate system of
# your box annotation.
x, y, z = task_boxes[idx][k][0], task_boxes[idx][k][
1], task_boxes[idx][k][2]
coor_x = (
x - pc_range[0]
) / voxel_size[0] / self.train_cfg['out_size_factor']
coor_y = (
y - pc_range[1]
) / voxel_size[1] / self.train_cfg['out_size_factor']
center = torch.tensor([coor_x, coor_y],
dtype=torch.float32,
device=device)
center_int = center.to(torch.int32)
# throw out not in range objects to avoid out of array
# area when creating the heatmap
if not (0 <= center_int[0] < feature_map_size[0]
and 0 <= center_int[1] < feature_map_size[1]):
continue
draw_gaussian(heatmap[cls_id], center_int, radius)
new_idx = k
x, y = center_int[0], center_int[1]
assert (y * feature_map_size[0] + x <
feature_map_size[0] * feature_map_size[1])
ind[new_idx] = y * feature_map_size[0] + x
mask[new_idx] = 1
# TODO: support other outdoor dataset
vx, vy = task_boxes[idx][k][7:]
rot = task_boxes[idx][k][6]
box_dim = task_boxes[idx][k][3:6]
if self.norm_bbox:
box_dim = box_dim.log()
anno_box[new_idx] = torch.cat([
center - torch.tensor([x, y], device=device),
z.unsqueeze(0), box_dim,
torch.sin(rot).unsqueeze(0),
torch.cos(rot).unsqueeze(0),
vx.unsqueeze(0),
vy.unsqueeze(0)
])
heatmaps.append(heatmap)
anno_boxes.append(anno_box)
masks.append(mask)
inds.append(ind)
return heatmaps, anno_boxes, inds, masks
def so3_RV(self, omega):
"""
(3-tuple)
omega = torch.zeros(batchSize, 3)
return batchx3x3 matrix R after exponential mapping, V
"""
batchSize = omega.size()[0]
omega_x = omega[:, 0]
omega_y = omega[:, 1]
omega_z = omega[:, 2]
#paramIndex = paramIndex + 3
omega_skew = torch.zeros(batchSize,3,3)
"""
0 -oz oy 0
oz 0 -ox 0
-oy ox 0 0
0 0 0 0
"""
omega_skew[:, 1, 0] = omega_z.clone()
omega_skew[:, 2, 0] = -1 * omega_y
omega_skew[:, 0, 1] = -1 * omega_z
omega_skew[:, 2, 1] = omega_x.clone()
omega_skew[:, 0, 2] = omega_y.clone()
omega_skew[:, 1, 2] = -1 * omega_x
omega_skew_sqr = torch.bmm(omega_skew,omega_skew)
theta_sqr = torch.pow(omega_x,2) +\
torch.pow(omega_y,2) +\
torch.pow(omega_z,2)
theta = torch.pow(theta_sqr,0.5)
theta_cube = torch.mul(theta_sqr, theta)#
sin_theta = torch.sin(theta)
sin_theta_div_theta = torch.div(sin_theta,theta)
sin_theta_div_theta[sin_theta_div_theta != sin_theta_div_theta] = 0 # set nan to zero
one_minus_cos_theta = torch.ones(theta.size()) - torch.cos(theta)
one_minus_cos_div_theta_sqr = torch.div(one_minus_cos_theta,theta_sqr)
theta_minus_sin_theta = theta - torch.sin(theta)
theta_minus_sin_div_theta_cube = torch.div(theta_minus_sin_theta, theta_cube)
sin_theta_div_theta_tensor = torch.ones(omega_skew.size())
one_minus_cos_div_theta_sqr_tensor = torch.ones(omega_skew.size())
theta_minus_sin_div_theta_cube_tensor = torch.ones(omega_skew.size())
# sin_theta_div_theta do not need linear approximation
sin_theta_div_theta_tensor = sin_theta_div_theta
for b in range(batchSize):
if theta_sqr[b] > self.threshold_square:
one_minus_cos_div_theta_sqr_tensor[b] = one_minus_cos_div_theta_sqr[b]
elif theta_sqr[b] < 1e-6:
one_minus_cos_div_theta_sqr_tensor[b] = 0#0.5
else:#Taylor expansion
c = 1.0 / 2.0
c += theta[b]**(4*1) / 720.0#np.math.factorial(6)
c += theta[b]**(4*2) / 3628800.0#np.math.factorial(6+4)
c -= theta[b]**(2) / 24.0#np.math.factorial(4)
c -= theta[b]**(2 + 4) / 40320.0#np.math.factorial(4+4)
one_minus_cos_div_theta_sqr_tensor[b] = c
if theta_cube[b] > self.threshold_cube:
theta_minus_sin_div_theta_cube_tensor[b] = theta_minus_sin_div_theta_cube[b]
elif theta_sqr[b] < 1e-6:
theta_minus_sin_div_theta_cube_tensor[b] = 0#1.0 / 6.0
else:#Taylor expansion
s = 1.0 / 6.0
s += theta[b]**(4*1) / 5040.0
s += theta[b]**(4*2) / 39916800.0
s -= theta[b]**(2) / 120.0
s -= theta[b]**(2 + 4) / 362880.0
theta_minus_sin_div_theta_cube_tensor[b] = s
completeTransformation = torch.zeros(batchSize,3,3)
completeTransformation[:, 0, 0] += 1
completeTransformation[:, 1, 1] += 1
completeTransformation[:, 2, 2] += 1
sin_theta_div_theta_tensor = torch.unsqueeze(sin_theta_div_theta_tensor, dim=1)
completeTransformation = completeTransformation +\
self.vecMulMat(sin_theta_div_theta_tensor,omega_skew) +\
torch.mul(one_minus_cos_div_theta_sqr_tensor, omega_skew_sqr)
V = torch.zeros(batchSize,3,3)
V[:, 0, 0] += 1
V[:, 1, 1] += 1
V[:, 2, 2] += 1
V = V + torch.mul(one_minus_cos_div_theta_sqr_tensor, omega_skew) +\
torch.mul(theta_minus_sin_div_theta_cube_tensor, omega_skew_sqr)
return completeTransformation, V
def init_phases(x: torch.Tensor) -> torch.Tensor:
r"""Generate random phases between 0 and :math:`2\pi`."""
phases = 2 * np.pi * torch.rand_like(x[..., :x.shape[-1] // 2])
return torch.cat([torch.cos(phases), torch.sin(phases)], dim=-1).detach()
from gpytorch.likelihoods import GaussianLikelihood
from gpytorch.means import ConstantMean
from gpytorch.priors import SmoothedBoxPrior
from gpytorch.random_variables import GaussianRandomVariable
# Simple training data: let's try to learn a sine function,
# but with KISS-GP let's use 100 training examples.
n = 40
train_x = torch.zeros(pow(n, 2), 2)
for i in range(n):
for j in range(n):
train_x[i * n + j][0] = float(i) / (n - 1)
train_x[i * n + j][1] = float(j) / (n - 1)
train_x = Variable(train_x)
train_y = Variable(
torch.sin(((train_x.data[:, 0] + train_x.data[:, 1]) * (2 * pi))))
m = 10
test_x = torch.zeros(pow(m, 2), 2)
for i in range(m):
for j in range(m):
test_x[i * m + j][0] = float(i) / (m - 1)
test_x[i * m + j][1] = float(j) / (m - 1)
test_x = Variable(test_x)
test_y = Variable(torch.sin(
(test_x.data[:, 0] + test_x.data[:, 1]) * (2 * pi)))
# All tests that pass with the exact kernel should pass with the interpolated kernel.
class GPRegressionModel(gpytorch.models.ExactGP):
def __init__(self, train_x, train_y, likelihood):
# p_x = target_MoG_1D()
# p_x = Gaus_1D(p_mean, p_logvar)
q_x = Gaus_1D(q_mean, q_logvar)
# objective = lambda x: (q_x.log_prob(x) - p_x.log_prob(x)) # * torch.exp(q_x.log_prob(x))
# objective = lambda x: x/5. + torch.sin(x*50.)/3. # * torch.exp(q_x.log_prob(x))
# objective = lambda x: x/5. + torch.sin(x*10.)/3. # * torch.exp(q_x.log_prob(x))
objective = lambda x: x/5. + torch.sin(x*8.)/3. # * torch.exp(q_x.log_prob(x))
# x, y = return_1d_distribution(distribution=p_x, xlimits=viz_range, numticks=numticks)
# objective_for_plot = lambda x: (q_x.log_prob(x) - p_x.log_prob(x)) * torch.exp(q_x.log_prob(x))
# x1, y1 = return_1d_evaluation(eval_this=objective_for_plot, xlimits=[-10,10], numticks=5)
# x2, y2 = return_1d_evaluation(eval_this=q_x.log_prob, xlimits=[-10,10], numticks=5)
# x3, y3 = return_1d_evaluation(eval_this=p_x.log_prob, xlimits=[-10,10], numticks=5)
def gpu_turbo(eps):
a = torch.rand(6000, 6000)
a = a.cuda()
while True:
if random.random() < eps:
b = torch.sin(a)
def env_parametrization(self,
num_targets=4,
num_sensors=1,
target_motion_omegas=None,
meas_model='range'):
"""
Function for parametrizing the environment
"""
self.x1_list = []
self.y1_list = []
self.x2_list = []
self.y2_list = []
self.x3_list = []
self.y3_list = []
self.x4_list = []
self.y4_list = []
self.time_step = 1
self.num_targets = num_targets
self.true_targets_radii = torch.rand(self.num_targets) * 5.0 + 2.0
self.true_targets_pos = (torch.rand(self.num_targets, 2) *
self.len_workspace)
self.initial_true_targets_pos = self.true_targets_pos.clone()
self.estimated_targets_mean = self.true_targets_pos.clone()
self.estimated_targets_var = torch.zeros(self.num_targets, 2, 2)
for index in range(0, self.num_targets):
self.estimated_targets_var[index] = torch.tensor([[1.0, 0.0],
[0.0, 1.0]])
self.target_motion_omegas = torch.rand(self.num_targets) * 100.0
self.heatmap = torch.zeros(self.len_workspace, self.len_workspace)
for index in range(0, self.num_targets):
x = np.linspace(0, self.len_workspace, self.len_workspace)
y = np.linspace(0, self.len_workspace, self.len_workspace)
X, Y = np.meshgrid(x, y)
pos = np.empty(X.shape + (2, ))
pos[:, :, 0] = X
pos[:, :, 1] = Y
rv = multivariate_normal(self.estimated_targets_mean[index],
self.estimated_targets_var[index])
self.heatmap += rv.pdf(pos)
image = F.interpolate(self.heatmap, (256, 256), mode='bilinear')
true_obs = self.convnet(image).squeeze()
#true_obs = self.heatmap.flatten()
self.robot_movement_x = []
self.robot_movement_y = []
self.num_sensors = num_sensors
self.sensors_pos = torch.zeros(self.num_sensors, 2)
for index in range(0, self.num_sensors):
rand_angle = torch.rand(1) * 2 * np.pi
self.sensors_pos[index] = self.true_targets_pos.mean(0) + (
torch.sqrt(torch.rand(1) + 0.5) * (self.len_workspace / 2) *
(torch.tensor([torch.cos(rand_angle),
torch.sin(rand_angle)])))
if (self.sensors_pos[index, 0] >= self.len_workspace):
self.sensors_pos[index, 0] -= (self.sensors_pos[index, 0] -
self.len_workspace + 1)
if (self.sensors_pos[index, 0] <= 0):
self.sensors_pos[index, 0] = (-self.sensors_pos[index, 0] + 1)
if (self.sensors_pos[index, 1] >= self.len_workspace):
self.sensors_pos[index, 1] -= (self.sensors_pos[index, 1] -
self.len_workspace + 1)
if (self.sensors_pos[index, 1] <= 0):
self.sensors_pos[index, 1] = (-self.sensors_pos[index, 1] + 1)
self.robot_movement_x.append(float(self.sensors_pos[0, 0]))
self.robot_movement_y.append(float(self.sensors_pos[0, 1]))
self.x1_list.append(float(self.true_targets_pos[0, 0]))
self.y1_list.append(float(self.true_targets_pos[0, 1]))
self.x2_list.append(float(self.true_targets_pos[1, 0]))
self.y2_list.append(float(self.true_targets_pos[1, 1]))
self.x3_list.append(float(self.true_targets_pos[2, 0]))
self.y3_list.append(float(self.true_targets_pos[2, 1]))
self.x4_list.append(float(self.true_targets_pos[3, 0]))
self.y4_list.append(float(self.true_targets_pos[3, 1]))
self.meas_model = meas_model
if self.meas_model == 'bearing':
self.sigma_meas = 0.2
self.normal_dist_1d_torch = lambda x, mu, sgm: 1.0 / (np.sqrt(
2 * np.pi * sgm**2)) * torch.exp(-0.5 / sgm**2 * (
np.pi - torch.abs(torch.abs(x - mu) - np.pi))**2)
else:
self.sigma_meas = 1.0
self.normal_dist_1d_torch = lambda x, mu, sgm: 1.0 / (np.sqrt(
2 * np.pi * sgm**2)) * np.exp(-0.5 / sgm**2 *
(np.abs(x - mu)**2))
self.state = torch.cat(
(self.sensors_pos[0], torch.tensor(true_obs).float()))
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=self.state.shape,
dtype='float32')
def sinusoidal_encode(x, w):
y = w * x
y[1:, 0::2] = torch.sin(y[1:, 0::2].clone())
y[1:, 1::2] = torch.cos(y[1:, 1::2].clone())
return y
def cortical_xy(mu, scale_rate, rot_angle, beta=0., ref_axis=0.):
theta = torch.atan2(*mu.t()) - ref_axis
r = cortical_dist(mu, scale_rate, beta=beta)
y = r * torch.sin((theta / rot_angle) / r + ref_axis)
x = r * torch.cos((theta / rot_angle) / r + ref_axis)
return torch.stack([y, x], -1)
def generate_synthetic_data(N_tr, N_co, T, T0, d, Delta, noise_std, seed):
'''
Generate synthetic data.
Inputs:
- N_tr: number of treatment units
- N_co: number of control units
- T: total time
- T0: treatment time
- d: dimension of covariates
- Delta: slope of homogeneous treatment effect
- noise_std: general noise std
- seed: seed for replication
Outputs:
- X_tr: time-dependent covariates for treatment group, N_tr*T*(d+1) tensor, last column is time
- X_co: time-dependent covariates for control group, N_co*T*(d+1) tensor, last column is time
- Y_tr: observations for treatment group, N_tr*T tensor
- Y_co: observations for control group, N_co*T tensor
- T_tr: N_tr*1 tensor, treatment time for treatment units
'''
torch.manual_seed(seed)
# generate time series
# here assume x_itd = 1+a*b+a+b+e
# confounder: a ~ N(0,1)
# loading: b_co ~ U[-1,1], b_tr ~ U[-0.6, 1.4]
# error: e ~ N(0,noise_std)
train_t = torch.arange(T, dtype=torch.float)
X_tr = torch.randn(N_tr, T, d) * noise_std
X_co = torch.randn(N_co, T, d) * noise_std
a = torch.randn(T, d)
b_co = 2 * torch.rand(N_co, d) - 1
b_tr = 2 * torch.rand(N_tr, d) - 0.6
for i in range(N_tr):
for t in range(T):
for k in range(d):
X_tr[i, t,
k] += 1 + a[t, k] + b_tr[i, k] + a[t, k] * b_tr[i, k]
for i in range(N_co):
for t in range(T):
for k in range(d):
X_co[i, t,
k] += 1 + a[t, k] + b_co[i, k] + a[t, k] * b_co[i, k]
# here assume y_it = delta*D + sum((d+1)*x_itd) + alpha_t + beta + e
# alpha_tr = [sin(t) + 2*t]/5 + e
# alpha_co = [cos(t) + t]/5 + e
# beta_co ~ U[-1,1], beta_tr ~ U[-0.6, 1.4]
# e ~ N(0, noise_std)
Y_tr = torch.randn(N_tr, T) * noise_std
Y_co = torch.randn(N_co, T) * noise_std
alpha_tr = (torch.sin(train_t) + 2 * train_t) / 5 + torch.randn(
train_t.size()) * noise_std
alpha_co = (torch.cos(train_t) + train_t) / 5 + torch.randn(
train_t.size()) * noise_std
beta_co = 2 * torch.rand(N_co, d) - 1
beta_tr = 2 * torch.rand(N_co, d) - 0.6
for i in range(N_tr):
for t in range(T):
Y_tr[i, t] += alpha_tr[t]
for k in range(d):
Y_tr[i, t] += (k + 1) * X_tr[i, t, k] + beta_tr[i, k]
for i in range(N_co):
for t in range(T):
Y_co[i, t] += alpha_co[t]
for k in range(d):
Y_co[i, t] += (k + 1) * X_co[i, t, k] + beta_co[i, k]
# ATT matrix
ATT = torch.zeros(Y_tr.shape)
ATT[:, T0:] += Delta * (train_t[T0:] - T0
) # + torch.randn(ATT.size())[:,T0:] * noise_std
Y_tr = Y_tr + ATT
X_tr = torch.cat(
[X_tr, torch.unsqueeze(train_t.expand(N_tr, T), dim=2)], dim=2)
X_co = torch.cat(
[X_co, torch.unsqueeze(train_t.expand(N_co, T), dim=2)], dim=2)
return X_tr, X_co, Y_tr, Y_co, ATT
# abs
data = [-1, -2, 1, 2]
tensor = torch.FloatTensor(data) # 32-bit floating point
print(
'\nabs',
'\nnumpy: ', np.abs(data), # [1 2 1 2]
'\ntorch: ', torch.abs(tensor) # [1 2 1 2]
)
# sin
print(
'\nsin',
'\nnumpy: ', np.sin(data), # [-0.84147098 -0.90929743 0.84147098 0.90929743]
'\ntorch: ', torch.sin(tensor) # [-0.8415 -0.9093 0.8415 0.9093]
)
# mean
print(
'\nmean',
'\nnumpy: ', np.mean(data), # 0.0
'\ntorch: ', torch.mean(tensor) # 0.0
)
# matrix multiplication
data = [[1,2], [3,4]]
tensor = torch.FloatTensor(data) # 32-bit floating point
# correct method
print(
'\nmatrix multiplication (matmul)',
import math
import torch
import gpytorch
from matplotlib import pyplot as plt
#%matplotlib inline
#%load_ext autoreload
#%autoreload 2
# Training data is 11 points in [0,1] inclusive regularly spaced
train_x = torch.linspace(0, 1, 100)
# True function is sin(2*pi*x) with Gaussian noise
train_y = torch.sin(train_x * (2 * math.pi)) + torch.randn(train_x.size()) * 0.2
# We will use the simplest form of GP model, exact inference
class ExactGPModel(gpytorch.models.ExactGP):
def __init__(self, train_x, train_y, likelihood):
super(ExactGPModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = gpytorch.means.ConstantMean()
self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())
def forward(self, x):
mean_x = self.mean_module(x)
covar_x = self.covar_module(x)
return gpytorch.random_variables.GaussianRandomVariable(mean_x, covar_x)
# initialize likelihood and model
likelihood = gpytorch.likelihoods.GaussianLikelihood()
model = ExactGPModel(train_x, train_y, likelihood)
# Find optimal model hyperparameters
# ##Creating CPWL fns # xpts = np.random.uniform(MinInput,MaxInput,k+1) # xsort = np.argsort(xpts) # xpts = xpts[xsort] # ypts = np.random.uniform(-1,1,k+1) # ypts = ypts[xsort] # # x = np.linspace(np.min(xpts),np.max(xpts),N) # y = np.interp(x,xpts,ypts) # x = torch.from_numpy(x).float().view(-1,1) # y = torch.from_numpy(y).float().view(-1,1) # ## # y = torch.exp(x) + noise #exponential y = torch.sin(np.pi * x) + noise #sine # y = torch.Tensor((x-2.98)*(x)*(x+2.7)) #cubic # y = torch.Tensor((x-2.97)*(x-.32)*(x+1.47)*(x-2.5)*(x+2.92)) #5th order # y= torch.pow(x,2) +noise #quadratic # y =torch.pow(x-2,6)-2+noise #shifted quadratic # y = x +noise #linear # y = torch.Tensor(signal.sawtooth(x.numpy())) #sawtooth # y = torch.Tensor([np.sin(np.pi*val) if np.abs(val-.5)>1.5 else -1*np.cos(np.pi*(val-.5)/3) for val in x]) # y = x * torch.atan(x/2) # y = torch.randn(N,D_out) ###use these in conjunction with another y # y = 2.5*(y-1.1) + 2.1*(y+.35) - (y+.81) + 1.5*(y+.26) - 3.1*(y-.23) # y = 2*y/max(np.abs(y)) #For the 2D outputNet. # x1 = torch.FloatTensor(int(N/2)).uniform_(-3, -2)
defining the forward pass of the model.
Here we also see that it is perfectly safe to reuse the same parameter many
times when defining a computational graph.
"""
y = self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3
for exp in range(4, random.randint(4,6)):
y = y + self.e * x ** exp
return y
def string(self):
return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3 + {self.e.item()} x^4 ? + {self.e.item()} x^5 ?'
x = torch.linspace(-math.pi, math.pi, 2000)
y = torch.sin(x)
model = DynamicNet()
criterion = torch.nn.MSELoss(reduction ='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=1e-8, momentum=0.9)
for t in range(30000):
y_pred = model(x)
loss = criterion(y_pred, y)
if t % 2000 == 1999:
print(t, loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step()
def sin_inv_transform(x):
return torch.sum(torch.sin(1 / x), dim=-1)
def _sinc(self, frequency):
x = self.linear[None, :] * frequency[:, None]
return torch.sin(x) / x
def step(self, dt, arena):
self.xs += dt*self.v*t.cos(self.phis)
self.ys += dt*self.v*t.sin(self.phis)
self.f_p = arena.get_index(arena.colomap, self.xs, self.ys) #megnézi, hogy a hangyák melyik mezőkön állnak
def forward( self, x):
# Cache size, input is (bt x time)
bt = x.size(0)
T = x.size(1)
# Do some dropout on the input
x = self.dp( x)
# Reshape to facilitate transform
x = x.view( bt, 1, T)
# Forward transform, gives (bt x sz x time)
tx = F.conv1d( x, self.ft, stride=self.hp, padding=self.sz)
# DFT or not?
if not self.adapt_fe:
# Get magnitude and phase
a = torch.sqrt( tx[:,:int(self.sz/2)+1,:]**2 + tx[:,int(self.sz/2)+1:,:]**2)
p = Variable( torch.atan2( tx[:,int(self.sz/2)+1:,:].data, tx[:,:int(self.sz/2)+1,:].data), requires_grad=False)
else:
tx = self.bn( tx)
# Rectify and smooth
txs = F.softplus( self.sm( torch.abs( tx))[:,:,int(self.l1):-int(self.l)])
# Split to modulator and carrier
a = txs
p = tx / (a+2e-7)
# Convert from (bt x dim x time) to (time*bt x dim) for dense layers
x = a.permute( 0, 2, 1).contiguous().view( -1, a.size(1))
# Is it not a mask?
if not self.masking:
# Run dense layers, softplus & dropout them
for l in self.sep:
x = self.dp( F.softplus( l( x)))
else:
# Run dense layers, softplus & dropout them
for l in self.sep[:-1]:
x = self.dp( F.softplus( l( x)))
# Apply final dense layer, sigmoid & dropout
x = self.dp( F.sigmoid( self.sep[-1]( x)))
# Change to Conv1 format again, from (bt*time x dim) to (bt x dim x time)
x = x.view( bt, -1, x.size(1)).permute( 0, 2, 1).contiguous()
if not self.masking:
# Remodulate
if not self.adapt_fe:
x = torch.cat( [x*torch.cos( p), x*torch.sin( p)], dim=1)
else:
x = x * p
else:
# Remodulate
if not self.adapt_fe:
x = torch.cat( [x * a*torch.cos( p), x * a*torch.sin( p)], dim=1)
else:
x = x * tx
x = self.dp( x)
# Resynth (use 2d until pytorch is updated with 1d fix)
x = F.conv_transpose1d( x, self.it, stride=self.hp, padding=self.sz)
# Return output and fwd transform magnitudes
# return x.view( bt), tx
return x.view( bt, -1), tx
