diff --git a/python/paddle/distribution/uniform.py b/python/paddle/distribution/uniform.py index 1d2cb885b56417625ddda09dd2d512b1f7ae0f84..5619258efcf9142032e3f76f4605e2a2ccf9c17a 100644 --- a/python/paddle/distribution/uniform.py +++ b/python/paddle/distribution/uniform.py @@ -62,33 +62,42 @@ class Uniform(distribution.Distribution): Examples: .. code-block:: python - import paddle - from paddle.distribution import Uniform - - # Without broadcasting, a single uniform distribution [3, 4]: - u1 = Uniform(low=3.0, high=4.0) - # 2 distributions [1, 3], [2, 4] - u2 = Uniform(low=[1.0, 2.0], high=[3.0, 4.0]) - # 4 distributions - u3 = Uniform(low=[[1.0, 2.0], [3.0, 4.0]], - high=[[1.5, 2.5], [3.5, 4.5]]) - - # With broadcasting: - u4 = Uniform(low=3.0, high=[5.0, 6.0, 7.0]) - - # Complete example - value_tensor = paddle.to_tensor([0.8], dtype="float32") - - uniform = Uniform([0.], [2.]) - - sample = uniform.sample([2]) - # a random tensor created by uniform distribution with shape: [2, 1] - entropy = uniform.entropy() - # [0.6931472] with shape: [1] - lp = uniform.log_prob(value_tensor) - # [-0.6931472] with shape: [1] - p = uniform.probs(value_tensor) - # [0.5] with shape: [1] + >>> import paddle + >>> from paddle.distribution import Uniform + >>> paddle.seed(2023) + + >>> # Without broadcasting, a single uniform distribution [3, 4]: + >>> u1 = Uniform(low=3.0, high=4.0) + >>> # 2 distributions [1, 3], [2, 4] + >>> u2 = Uniform(low=[1.0, 2.0], high=[3.0, 4.0]) + >>> # 4 distributions + >>> u3 = Uniform(low=[[1.0, 2.0], [3.0, 4.0]], + ... high=[[1.5, 2.5], [3.5, 4.5]]) + ... + >>> # With broadcasting: + >>> u4 = Uniform(low=3.0, high=[5.0, 6.0, 7.0]) + + >>> # Complete example + >>> value_tensor = paddle.to_tensor([0.8], dtype="float32") + + >>> uniform = Uniform([0.], [2.]) + + >>> sample = uniform.sample([2]) + >>> # a random tensor created by uniform distribution with shape: [2, 1] + >>> entropy = uniform.entropy() + >>> print(entropy) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.69314718]) + + >>> lp = uniform.log_prob(value_tensor) + >>> print(lp) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [-0.69314718]) + + >>> p = uniform.probs(value_tensor) + >>> print(p) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.50000000]) """ def __init__(self, low, high, name=None): diff --git a/tools/sampcd_processor_xdoctest.py b/tools/sampcd_processor_xdoctest.py index d99acd63474f0e508b79055fefdfe5d473b48b14..3ac5523216db55bf3d8ecc368e0f500f87543b5e 100644 --- a/tools/sampcd_processor_xdoctest.py +++ b/tools/sampcd_processor_xdoctest.py @@ -48,11 +48,124 @@ XDOCTEST_CONFIG = { "paddle.device.set_device('cpu')", ] ), - "analysis": "auto", - "options": "+IGNORE_WHITESPACE", + "default_runtime_state": {"IGNORE_WHITESPACE": True}, } +def _patch_global_state(debug, verbose): + # patch xdoctest global_state + from xdoctest import global_state + + _debug_xdoctest = debug and verbose > 2 + global_state.DEBUG = _debug_xdoctest + global_state.DEBUG_PARSER = global_state.DEBUG_PARSER and _debug_xdoctest + global_state.DEBUG_CORE = global_state.DEBUG_CORE and _debug_xdoctest + global_state.DEBUG_RUNNER = global_state.DEBUG_RUNNER and _debug_xdoctest + global_state.DEBUG_DOCTEST = global_state.DEBUG_DOCTEST and _debug_xdoctest + + +def _patch_tensor_place(): + from xdoctest import checker + + pattern_tensor = re.compile( + r""" + (Tensor\(.*?place=) # Tensor start + (.*?) # Place=(XXX) + (\,.*?\)) + """, + re.X | re.S, + ) + + _check_output = checker.check_output + + def check_output(got, want, runstate=None): + if not want: # nocover + return True + + return _check_output( + got=pattern_tensor.sub(r'\1Place(cpu)\3', got), + want=pattern_tensor.sub(r'\1Place(cpu)\3', want), + runstate=runstate, + ) + + checker.check_output = check_output + + +def _patch_float_precision(digits): + from xdoctest import checker + + pattern_number = re.compile( + r""" + (?: + (?<=[\s*\[\(\'\"\:]) # number starts + (?: # int/float or complex-real + (?: + [+-]? + (?: + (?: \d*\.\d+) | (?: \d+\.?) # int/float + ) + ) + (?:[Ee][+-]?\d+)? + ) + (?: # complex-imag + (?: + (?: + [+-]? + (?: + (?: \d*\.\d+) | (?: \d+\.?) + ) + ) + (?:[Ee][+-]?\d+)? + ) + (?:[Jj]) + )? + ) + """, + re.X | re.S, + ) + + _check_output = checker.check_output + + def _sub_number(match_obj, digits): + match_str = match_obj.group() + + if 'j' in match_str or 'J' in match_str: + try: + match_num = complex(match_str) + except ValueError: + return match_str + + return ( + str( + complex( + round(match_num.real, digits), + round(match_num.imag, digits), + ) + ) + .strip('(') + .strip(')') + ) + else: + try: + return str(round(float(match_str), digits)) + except ValueError: + return match_str + + sub_number = functools.partial(_sub_number, digits=digits) + + def check_output(got, want, runstate=None): + if not want: # nocover + return True + + return _check_output( + got=pattern_number.sub(sub_number, got), + want=pattern_number.sub(sub_number, want), + runstate=runstate, + ) + + checker.check_output = check_output + + class Xdoctester(DocTester): """A Xdoctest doctester.""" @@ -63,6 +176,10 @@ class Xdoctester(DocTester): target='codeblock', mode='native', verbose=2, + patch_global_state=True, + patch_tensor_place=True, + patch_float_precision=True, + patch_float_digits=5, **config, ): self.debug = debug @@ -73,21 +190,14 @@ class Xdoctester(DocTester): self.verbose = verbose self.config = {**XDOCTEST_CONFIG, **(config or {})} - # patch xdoctest global_state - from xdoctest import global_state + if patch_global_state: + _patch_global_state(self.debug, self.verbose) - _debug_xdoctest = debug and verbose > 2 - global_state.DEBUG = _debug_xdoctest - global_state.DEBUG_PARSER = ( - global_state.DEBUG_PARSER and _debug_xdoctest - ) - global_state.DEBUG_CORE = global_state.DEBUG_CORE and _debug_xdoctest - global_state.DEBUG_RUNNER = ( - global_state.DEBUG_RUNNER and _debug_xdoctest - ) - global_state.DEBUG_DOCTEST = ( - global_state.DEBUG_DOCTEST and _debug_xdoctest - ) + if patch_tensor_place: + _patch_tensor_place() + + if patch_float_precision: + _patch_float_precision(patch_float_digits) self.docstring_parser = functools.partial( xdoctest.core.parse_docstr_examples, style=self.style @@ -95,19 +205,13 @@ class Xdoctester(DocTester): self.directive_pattern = re.compile( r""" - (?<=(\#\s{1})) # positive lookbehind, directive begins - (doctest) # directive prefix, which should be replaced - (?= # positive lookahead, directive content - ( - :\s+ - [\+\-] - (REQUIRES|SKIP) - (\((env\s*:\s*(CPU|GPU|XPU|DISTRIBUTED)\s*,?\s*)+\))? - ) - \s*\n+ - )""", + (?<=(\#\s)) # positive lookbehind, directive begins + (doctest) # directive prefix, which should be replaced + (?=(:\s*.*\n)) # positive lookahead, directive content + """, re.X, ) + self.directive_prefix = 'xdoctest' def convert_directive(self, docstring: str) -> str: @@ -199,7 +303,7 @@ class Xdoctester(DocTester): return test_results - def print_summary(self, test_results, whl_error): + def print_summary(self, test_results, whl_error=None): summary_success = [] summary_failed = [] summary_skiptest = [] @@ -208,7 +312,7 @@ class Xdoctester(DocTester): stdout_handler = logging.StreamHandler(stream=sys.stdout) logger.addHandler(stdout_handler) logger.info("----------------End of the Check--------------------") - if len(whl_error) != 0: + if whl_error is not None and whl_error: logger.info("%s is not in whl.", whl_error) logger.info("") logger.info("Please check the whl package and API_PR.spec!") @@ -239,10 +343,6 @@ class Xdoctester(DocTester): summary_skiptest.append(test_result.name) if test_result.failed: - logger.info( - "In addition, mistakes found in sample codes: %s", - test_result.name, - ) summary_failed.append(test_result.name) if test_result.time > TEST_TIMEOUT: @@ -259,16 +359,19 @@ class Xdoctester(DocTester): logger.info(f'{k} - {v}s') if len(summary_success): logger.info("%d sample codes ran success", len(summary_success)) + logger.info('\n'.join(summary_success)) + if len(summary_skiptest): logger.info("%d sample codes skipped", len(summary_skiptest)) - if self.debug: - logger.info('\n'.join(summary_skiptest)) + logger.info('\n'.join(summary_skiptest)) + if len(summary_nocodes): logger.info( - "%d apis don't have sample codes", len(summary_nocodes) + "%d apis could not run test or don't have sample codes", + len(summary_nocodes), ) - if self.debug: - logger.info('\n'.join(summary_nocodes)) + logger.info('\n'.join(summary_nocodes)) + if len(summary_failed): logger.info("%d sample codes ran failed", len(summary_failed)) logger.info('\n'.join(summary_failed)) diff --git a/tools/test_sampcd_processor_xdoctest.py b/tools/test_sampcd_processor_xdoctest.py index 494d835e08dc851f3b1b3f0387ed0b21cac5d4bc..f737b0209da2240c2028babdcebd7f832263b029 100644 --- a/tools/test_sampcd_processor_xdoctest.py +++ b/tools/test_sampcd_processor_xdoctest.py @@ -14,9 +14,11 @@ # See the License for the specific language governing permissions and # limitations under the License. +import importlib import os import unittest +import xdoctest from sampcd_processor_utils import get_test_results from sampcd_processor_xdoctest import Xdoctester @@ -37,7 +39,6 @@ class TestXdoctester(unittest.TestCase): self.assertEqual(doctester.style, 'freeform') self.assertEqual(doctester.target, 'codeblock') self.assertEqual(doctester.mode, 'native') - self.assertEqual(doctester.config['analysis'], 'auto') doctester = Xdoctester(analysis='static') self.assertEqual(doctester.config['analysis'], 'static') @@ -49,6 +50,11 @@ class TestXdoctester(unittest.TestCase): docstring_target = "# xdoctest: -SKIP\n" self.assertEqual(docstring_output, docstring_target) + docstring_input = '# doctest: +SKIP("skip this test...")\n' + docstring_output = doctester.convert_directive(docstring_input) + docstring_target = '# xdoctest: +SKIP("skip this test...")\n' + self.assertEqual(docstring_output, docstring_target) + docstring_input = """ placeholder @@ -138,6 +144,674 @@ class TestXdoctester(unittest.TestCase): class TestGetTestResults(unittest.TestCase): + def test_patch_xdoctest(self): + # test patch tensor place + _clear_environ() + + test_capacity = {'cpu'} + doctester = Xdoctester(style='freeform', target='codeblock') + doctester.prepare(test_capacity) + + docstrings_to_test = { + 'gpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.2) + >>> # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0.20000000]) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.20000000]) + + """, + 'cpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.2) + >>> # Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [0.20000000]) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.20000000]) + + """, + 'gpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.2) + >>> # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0.20000000]) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.20000000]) + + """, + 'cpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.2) + >>> # Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [0.20000000]) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.20000000]) + """, + 'gpu_to_cpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor([[1,2,3], [2,3,4], [3,4,5]]) + >>> # Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, + >>> # [[1, 2, 3], + >>> # [2, 3, 4], + >>> # [3, 4, 5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, + [[1, 2, 3], + [2, 3, 4], + [3, 4, 5]]) + """, + 'cpu_to_gpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor([[1,2,3], [2,3,4], [3,4,5]]) + >>> # Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, + >>> # [[1, 2, 3], + >>> # [2, 3, 4], + >>> # [3, 4, 5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, + [[1, 2, 3], + [2, 3, 4], + [3, 4, 5]]) + """, + } + + test_results = get_test_results(doctester, docstrings_to_test) + self.assertEqual(len(test_results), 6) + + tr_0, tr_1, tr_2, tr_3, tr_4, tr_5 = test_results + + self.assertIn('gpu_to_gpu', tr_0.name) + self.assertTrue(tr_0.passed) + + self.assertIn('cpu_to_cpu', tr_1.name) + self.assertTrue(tr_1.passed) + + self.assertIn('gpu_to_cpu', tr_2.name) + self.assertTrue(tr_2.passed) + + self.assertIn('cpu_to_gpu', tr_3.name) + self.assertTrue(tr_3.passed) + + self.assertIn('gpu_to_cpu_array', tr_4.name) + self.assertTrue(tr_4.passed) + + self.assertIn('cpu_to_gpu_array', tr_5.name) + self.assertTrue(tr_5.passed) + + # reload xdoctest.checker + importlib.reload(xdoctest.checker) + + _clear_environ() + + test_capacity = {'cpu'} + doctester = Xdoctester( + style='freeform', target='codeblock', patch_tensor_place=False + ) + doctester.prepare(test_capacity) + + test_results = get_test_results(doctester, docstrings_to_test) + self.assertEqual(len(test_results), 6) + + tr_0, tr_1, tr_2, tr_3, tr_4, tr_5 = test_results + + self.assertIn('gpu_to_gpu', tr_0.name) + self.assertTrue(tr_0.passed) + + self.assertIn('cpu_to_cpu', tr_1.name) + self.assertTrue(tr_1.passed) + + self.assertIn('gpu_to_cpu', tr_2.name) + self.assertFalse(tr_2.passed) + + self.assertIn('cpu_to_gpu', tr_3.name) + self.assertFalse(tr_3.passed) + + self.assertIn('gpu_to_cpu_array', tr_4.name) + self.assertFalse(tr_4.passed) + + self.assertIn('cpu_to_gpu_array', tr_5.name) + self.assertFalse(tr_5.passed) + + # test patch float precision + # reload xdoctest.checker + importlib.reload(xdoctest.checker) + + _clear_environ() + + test_capacity = {'cpu'} + doctester = Xdoctester(style='freeform', target='codeblock') + doctester.prepare(test_capacity) + + docstrings_to_test = { + 'gpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.123456780]) + + """, + 'cpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.123456780]) + + """, + 'gpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.123456780]) + + """, + 'cpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.123456780]) + """, + 'gpu_to_cpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor([[1.123456789 ,2,3], [2,3,4], [3,4,5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[1.123456780, 2., 3.], + [2., 3., 4.], + [3., 4., 5.]]) + """, + 'cpu_to_gpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor([[1.123456789,2,3], [2,3,4], [3,4,5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [[1.123456780, 2., 3.], + [2., 3., 4.], + [3., 4., 5.]]) + """, + 'mass_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor( + ... [[1.123456780, 2., -3, .3], + ... [2, 3, +4., 1.2+10.34e-5j], + ... [3, 5.e-3, 1e2, 3e-8]] + ... ) + >>> # Tensor(shape=[3, 4], dtype=complex64, place=Place(gpu:0), stop_gradient=True, + >>> # [[ (1.1234568357467651+0j) , + >>> # (2+0j) , + >>> # (-3+0j) , + >>> # (0.30000001192092896+0j) ], + >>> # [ (2+0j) , + >>> # (3+0j) , + >>> # (4+0j) , + >>> # (1.2000000476837158+0.00010340000153519213j)], + >>> # [ (3+0j) , + >>> # (0.004999999888241291+0j) , + >>> # (100+0j) , + >>> # (2.999999892949745e-08+0j) ]]) + >>> print(a) + Tensor(shape=[3, 4], dtype=complex64, place=Place(AAA), stop_gradient=True, + [[ (1.123456+0j), + (2+0j), + (-3+0j), + (0.3+0j)], + [ (2+0j), + (3+0j), + (4+0j), + (1.2+0.00010340j)], + [ (3+0j), + (0.00499999+0j), + (100+0j), + (2.999999e-08+0j)]]) + """, + 'float_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> x = [[2, 3, 4], [7, 8, 9]] + >>> x = paddle.to_tensor(x, dtype='float32') + >>> print(paddle.log(x)) + Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[0.69314718, 1.09861231, 1.38629436], + [1.94591010, 2.07944155, 2.19722462]]) + + """, + 'float_array_diff': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> x = [[2, 3, 4], [7, 8, 9]] + >>> x = paddle.to_tensor(x, dtype='float32') + >>> print(paddle.log(x)) + Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[0.69314712, 1.09861221, 1.386294], + [1.94591032, 2.07944156, 2.1972246]]) + + """, + } + + test_results = get_test_results(doctester, docstrings_to_test) + self.assertEqual(len(test_results), 9) + + tr_0, tr_1, tr_2, tr_3, tr_4, tr_5, tr_6, tr_7, tr_8 = test_results + + self.assertIn('gpu_to_gpu', tr_0.name) + self.assertTrue(tr_0.passed) + + self.assertIn('cpu_to_cpu', tr_1.name) + self.assertTrue(tr_1.passed) + + self.assertIn('gpu_to_cpu', tr_2.name) + self.assertTrue(tr_2.passed) + + self.assertIn('cpu_to_gpu', tr_3.name) + self.assertTrue(tr_3.passed) + + self.assertIn('gpu_to_cpu_array', tr_4.name) + self.assertTrue(tr_4.passed) + + self.assertIn('cpu_to_gpu_array', tr_5.name) + self.assertTrue(tr_5.passed) + + self.assertIn('mass_array', tr_6.name) + self.assertTrue(tr_6.passed) + + self.assertIn('float_array', tr_7.name) + self.assertTrue(tr_7.passed) + + self.assertIn('float_array_diff', tr_8.name) + self.assertTrue(tr_8.passed) + + # reload xdoctest.checker + importlib.reload(xdoctest.checker) + + _clear_environ() + + test_capacity = {'cpu'} + doctester = Xdoctester( + style='freeform', target='codeblock', patch_float_precision=False + ) + doctester.prepare(test_capacity) + + docstrings_to_test = { + 'gpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.123456780]) + + """, + 'cpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.123456780]) + + """, + 'gpu_to_cpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, + [0.123456780]) + + """, + 'cpu_to_gpu': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor(.123456789) + >>> print(a) + Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [0.123456780]) + """, + 'gpu_to_cpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor([[1.123456789 ,2,3], [2,3,4], [3,4,5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[1.123456780, 2., 3.], + [2., 3., 4.], + [3., 4., 5.]]) + """, + 'cpu_to_gpu_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> a = paddle.to_tensor([[1.123456789,2,3], [2,3,4], [3,4,5]]) + >>> print(a) + Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, + [[1.123456780, 2., 3.], + [2., 3., 4.], + [3., 4., 5.]]) + """, + 'mass_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('gpu') + >>> a = paddle.to_tensor( + ... [[1.123456780, 2., -3, .3], + ... [2, 3, +4., 1.2+10.34e-5j], + ... [3, 5.e-3, 1e2, 3e-8]] + ... ) + >>> # Tensor(shape=[3, 4], dtype=complex64, place=Place(gpu:0), stop_gradient=True, + >>> # [[ (1.1234568357467651+0j) , + >>> # (2+0j) , + >>> # (-3+0j) , + >>> # (0.30000001192092896+0j) ], + >>> # [ (2+0j) , + >>> # (3+0j) , + >>> # (4+0j) , + >>> # (1.2000000476837158+0.00010340000153519213j)], + >>> # [ (3+0j) , + >>> # (0.004999999888241291+0j) , + >>> # (100+0j) , + >>> # (2.999999892949745e-08+0j) ]]) + >>> print(a) + Tensor(shape=[3, 4], dtype=complex64, place=Place(AAA), stop_gradient=True, + [[ (1.123456+0j), + (2+0j), + (-3+0j), + (0.3+0j)], + [ (2+0j), + (3+0j), + (4+0j), + (1.2+0.00010340j)], + [ (3+0j), + (0.00499999+0j), + (100+0j), + (2.999999e-08+0j)]]) + """, + 'float_array': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> x = [[2, 3, 4], [7, 8, 9]] + >>> x = paddle.to_tensor(x, dtype='float32') + >>> print(paddle.log(x)) + Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[0.69314718, 1.09861231, 1.38629436], + [1.94591010, 2.07944155, 2.19722462]]) + + """, + 'float_array_diff': """ + placeholder + + Examples: + + .. code-block:: python + :name: code-example-1 + + this is some blabla... + + >>> import paddle + >>> paddle.device.set_device('cpu') + >>> x = [[2, 3, 4], [7, 8, 9]] + >>> x = paddle.to_tensor(x, dtype='float32') + >>> print(paddle.log(x)) + Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, + [[0.69314712, 1.09861221, 1.386294], + [1.94591032, 2.07944156, 2.1972246]]) + + """, + } + + test_results = get_test_results(doctester, docstrings_to_test) + self.assertEqual(len(test_results), 9) + + tr_0, tr_1, tr_2, tr_3, tr_4, tr_5, tr_6, tr_7, tr_8 = test_results + + self.assertIn('gpu_to_gpu', tr_0.name) + self.assertFalse(tr_0.passed) + + self.assertIn('cpu_to_cpu', tr_1.name) + self.assertFalse(tr_1.passed) + + self.assertIn('gpu_to_cpu', tr_2.name) + self.assertFalse(tr_2.passed) + + self.assertIn('cpu_to_gpu', tr_3.name) + self.assertFalse(tr_3.passed) + + self.assertIn('gpu_to_cpu_array', tr_4.name) + self.assertFalse(tr_4.passed) + + self.assertIn('cpu_to_gpu_array', tr_5.name) + self.assertFalse(tr_5.passed) + + self.assertIn('mass_array', tr_6.name) + self.assertFalse(tr_6.passed) + + self.assertIn('float_array', tr_7.name) + self.assertTrue(tr_7.passed) + + self.assertIn('float_array_diff', tr_8.name) + self.assertFalse(tr_8.passed) + def test_run_cpu(self): _clear_environ()