示例#1
0
    def testRandom(self):
        arr = rand(2, 3)

        self.assertIsNotNone(arr.dtype)

        arr = beta(1, 2, chunk_size=2).tiles()

        self.assertEqual(arr.shape, ())
        self.assertEqual(calc_shape(arr), arr.shape)
        self.assertEqual(len(arr.chunks), 1)
        self.assertEqual(arr.chunks[0].shape, ())
        self.assertEqual(calc_shape(arr.chunks[0]), arr.chunks[0].shape)
        self.assertEqual(arr.chunks[0].op.dtype, np.dtype('f8'))

        arr = beta([1, 2], [3, 4], chunk_size=2).tiles()

        self.assertEqual(arr.shape, (2, ))
        self.assertEqual(calc_shape(arr), arr.shape)
        self.assertEqual(len(arr.chunks), 1)
        self.assertEqual(arr.chunks[0].shape, (2, ))
        self.assertEqual(arr.chunks[0].op.dtype, np.dtype('f8'))
        self.assertEqual(calc_shape(arr.chunks[0]), arr.chunks[0].shape)

        arr = beta([[2, 3]],
                   from_ndarray([[4, 6], [5, 2]], chunk_size=2),
                   chunk_size=1,
                   size=(3, 2, 2)).tiles()

        self.assertEqual(arr.shape, (3, 2, 2))
        self.assertEqual(calc_shape(arr), arr.shape)
        self.assertEqual(len(arr.chunks), 12)
        self.assertEqual(arr.chunks[0].op.dtype, np.dtype('f8'))
        self.assertEqual(calc_shape(arr.chunks[0]), arr.chunks[0].shape)
示例#2
0
    def testRandomSerialize(self):
        arr = RandomState(0).beta([[2, 3]],
                                  from_ndarray([[4, 6], [5, 2]], chunk_size=2),
                                  chunk_size=1,
                                  size=(3, 2, 2)).tiles()
        chunk = arr.chunks[0]

        self.assertEqual(chunk.op.dtype, np.dtype('f8'))

        serials = self._pb_serial(chunk)
        chunk2 = self._pb_deserial(serials)[chunk.data]

        self.assertEqual(chunk.index, chunk2.index)
        state, state2 = chunk.op.state, chunk2.op.state
        self.assertTrue(np.array_equal(state.keys, state2.keys))
示例#3
0
    def testBetaExecute(self):
        arr = tensor.random.beta(1, 2, chunk_size=2).tiles()
        arr.chunks[0].op._state = State(np.random.RandomState(0))

        self.assertEqual(
            self.executor.execute_tensor(arr)[0],
            np.random.RandomState(0).beta(1, 2))

        arr = tensor.random.beta([1, 2], [3, 4], chunk_size=2).tiles()
        arr.chunks[0].op._state = State(np.random.RandomState(0))

        self.assertTrue(
            np.array_equal(
                self.executor.execute_tensor(arr)[0],
                np.random.RandomState(0).beta([1, 2], [3, 4])))

        arr = tensor.random.beta([[2, 3]],
                                 from_ndarray([[4, 6], [5, 2]], chunk_size=2),
                                 chunk_size=1,
                                 size=(3, 2, 2)).tiles()
        for c in arr.chunks:
            c.op._state = State(np.random.RandomState(0))

        res = self.executor.execute_tensor(arr, concat=True)[0]

        self.assertEqual(res[0, 0, 0], np.random.RandomState(0).beta(2, 4))
        self.assertEqual(res[0, 0, 1], np.random.RandomState(0).beta(3, 6))
        self.assertEqual(res[0, 1, 0], np.random.RandomState(0).beta(2, 5))
        self.assertEqual(res[0, 1, 1], np.random.RandomState(0).beta(3, 2))

        arr = tensor.random.RandomState(0).beta([[3, 4]], [[1], [2]],
                                                chunk_size=1)
        tensor.random.seed(0)
        arr2 = tensor.random.beta([[3, 4]], [[1], [2]], chunk_size=1)

        self.assertTrue(
            np.array_equal(
                self.executor.execute_tensor(arr, concat=True)[0],
                self.executor.execute_tensor(arr2, concat=True)[0]))