class NormalizeTest(unittest.TestCase):
data = [[-5, 0, 0, 0],
[0, 1, -2, 3],
[100, 2, 0, 0]]
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
self.tensor.update(nested_list_to_dict(self.data))
self.normalized = NormalizedView(self.tensor, mode=0)
self.randomtensor = DenseTensor(numpy.random.normal(size=(5, 8)))
self.randomnormal_0 = NormalizedView(self.randomtensor, mode=0)
self.randomnormal_1 = NormalizedView(self.randomtensor, mode=1)
def test_norms(self):
self.assertAlmostEqual(self.normalized[0,0], -1.0)
self.assertAlmostEqual(self.normalized[2,0], 0.99980006)
for i in range(5):
row = [self.randomnormal_0[i,j] for j in range(8)]
self.assertAlmostEqual(numpy.dot(row, row), 1.0)
for i in range(8):
col = [self.randomnormal_1[i,j] for i in range(5)]
self.assertAlmostEqual(numpy.dot(col, col), 1.0)
def testDotProduct():
tensor = DenseTensor(
array([0.14687186, 0.36171911, 0.21347318, 0.46414277, 0.04449569]))
tensor2 = DenseTensor(
array([0.70729209, 0.31895484, 0.78696611, 0.71827665, 0.87118245]))
result = tensor * tensor2
assert_almost_equal(result, 0.75939630191647056)
def rand_pair(self):
leftdim = random.randrange(1, 30)
innerdim = random.randrange(1, 30)
rightdim = random.randrange(1, 30)
dense1 = DenseTensor(numpy.random.random((leftdim, innerdim)))
dense2 = DenseTensor(numpy.random.random((innerdim, rightdim)))
return dense1, dense2
def testDotProductZeros():
# Set up two tensors
tensor = DenseTensor(zeros((5, )))
tensor2 = DenseTensor(zeros(5, ))
# Dot them
result = tensor * tensor2
eq_(result, 0)
def testAdding():
# Set up two tensors.
tensor = DenseTensor(zeros((5, )))
tensor2 = DenseTensor(zeros(5, ))
tensor2[3] = 3
# Add them.
result = tensor + tensor2
assert (result._data == [0, 0, 0, 3, 0]).all()
def testVectorNorm():
tensor = DenseTensor(zeros((5, )))
tensor[0] = 1
tensor[1] = 5
assert_almost_equal(tensor.norm(), sqrt(26.0))
normalized = tensor.normalized_copy()
assert_almost_equal(normalized * normalized, 1.0)
assert_almost_equal(normalized.norm(), 1.0)
def testVectorNorm():
tensor = DenseTensor(zeros((5,)))
tensor[0] = 1
tensor[1] = 5
assert_almost_equal(tensor.norm(), sqrt(26.0))
normalized = tensor.normalized_copy()
assert_almost_equal(normalized*normalized, 1.0)
assert_almost_equal(normalized.norm(), 1.0)
def test_extreme_items():
tensor = DenseTensor(zeros(100, ))
for i in range(100):
tensor[i] = i * 10
extremes = tensor.extremes()
top, bottom = tensor.extreme_items(10, 10)
eq_(bottom, [((i, ), i * 10.) for i in range(10)])
eq_(top, [((i, ), i * 10.) for i in range(90, 100)])
def test_dense_svd():
dense = DenseTensor(np.random.random(size=(10, 15)))
sparse = dense.to_sparse()
print repr(data(dense.svd().u))
dense_svd_u = np.abs(data(dense.svd().u))
sparse_svd_u = np.abs(data(sparse.svd().u))
assert np.all(np.abs(dense_svd_u - sparse_svd_u) < 0.0001)
def test_extremes():
tensor = DenseTensor(zeros(100, ))
for i in range(100):
tensor[i] = i * 10
extremes = tensor.extremes()
bottom, top = extremes[:10], extremes[10:]
eq_(bottom, [((i, ), i * 10.) for i in range(10)])
eq_(top, [((i, ), i * 10.) for i in range(90, 100)])
def test_extremes():
tensor = DenseTensor(zeros(100,))
for i in range(100):
tensor[i] = i*10
extremes = tensor.extremes()
bottom, top = extremes[:10], extremes[10:]
eq_(bottom, [((i,), i*10.) for i in range(10)])
eq_(top, [((i,), i*10.) for i in range(90,100)])
def test_extreme_items():
tensor = DenseTensor(zeros(100,))
for i in range(100):
tensor[i] = i*10
extremes = tensor.extremes()
top, bottom = tensor.extreme_items(10, 10)
eq_(bottom, [((i,), i*10.) for i in range(10)])
eq_(top, [((i,), i*10.) for i in range(90,100)])
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
self.tensor.update(nested_list_to_dict(self.data))
self.normalized = NormalizedView(self.tensor, mode=0)
self.randomtensor = DenseTensor(numpy.random.normal(size=(5, 8)))
self.randomnormal_0 = NormalizedView(self.randomtensor, mode=0)
self.randomnormal_1 = NormalizedView(self.randomtensor, mode=1)
def denormalized(self, norms):
row_norms, col_norms = norms
u, v, svals = self.u.unwrap(), self.v.unwrap(), self.svals.unwrap()
import numpy as np
if row_norms is not None:
u = self.u.unwrap() * row_norms[:, np.newaxis]
if col_norms is not None:
v = self.v.unwrap() * col_norms[:, np.newaxis]
return SVD2DResults(DenseTensor(u), DenseTensor(v), DenseTensor(svals))
def core(self):
'''
Get the core tensor. The core tensor is the diagonal *S*
matrix from an SVD.
'''
if self._core is None:
self._core = DenseTensor(numpy.diag(self.svals.to_dense()._data))
return self._core
def reconstruct(self, weights):
"""
Get a linear combination of the eigenvectors, and re-express it as
a Divisi tensor (a dense labeled vector).
"""
array = self.reconstruct_array(weights)
assert str(array[0]) != 'nan'
return LabeledView(DenseTensor(array), [self._labels])
def slice(self, k=None, rows=None, cols=None):
'''
Slice out a part of the SVD results, fewer svals, rows, and/or columns.
k : int - how many svals to keep. None -> keep all.
rows : [int] - a list of rows to keep. None -> keep all.
cols : [int] - a list of cols to keep. None -> keep all.
'''
u, v, svals = self.u.unwrap(), self.v.unwrap(), self.svals.unwrap()
if svals is not None:
svals = svals[:k]
u = u[:,:k]
v = v[:,:k]
if rows is not None:
u = u[rows,:]
if cols is not None:
v = v[cols,:]
return SVD2DResults(DenseTensor(u), DenseTensor(v), DenseTensor(svals))
def svd_sparse_order2(tensor, k=50, **kw):
'''
Compute the SVD of sparse 2-D tensor *tensor*. The optional
parameter *k* is the number of sigma values to retain (default
value is 50).
'''
ut, s, vt = tensor._svd(k=k, **kw)
#cnorms = dMatNorms(vt)
logging.info('ut(%s), s(%s), vt(%s)\n' % (ut.shape, s.shape, vt.shape))
# Truncate ut and vt to the number of singular values we actually got.
n_svals = s.shape[0]
ut = ut[:n_svals, :]
vt = vt[:n_svals, :]
return SVD2DResults(DenseTensor(ut.T), DenseTensor(vt.T), DenseTensor(s))
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
self.tensor.update(nested_list_to_dict(self.data))
self.normalized = NormalizedView(self.tensor, mode=0)
self.randomtensor = DenseTensor(numpy.random.normal(size=(5, 8)))
self.randomnormal_0 = NormalizedView(self.randomtensor, mode=0)
self.randomnormal_1 = NormalizedView(self.randomtensor, mode=1)
def test_combine_by_element():
t1 = LabeledView(DenseTensor(zeros((2, 2))), [['a', 'b'], ['c', 'd']])
t2 = LabeledView(DenseTensor(zeros((2, 2))), [['a', 'b'], ['c', 'd']])
t1['a', 'c'] = 1
t1['b', 'c'] = 2
t2['a', 'c'] = 4
t2['a', 'd'] = 5
t3 = t1.combine_by_element(t2, lambda x, y: x + (2 * y))
eq_(t3['a', 'c'], 9)
eq_(t3['b', 'c'], 2)
eq_(t3['a', 'd'], 10)
eq_(t3['b', 'd'], 0)
t4 = DenseTensor(zeros((3, 2)))
assert_raises(IndexError,
lambda: t1.combine_by_element(t4, lambda x, y: x + y))
t4 = DenseTensor(zeros((2, 2, 1)))
assert_raises(IndexError,
lambda: t1.combine_by_element(t4, lambda x, y: x + y))
def weighted_v_vec(self, idx, default_zeros=False):
'''
Get the weighted *v* vector with key *idx*.
If *idx* is not present and default_zeros is true, returns a
vector of zeros.
'''
try:
return self.weighted_v[idx, :]
except KeyError:
if not default_zeros: raise
return DenseTensor(numpy.zeros((len(self.svals),))).labeled([None])
def test_tensordot(self):
if True: # FIXME XXX: skip this test.
return
# Test degenerate case of two 1-d vectors
t1 = DictTensor(ndim=1)
t2 = DictTensor(ndim=1)
t1[0] = 1
t1[2] = 2
t2[0] = 3
t2[1] = 4
t2[2] = 5
self.assertEqual(13, t1.tensordot(t2, 0))
self.assertEqual(13, t1.tensordot(t2.to_dense(), 0))
self.assertEqual(13, t1.to_dense().tensordot(t2, 0))
self.assertEqual(13, t1.to_dense().tensordot(t2.to_dense(), 0))
for i in range(5):
# Make a random, randomly-shaped 3D tensor
shape = random.sample(xrange(1, 30), 3)
tensor = DenseTensor(numpy.random.random(shape))
# Pick a random one of those dimensions
dim = random.randrange(3)
# Make a random vector of that length
vec = DenseTensor(numpy.random.random((shape[dim], )))
# Try the dense result
result = tensor.tensordot(vec, dim)
self.assertEqual(result.shape,
tuple(shape[:dim] + shape[dim + 1:]))
# Try it with the tensor being sparse.
sparset = tensor.to_sparse()
result_s = sparset.tensordot(vec, dim)
self.assertEqual(result_s.shape, result.shape)
for key, val in result.iteritems():
self.assertAlmostEqual(val, result_s[key])
def aspace_mds():
from csc.conceptnet.analogyspace import conceptnet_2d_from_db
cnet = conceptnet_2d_from_db('en')
aspace = cnet.normalized().svd(k=100)
labels = cnet.label_list(0)
ptmatrix = data(aspace.u)
ptmatrix *= data(aspace.svals)
proj = mds(ptmatrix)
result = proj.project(data(aspace.u))
return LabeledView(DenseTensor(result), [labels, None])
def test_tensordot(self):
if True: # FIXME XXX: skip this test.
return
# Test degenerate case of two 1-d vectors
t1 = DictTensor(ndim=1)
t2 = DictTensor(ndim=1)
t1[0] = 1
t1[2] = 2
t2[0] = 3
t2[1] = 4
t2[2] = 5
self.assertEqual(13, t1.tensordot(t2, 0))
self.assertEqual(13, t1.tensordot(t2.to_dense(), 0))
self.assertEqual(13, t1.to_dense().tensordot(t2, 0))
self.assertEqual(13, t1.to_dense().tensordot(t2.to_dense(), 0))
for i in range(5):
# Make a random, randomly-shaped 3D tensor
shape = random.sample(xrange(1,30), 3)
tensor = DenseTensor(numpy.random.random(shape))
# Pick a random one of those dimensions
dim = random.randrange(3)
# Make a random vector of that length
vec = DenseTensor(numpy.random.random((shape[dim],)))
# Try the dense result
result = tensor.tensordot(vec, dim)
self.assertEqual(result.shape, tuple(shape[:dim]+shape[dim+1:]))
# Try it with the tensor being sparse.
sparset = tensor.to_sparse()
result_s = sparset.tensordot(vec, dim)
self.assertEqual(result_s.shape, result.shape)
for key, val in result.iteritems():
self.assertAlmostEqual(val, result_s[key])
class NormalizeTest(unittest.TestCase):
data = [[-5, 0, 0, 0], [0, 1, -2, 3], [100, 2, 0, 0]]
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
self.tensor.update(nested_list_to_dict(self.data))
self.normalized = NormalizedView(self.tensor, mode=0)
self.randomtensor = DenseTensor(numpy.random.normal(size=(5, 8)))
self.randomnormal_0 = NormalizedView(self.randomtensor, mode=0)
self.randomnormal_1 = NormalizedView(self.randomtensor, mode=1)
def test_norms(self):
self.assertAlmostEqual(self.normalized[0, 0], -1.0)
self.assertAlmostEqual(self.normalized[2, 0], 0.99980006)
for i in range(5):
row = [self.randomnormal_0[i, j] for j in range(8)]
self.assertAlmostEqual(numpy.dot(row, row), 1.0)
for i in range(8):
col = [self.randomnormal_1[i, j] for i in range(5)]
self.assertAlmostEqual(numpy.dot(col, col), 1.0)
def test_iter_dim_keys():
raw = DenseTensor(zeros((2, 3)))
labels = [['a', 'b'], ['c', 'd', 'e']]
tensor = LabeledView(raw, labels)
i = 0
for key in tensor.iter_dim_keys(0):
eq_(key, labels[0][i])
i += 1
eq_(i, 2)
i = 0
for key in tensor.iter_dim_keys(1):
eq_(key, labels[1][i])
i += 1
eq_(i, 3)
class DenseTensorTest(unittest.TestCase):
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
def test_initial(self):
self.assertEqual(len(self.tensor), 3 * 4)
self.assertEqual(len(self.tensor.keys()), 3 * 4)
assert_dims_consistent(self.tensor)
self.assert_(isinstance(self.tensor[2, 3], (float, int, long)))
self.assertEqual(self.tensor.shape, (3, 4))
self.assertEqual(self.tensor[1, 2], 0)
self.assertEqual(self.tensor[0, 3], 0)
def test_container(self):
self.tensor[0, 0] = 1
self.tensor[2, 3] = 2
self.tensor[0, -1] = 3
assertTensorEqual(self.tensor,
[[1, 0, 0, 3], [0, 0, 0, 0], [0, 0, 0, 2]])
def test_cosine_angle():
v1 = DenseTensor(zeros((5,)))
v2 = DenseTensor(zeros((5,)))
v1[0] = v2[0] = 5
assert_almost_equal(v1.cosine_of_angle_to(v2), 1.0)
v1 = DenseTensor(zeros((5,)))
v2 = DenseTensor(zeros((5,)))
v1[0] = v2[1] = 5
assert_almost_equal(v1.cosine_of_angle_to(v2), 0.0)
v1 = DenseTensor(zeros((5,)))
v2 = DenseTensor(zeros((5,)))
v1[0] = 5
v2[0] = -5
assert_almost_equal(v1.cosine_of_angle_to(v2), -1.0)
class DenseTensorTest(unittest.TestCase):
def setUp(self):
self.tensor = DenseTensor(zeros((3,4)))
def test_initial(self):
self.assertEqual(len(self.tensor), 3*4)
self.assertEqual(len(self.tensor.keys()), 3*4)
assert_dims_consistent(self.tensor)
self.assert_(isinstance(self.tensor[2, 3], (float, int, long)))
self.assertEqual(self.tensor.shape, (3, 4))
self.assertEqual(self.tensor[1, 2], 0)
self.assertEqual(self.tensor[0, 3], 0)
def test_container(self):
self.tensor[0, 0] = 1
self.tensor[2, 3] = 2
self.tensor[0, -1] = 3
assertTensorEqual(self.tensor,
[[1, 0, 0, 3],
[0, 0, 0, 0],
[0, 0, 0, 2]])
def test_cosine_angle():
v1 = DenseTensor(zeros((5, )))
v2 = DenseTensor(zeros((5, )))
v1[0] = v2[0] = 5
assert_almost_equal(v1.cosine_of_angle_to(v2), 1.0)
v1 = DenseTensor(zeros((5, )))
v2 = DenseTensor(zeros((5, )))
v1[0] = v2[1] = 5
assert_almost_equal(v1.cosine_of_angle_to(v2), 0.0)
v1 = DenseTensor(zeros((5, )))
v2 = DenseTensor(zeros((5, )))
v1[0] = 5
v2[0] = -5
assert_almost_equal(v1.cosine_of_angle_to(v2), -1.0)
def svd(self, k=50):
import numpy
from csc.divisi.tensor import DenseTensor
return MockSVDResults(None, DenseTensor(numpy.array(self.svals[:k])),
None)
def test_dense_data():
t1 = LabeledView(DenseTensor(zeros((2, 2))), [['a', 'b'], ['c', 'd']])
assert isinstance(data(t1), ndarray)
def setUp(self):
self.tensor = DenseTensor(zeros((3,4)))
def make_dense_labeled_tensor(data, labels):
return LabeledView(DenseTensor(data), labels)
def wrapped_tensor(name):
data = getattr(root, name)
if copy: data = data.read()
return DenseTensor(data)
def get_weighted_v(self):
return DenseTensor(self.v.unwrap() * self.svals.unwrap())
def get_weighted_v(self):
return self.v.layer_on(DenseTensor(self.v.tensor.unwrap() * self.svals.unwrap()))
def get_mds_matrix():
array = np.array(mds.points)
matrix = LabeledView(DenseTensor(array), [aspace.u.label_list(0), None])
return matrix
def setUp(self):
self.tensor = DenseTensor(zeros((3, 4)))
