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 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)))