def main():
min_size = 2
max_size = 50
matrix_sizes = range(min_size, max_size + 1)
matrix_samples_per_size = 2000
mean_cosine_similarities = []
for matrix_size in matrix_sizes:
for run in range(0, matrix_samples_per_size):
matrix = random_square_matrix(matrix_size)
mean_cosine_similarities.append({
"Matrix Size": matrix_size,
"Mean Cosine Similarity": mean_cosine_similarity(matrix),
})
cosine_similarity_data = pd.DataFrame(mean_cosine_similarities)
sns.set_style('darkgrid')
cosine_similarity_plot = sns.lineplot(
x="Matrix Size",
y="Mean Cosine Similarity",
data=cosine_similarity_data,
)
plot_title = "Mean Cosine Similarity of random matrix columns vs. matrix size\n" +\
"{0} matrices sampled for each size from {1}x{1} to {2}x{2}.".format(
matrix_samples_per_size,
min_size,
max_size,
)
cosine_similarity_plot.set_title(plot_title)
cosine_similarity_plot.get_figure().savefig("cosine_similarity.pdf")
def test_all_equal(self):
bunched_up_matrix = np.array([
[5, 5, 5],
[5, 5, 5],
[5, 5, 5],
])
# Columns are exactly dependent, so mean similarity should be maximized (1.0)
self.assertAlmostEqual(metrics.mean_cosine_similarity(bunched_up_matrix), 1)
# Same goes for elements of the similarity matrix
cosine_similarity_matrix = metrics.cosine_similarity_matrix(bunched_up_matrix)
for row, col in zip(range(0, 3), range(0, 3)):
self.assertAlmostEqual(cosine_similarity_matrix[row, col], 1)
def test_bunched_up(self):
bunched_up_matrix = np.array([
[11, 12, 13],
[11, 12, 14],
[11, 13, 14],
])
# Columns are close to dependent, so mean should be high
self.assertGreater(metrics.mean_cosine_similarity(bunched_up_matrix), 0.5)
# All off-diagonal elements of the similarity matrix should be high
cosine_similarity_matrix = metrics.cosine_similarity_matrix(bunched_up_matrix)
for row, col in zip(range(0, 3), range(0, 3)):
if row == col:
continue
self.assertGreater(cosine_similarity_matrix[row, col], 0.5)
def test_rank_1(self):
rank_1_matrix = np.array([
[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
])
# Columns are all perfectly similar, so mean should be 1
self.assertAlmostEqual(metrics.mean_cosine_similarity(rank_1_matrix), 1)
# Three columns with perfect similarity means total should be 3
self.assertAlmostEqual(metrics.total_cosine_simiarity(rank_1_matrix), 3)
# All elements of the similarity matrix should be 1
cosine_similarity_matrix = metrics.cosine_similarity_matrix(rank_1_matrix)
for row, col in zip(range(0, 3), range(0, 3)):
self.assertAlmostEqual(cosine_similarity_matrix[row, col], 1)
def test_orthogonal(self):
orthogonal_matrix = np.array([
[0, 2, 0],
[1, 0, 0],
[0, 0, -5],
])
# Columns are orthogonal, so mean should be 0
self.assertAlmostEqual(metrics.mean_cosine_similarity(orthogonal_matrix), 0)
# All orthogonal means total should be 0
self.assertAlmostEqual(metrics.total_cosine_simiarity(orthogonal_matrix), 0)
# All off-diagonal elements should be 0, on-diagonal are still 1
cosine_similarity_matrix = metrics.cosine_similarity_matrix(orthogonal_matrix)
for row, col in zip(range(0, 3), range(0, 3)):
if row == col:
self.assertAlmostEqual(cosine_similarity_matrix[row, col], 1)
else:
self.assertAlmostEqual(cosine_similarity_matrix[row, col], 0)
for i in torch.arange(2, 40):
A = torch.mm(A / i, X)
eX = eX + A
ctx.save_for_backward(eX)
return eX
@staticmethod
def backward(ctx, grad_output):
eX, = ctx.saved_tensors
return grad_output.mm(eX)
mexp = MExp.apply # convenient alias
if __name__ == "__main__":
import numpy as np
from tools.neur.functional import ortho_basis, exp_map
from tools.ortho.metrics import mean_cosine_similarity
print(ortho_basis(10))
# TODO Logan this call is broken but I left it here in case you think that indicates a problem.
orth = exp_map(ortho_basis(10), torch.rand(45).reshape(-1,1,1))
print(orth)
print(np.linalg.norm(orth, axis=1))
print(mean_cosine_similarity(orth.numpy()))