def forward(self, input_x):
#input data dim. is batch X 1 X feature_size X time
if not input_x.shape[1] == 1:
exit(1)
x = input_x.view(
(input_x.shape[0], input_x.shape[2], input_x.shape[3]), -1)
x = x.transpose(1, 2)
for layer in self.layer[:-1]:
x = layer(x)
xb = self.layer[-1](x)
stack = []
for b_idx in range(xb.shape[0]):
M = self.M_base.clone()
for t_idx in range(xb.shape[2]):
M = torch.addr(M, x[b_idx, :, t_idx], xb[b_idx, :, t_idx])
stack.append(M.view(-1))
x = torch.stack(stack)
for layer in self.bottleneck_layer:
x = layer(x)
x = self.bottle_neck(x)
self.features = self.l2_norm(x)
# Multiply by alpha = 10 as suggested in https://arxiv.org/pdf/1703.09507.pdf
alpha = 10
self.features = self.features * alpha
return self.features
def forward(ctx, add_matrix, vector1, vector2, alpha=1, beta=1, inplace=False):
ctx.alpha = alpha
ctx.beta = beta
ctx.add_matrix_size = add_matrix.size()
ctx.save_for_backward(vector1, vector2)
output = _get_output(ctx, add_matrix, inplace=inplace)
return torch.addr(alpha, add_matrix, beta,
vector1, vector2, out=output)
def unbind_role_att(role_vec, att_vec, r, att):
a = torch.addr(torch.zeros(dim, dim), role_vec, att_vec)
un_att = torch.mul(memory_tensor, a)
fil = torch.sum(torch.sum(un_att, 2), 1)
orig = arr_af_arrs_of_commands[att][r]
diff = orig - fil
print(pure_arr_of_commands[att][r])
print((diff).sum())
def forward(ctx, add_matrix, vector1, vector2, alpha=1, beta=1, inplace=False):
ctx.alpha = alpha
ctx.beta = beta
ctx.add_matrix_size = add_matrix.size()
ctx.save_for_backward(vector1, vector2)
output = _get_output(ctx, add_matrix, inplace=inplace)
return torch.addr(alpha, add_matrix, beta,
vector1, vector2, out=output)
def forward(self, add_matrix, vector1, vector2):
self.save_for_backward(vector1, vector2)
output = self._get_output(add_matrix)
return torch.addr(self.alpha,
add_matrix,
self.beta,
vector1,
vector2,
out=output)
def test_outer_ger_addr_legacy_tests(self, device):
for size in ((0, 0), (0, 5), (5, 0)):
a = torch.rand(size[0], device=device)
b = torch.rand(size[1], device=device)
self.assertEqual(torch.outer(a, b).shape, size)
self.assertEqual(torch.ger(a, b).shape, size)
m = torch.empty(size, device=device)
self.assertEqual(torch.addr(m, a, b).shape, size)
m = torch.randn(5, 6, device=device)
a = torch.randn(5, device=device)
b = torch.tensor(6, device=device)
self.assertRaises(RuntimeError, lambda: torch.outer(a, b))
self.assertRaises(RuntimeError, lambda: torch.outer(b, a))
self.assertRaises(RuntimeError, lambda: torch.ger(a, b))
self.assertRaises(RuntimeError, lambda: torch.ger(b, a))
self.assertRaises(RuntimeError, lambda: torch.addr(m, a, b))
self.assertRaises(RuntimeError, lambda: torch.addr(m, b, a))
def blas_lapack_ops(self):
m = torch.randn(3, 3)
a = torch.randn(10, 3, 4)
b = torch.randn(10, 4, 3)
v = torch.randn(3)
return (
torch.addbmm(m, a, b),
torch.addmm(torch.randn(2, 3), torch.randn(2, 3),
torch.randn(3, 3)),
torch.addmv(torch.randn(2), torch.randn(2, 3), torch.randn(3)),
torch.addr(torch.zeros(3, 3), v, v),
torch.baddbmm(m, a, b),
torch.bmm(a, b),
torch.chain_matmul(torch.randn(3, 3), torch.randn(3, 3),
torch.randn(3, 3)),
# torch.cholesky(a), # deprecated
torch.cholesky_inverse(torch.randn(3, 3)),
torch.cholesky_solve(torch.randn(3, 3), torch.randn(3, 3)),
torch.dot(v, v),
torch.eig(m),
torch.geqrf(a),
torch.ger(v, v),
torch.inner(m, m),
torch.inverse(m),
torch.det(m),
torch.logdet(m),
torch.slogdet(m),
torch.lstsq(m, m),
torch.lu(m),
torch.lu_solve(m, *torch.lu(m)),
torch.lu_unpack(*torch.lu(m)),
torch.matmul(m, m),
torch.matrix_power(m, 2),
# torch.matrix_rank(m),
torch.matrix_exp(m),
torch.mm(m, m),
torch.mv(m, v),
# torch.orgqr(a, m),
# torch.ormqr(a, m, v),
torch.outer(v, v),
torch.pinverse(m),
# torch.qr(a),
torch.solve(m, m),
torch.svd(a),
# torch.svd_lowrank(a),
# torch.pca_lowrank(a),
# torch.symeig(a), # deprecated
# torch.lobpcg(a, b), # not supported
torch.trapz(m, m),
torch.trapezoid(m, m),
torch.cumulative_trapezoid(m, m),
# torch.triangular_solve(m, m),
torch.vdot(v, v),
)
def run_test_case(m, a, b, beta=1, alpha=1):
if dtype == torch.bfloat16:
a_np = a.to(torch.double).cpu().numpy()
b_np = b.to(torch.double).cpu().numpy()
m_np = m.to(torch.double).cpu().numpy()
else:
a_np = a.cpu().numpy()
b_np = b.cpu().numpy()
m_np = m.cpu().numpy()
if beta == 0:
expected = alpha * np.outer(a_np, b_np)
else:
expected = beta * m_np + alpha * np.outer(a_np, b_np)
self.assertEqual(torch.addr(m, a, b, beta=beta, alpha=alpha), expected)
self.assertEqual(torch.Tensor.addr(m, a, b, beta=beta, alpha=alpha), expected)
result_dtype = torch.addr(m, a, b, beta=beta, alpha=alpha).dtype
out = torch.empty_like(m, dtype=result_dtype)
torch.addr(m, a, b, beta=beta, alpha=alpha, out=out)
self.assertEqual(out, expected)
def get_mats_from_arr(self, arr, command_number):
arr_of_mats = []
arr_of_diags = []
arr_of_symbols_for_command = []
arr_of_commands = []
final_mat = torch.zeros(
self.dim,
self.dim) # missing: matrix of zeros of dimension dim x dim
nodes_traversed = 0
for i, el in enumerate(arr):
vec_for_role = self.dict_of_role_vectors[arr_of_roles[i]]
if isinstance(el,
list): # missing: check if type of element is array
command_number += 1
pointer_name = "T" + str(command_number)
diags, mats, commands, nodes_traversed_in_this_tree = self.get_mats_from_arr(
el, command_number)
arr_of_mats.append(mats)
arr_of_diags.append(diags)
nodes_traversed += nodes_traversed_in_this_tree
command_number += nodes_traversed - 1
arr_of_symbols_for_command.append(pointer_name)
arr_of_commands.append(commands)
self.dict_of_pointers[pointer_name] = diags[0]
vec_for_el = diags[0]
else: # it's atom
vec_for_el = self.dict_of_atom_vectors[el]
arr_of_symbols_for_command.append(el)
final_mat += torch.addr(
torch.zeros(dim, dim), vec_for_el,
vec_for_role) # missing: outer product of role and element
diag_of_final_mat = torch.diag(
final_mat) # missing: get diagonal of matrix
normed_diag_of_final_mat = torch.div(diag_of_final_mat,
torch.norm(diag_of_final_mat,
2)) # normalize it
arr_of_mats.insert(0, final_mat) # prepend to the array
arr_of_diags.insert(0, normed_diag_of_final_mat)
arr_of_commands.insert(0, arr_of_symbols_for_command)
return arr_of_diags, arr_of_mats, arr_of_commands, nodes_traversed + 1
def _update(self, s, y, rho_inv):
rho = rho_inv.reciprocal()
if self.inverse:
if self.n_updates == 0:
self.H.mul_(rho_inv / y.dot(y))
torch.addr(torch.chain_matmul(torch.addr(self.I, s, y, alpha=-rho),
self.H,
torch.addr(self.I, y, s,
alpha=-rho)),
s,
s,
alpha=rho,
out=self.H)
else:
if self.n_updates == 0:
self.B.mul_(rho * y.dot(y))
Bs = torch.mv(self.B, s)
torch.addr(torch.addr(self.B, y, y, alpha=rho),
Bs,
Bs,
alpha=s.dot(Bs).reciprocal().neg(),
out=self.B)
def forward(self):
return torch.addr(self.input_one, self.vec1, self.vec2)
# Dot product of 2 tensors r = torch.dot(torch.Tensor([4, 2]), torch.Tensor([3, 1])) # 14 # Outer product of 2 vectors # Size 3x2 v1 = torch.arange(1, 4) # Size 3 v2 = torch.arange(1, 3) # Size 2 r = torch.ger(v1, v2) # Add M with outer product of 2 vectors # Size 3x2 vec1 = torch.arange(1, 4) # Size 3 vec2 = torch.arange(1, 3) # Size 2 M = torch.zeros(3, 2) r = torch.addr(M, vec1, vec2) # Batch Matrix x Matrix # Size 10x3x5 batch1 = torch.randn(10, 3, 4) batch2 = torch.randn(10, 4, 5) r = torch.bmm(batch1, batch2) # Batch Matrix + Matrix x Matrix # Performs a batch matrix-matrix product # 3x4 + (5x3x4 X 5x4x2 ) -> 5x3x2 M = torch.randn(3, 2) batch1 = torch.randn(5, 3, 4) batch2 = torch.randn(5, 4, 2) r = torch.addbmm(M, batch1, batch2)
def forward(self, x, y, z):
out1 = x.addr(y, z, beta=2, alpha=3)
out2 = torch.addr(x, y, z, beta=2, alpha=3)
return out1, out2
def observe_reward(self, features, action_taken, reward):
a_t = action_taken
self.As[a_t] = torch.addr(self.As[a_t], features.squeeze(), features.squeeze())
self.bs[a_t] += reward * features
