9359853505

Committed 04 Jun 2024 01:42AM UTC coverage: 88.02% (+0.1%) from 87.911%

Build # 9359853505

Build Type

Pull #1705

github

Committed by

web-flow

Commit Message

Merge dd28026b0 into c6f5f790b

Pull Request Pull Request #1705: Change memory object USM allocation ownership, and make execution asynchronous

Run Details

3275 of 3765 branches covered (86.99%)

Branch coverage included in aggregate %.

567 of 634 new or added lines in 23 files covered. (89.43%)

2 existing lines in 2 files now uncovered.

11207 of 12688 relevant lines covered (88.33%)

7552.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.39

/dpctl/tensor/_accumulation.py

#                       Data Parallel Control (dpctl)
#
#  Copyright 2020-2024 Intel Corporation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

from numpy.core.numeric import normalize_axis_index

import dpctl
import dpctl.tensor as dpt
import dpctl.tensor._tensor_accumulation_impl as tai
import dpctl.tensor._tensor_impl as ti
from dpctl.tensor._type_utils import (
    _default_accumulation_dtype,
    _default_accumulation_dtype_fp_types,
    _to_device_supported_dtype,
)
from dpctl.utils import ExecutionPlacementError, SequentialOrderManager


def _accumulate_common(
    x,
    axis,
    dtype,
    include_initial,
    out,
    _accumulate_fn,
    _accumulate_include_initial_fn,
    _dtype_supported,
    _default_accumulation_type_fn,
):
    if not isinstance(x, dpt.usm_ndarray):
        raise TypeError(f"Expected dpctl.tensor.usm_ndarray, got {type(x)}")
    appended_axis = False
    if x.ndim == 0:
        x = x[dpt.newaxis]
        appended_axis = True
    nd = x.ndim
    if axis is None:
        if nd > 1:
            raise ValueError(
                "`axis` cannot be `None` for array of dimension `{}`".format(nd)
            )
        axis = 0
    else:
        axis = normalize_axis_index(axis, nd, "axis")
    sh = x.shape
    res_sh = (
        sh[:axis] + (sh[axis] + 1,) + sh[axis + 1 :] if include_initial else sh
    )
    a1 = axis + 1
    if a1 == nd:
        perm = list(range(nd))
        arr = x
    else:
        perm = [i for i in range(nd) if i != axis] + [
            axis,
        ]
        arr = dpt.permute_dims(x, perm)
    q = x.sycl_queue
    inp_dt = x.dtype
    res_usm_type = x.usm_type
    if dtype is None:
        res_dt = _default_accumulation_type_fn(inp_dt, q)
    else:
        res_dt = dpt.dtype(dtype)
        res_dt = _to_device_supported_dtype(res_dt, q.sycl_device)

    # checking now avoids unnecessary allocations
    implemented_types = _dtype_supported(inp_dt, res_dt)
    if dtype is None and not implemented_types:
        raise RuntimeError(
            "Automatically determined accumulation data type does not "
            "have direct implementation"
        )
    orig_out = out
    if out is not None:
        if not isinstance(out, dpt.usm_ndarray):
            raise TypeError(
                f"output array must be of usm_ndarray type, got {type(out)}"
            )
        if not out.flags.writable:
            raise ValueError("provided `out` array is read-only")
        out_sh = out.shape
        # append an axis to `out` if scalar
        if appended_axis and not include_initial:
            out = out[dpt.newaxis, ...]
            orig_out = out
            final_res_sh = res_sh[1:]
        else:
            final_res_sh = res_sh
        if not out_sh == final_res_sh:
            raise ValueError(
                "The shape of input and output arrays are inconsistent. "
                f"Expected output shape is {final_res_sh}, got {out_sh}"
            )
        if res_dt != out.dtype:
            raise ValueError(
                f"Output array of type {res_dt} is needed, " f"got {out.dtype}"
            )
        if dpctl.utils.get_execution_queue((q, out.sycl_queue)) is None:
            raise ExecutionPlacementError(
                "Input and output allocation queues are not compatible"
            )
        # permute out array dims if necessary
        if a1 != nd:
            out = dpt.permute_dims(out, perm)
            orig_out = out
        if ti._array_overlap(x, out) and implemented_types:
            out = dpt.empty_like(out)
    else:
        out = dpt.empty(
            res_sh, dtype=res_dt, usm_type=res_usm_type, sycl_queue=q
        )
        if a1 != nd:
            out = dpt.permute_dims(out, perm)

    final_ev = dpctl.SyclEvent()
    _manager = SequentialOrderManager[q]
    depends = _manager.submitted_events
    if implemented_types:
        if not include_initial:
            ht_e, acc_ev = _accumulate_fn(
                src=arr,
                trailing_dims_to_accumulate=1,
                dst=out,
                sycl_queue=q,
                depends=depends,
            )
        else:
            ht_e, acc_ev = _accumulate_include_initial_fn(
                src=arr, dst=out, sycl_queue=q, depends=depends
            )
        _manager.add_event_pair(ht_e, acc_ev)
        if not (orig_out is None or out is orig_out):
            # Copy the out data from temporary buffer to original memory
            ht_e_cpy, acc_ev = ti._copy_usm_ndarray_into_usm_ndarray(
                src=out, dst=orig_out, sycl_queue=q, depends=[acc_ev]
            )
            _manager.add_event_pair(ht_e_cpy, acc_ev)
            out = orig_out
        final_ev = acc_ev
    else:
        if _dtype_supported(res_dt, res_dt):
            tmp = dpt.empty(
                arr.shape, dtype=res_dt, usm_type=res_usm_type, sycl_queue=q
            )
            ht_e_cpy, cpy_e = ti._copy_usm_ndarray_into_usm_ndarray(
                src=arr, dst=tmp, sycl_queue=q, depends=depends
            )
            _manager.add_event_pair(ht_e_cpy, cpy_e)
            if not include_initial:
                ht_e, final_ev = _accumulate_fn(
                    src=tmp,
                    trailing_dims_to_accumulate=1,
                    dst=out,
                    sycl_queue=q,
                    depends=[cpy_e],
                )
            else:
                ht_e, final_ev = _accumulate_include_initial_fn(
                    src=tmp,
                    dst=out,
                    sycl_queue=q,
                    depends=[cpy_e],
                )
            _manager.add_event_pair(ht_e, final_ev)
        else:
            buf_dt = _default_accumulation_type_fn(inp_dt, q)
            tmp = dpt.empty(
                arr.shape, dtype=buf_dt, usm_type=res_usm_type, sycl_queue=q
            )
            ht_e_cpy, cpy_e = ti._copy_usm_ndarray_into_usm_ndarray(
                src=arr, dst=tmp, sycl_queue=q, depends=depends
            )
            _manager.add_event_pair(ht_e_cpy, cpy_e)
            tmp_res = dpt.empty(
                res_sh, dtype=buf_dt, usm_type=res_usm_type, sycl_queue=q
            )
            if a1 != nd:
                tmp_res = dpt.permute_dims(tmp_res, perm)
            if not include_initial:
                ht_e, a_e = _accumulate_fn(
                    src=tmp,
                    trailing_dims_to_accumulate=1,
                    dst=tmp_res,
                    sycl_queue=q,
                    depends=[cpy_e],
                )
            else:
                ht_e, a_e = _accumulate_include_initial_fn(
                    src=tmp,
                    dst=tmp_res,
                    sycl_queue=q,
                    depends=[cpy_e],
                )
            _manager.add_event_pair(ht_e, a_e)
            ht_e_cpy2, final_ev = ti._copy_usm_ndarray_into_usm_ndarray(
                src=tmp_res, dst=out, sycl_queue=q, depends=[a_e]
            )
            _manager.add_event_pair(ht_e_cpy2, final_ev)

    if appended_axis:
        out = dpt.squeeze(out)
    if a1 != nd:
        inv_perm = sorted(range(nd), key=lambda d: perm[d])
        out = dpt.permute_dims(out, inv_perm)

    return out


def cumulative_sum(
    x, /, *, axis=None, dtype=None, include_initial=False, out=None
):
    """
    cumulative_sum(x, /, *, axis=None, dtype=None, include_initial=False,
                   out=None)

    Calculates the cumulative sum of elements in the input array `x`.

    Args:
        x (usm_ndarray):
            input array.
        axis (Optional[int]):
            axis along which cumulative sum must be computed.
            If `None`, the sum is computed over the entire array.
            If `x` is a one-dimensional array, providing an `axis` is optional;
            however, if `x` has more than one dimension, providing an `axis`
            is required.
            Default: `None`.
        dtype (Optional[dtype]):
            data type of the returned array. If `None`, the default data
            type is inferred from the "kind" of the input array data type.

                * If `x` has a real- or complex-valued floating-point data
                  type, the returned array will have the same data type as
                  `x`.
                * If `x` has signed integral data type, the returned array
                  will have the default signed integral type for the device
                  where input array `x` is allocated.
                * If `x` has unsigned integral data type, the returned array
                  will have the default unsigned integral type for the device
                  where input array `x` is allocated.
                * If `x` has a boolean data type, the returned array will
                  have the default signed integral type for the device
                  where input array `x` is allocated.

            If the data type (either specified or resolved) differs from the
            data type of `x`, the input array elements are cast to the
            specified data type before computing the cumulative sum.
            Default: `None`.
        include_initial (bool):
            boolean indicating whether to include the initial value (i.e., the
            additive identity, zero) as the first value along the provided axis
            in the output. Default: `False`.
        out (Optional[usm_ndarray]):
            the array into which the result is written.
            The data type of `out` must match the expected shape and the
            expected data type of the result or (if provided) `dtype`.
            If `None` then a new array is returned. Default: `None`.

    Returns:
        usm_ndarray:
            an array containing cumulative sums. The returned array has the data
            type as described in the `dtype` parameter description above.

            The returned array shape is determined as follows:

                * If `include_initial` is `False`, the returned array will
                  have the same shape as `x`
                * If `include_initial` is `True`, the returned array will
                  have the same shape as `x` except the axis along which the
                  cumulative sum is calculated, which will have size `N+1`

            where `N` is the size of the axis the cumulative sums are computed
            along.
    """
    return _accumulate_common(
        x,
        axis,
        dtype,
        include_initial,
        out,
        tai._cumsum_over_axis,
        tai._cumsum_final_axis_include_initial,
        tai._cumsum_dtype_supported,
        _default_accumulation_dtype,
    )


def cumulative_prod(
    x, /, *, axis=None, dtype=None, include_initial=False, out=None
):
    """
    cumulative_prod(x, /, *, axis=None, dtype=None, include_initial=False,
                   out=None)

    Calculates the cumulative product of elements in the input array `x`.

    Args:
        x (usm_ndarray):
            input array.
        axis (Optional[int]):
            axis along which cumulative product must be computed.
            If `None`, the product is computed over the entire array.
            If `x` is a one-dimensional array, providing an `axis` is optional;
            however, if `x` has more than one dimension, providing an `axis`
            is required.
            Default: `None`.
        dtype (Optional[dtype]):
            data type of the returned array. If `None`, the default data
            type is inferred from the "kind" of the input array data type.

                * If `x` has a real- or complex-valued floating-point data
                  type, the returned array will have the same data type as
                  `x`.
                * If `x` has signed integral data type, the returned array
                  will have the default signed integral type for the device
                  where input array `x` is allocated.
                * If `x` has unsigned integral data type, the returned array
                  will have the default unsigned integral type for the device
                  where input array `x` is allocated.
                * If `x` has a boolean data type, the returned array will
                  have the default signed integral type for the device
                  where input array `x` is allocated.

            If the data type (either specified or resolved) differs from the
            data type of `x`, the input array elements are cast to the
            specified data type before computing the cumulative product.
            Default: `None`.
        include_initial (bool):
            boolean indicating whether to include the initial value (i.e., the
            additive identity, zero) as the first value along the provided
            axis in the output. Default: `False`.
        out (Optional[usm_ndarray]):
            the array into which the result is written.
            The data type of `out` must match the expected shape and the
            expected data type of the result or (if provided) `dtype`.
            If `None` then a new array is returned. Default: `None`.

    Returns:
        usm_ndarray:
            an array containing cumulative products. The returned array has
            the data type as described in the `dtype` parameter description
            above.

            The returned array shape is determined as follows:

                * If `include_initial` is `False`, the returned array will
                  have the same shape as `x`
                * If `include_initial` is `True`, the returned array will
                  have the same shape as `x` except the axis along which the
                  cumulative product is calculated, which will have size `N+1`

            where `N` is the size of the axis the cumulative products are
            computed along.
    """
    return _accumulate_common(
        x,
        axis,
        dtype,
        include_initial,
        out,
        tai._cumprod_over_axis,
        tai._cumprod_final_axis_include_initial,
        tai._cumprod_dtype_supported,
        _default_accumulation_dtype,
    )


def cumulative_logsumexp(
    x, /, *, axis=None, dtype=None, include_initial=False, out=None
):
    """
    cumulative_logsumexp(x, /, *, axis=None, dtype=None, include_initial=False,
                   out=None)

    Calculates the cumulative logsmumexp of elements in the input array `x`.

    Args:
        x (usm_ndarray):
            input array.
        axis (Optional[int]):
            axis along which cumulative logsumexp must be computed.
            If `None`, the logsumexp is computed over the entire array.
            If `x` is a one-dimensional array, providing an `axis` is optional;
            however, if `x` has more than one dimension, providing an `axis`
            is required.
            Default: `None`.
        dtype (Optional[dtype]):
            data type of the returned array. If `None`, the default data
            type is inferred from the "kind" of the input array data type.

                * If `x` has a real- or complex-valued floating-point data
                  type, the returned array will have the same data type as
                  `x`.
                * If `x` has signed integral data type, the returned array
                  will have the default signed integral type for the device
                  where input array `x` is allocated.
                * If `x` has unsigned integral data type, the returned array
                  will have the default unsigned integral type for the device
                  where input array `x` is allocated.
                * If `x` has a boolean data type, the returned array will
                  have the default signed integral type for the device
                  where input array `x` is allocated.

            If the data type (either specified or resolved) differs from the
            data type of `x`, the input array elements are cast to the
            specified data type before computing the cumulative logsumexp.
            Default: `None`.
        include_initial (bool):
            boolean indicating whether to include the initial value (i.e., the
            additive identity, zero) as the first value along the provided axis
            in the output. Default: `False`.
        out (Optional[usm_ndarray]):
            the array into which the result is written.
            The data type of `out` must match the expected shape and the
            expected data type of the result or (if provided) `dtype`.
            If `None` then a new array is returned. Default: `None`.

    Returns:
        usm_ndarray:
            an array containing cumulative logsumexp results. The returned
            array has the data type as described in the `dtype` parameter
            description above.

            The returned array shape is determined as follows:

                * If `include_initial` is `False`, the returned array will
                  have the same shape as `x`
                * If `include_initial` is `True`, the returned array will
                  have the same shape as `x` except the axis along which the
                  cumulative logsumexp is calculated, which will have size
                  `N+1`
    """
    return _accumulate_common(
        x,
        axis,
        dtype,
        include_initial,
        out,
        tai._cumlogsumexp_over_axis,
        tai._cumlogsumexp_final_axis_include_initial,
        tai._cumlogsumexp_dtype_supported,
        _default_accumulation_dtype_fp_types,
    )

1	# Data Parallel Control (dpctl)
2	#
3	# Copyright 2020-2024 Intel Corporation
4	#
5	# Licensed under the Apache License, Version 2.0 (the "License");
6	# you may not use this file except in compliance with the License.
7	# You may obtain a copy of the License at
8	#
9	# http://www.apache.org/licenses/LICENSE-2.0
10	#
11	# Unless required by applicable law or agreed to in writing, software
12	# distributed under the License is distributed on an "AS IS" BASIS,
13	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	# See the License for the specific language governing permissions and
15	# limitations under the License.
16
17	from numpy.core.numeric import normalize_axis_index	1✔
18
19	import dpctl	1✔
20	import dpctl.tensor as dpt	1✔
21	import dpctl.tensor._tensor_accumulation_impl as tai	1✔
22	import dpctl.tensor._tensor_impl as ti	1✔
23	from dpctl.tensor._type_utils import (	1✔
24	_default_accumulation_dtype,
25	_default_accumulation_dtype_fp_types,
26	_to_device_supported_dtype,
27	)
28	from dpctl.utils import ExecutionPlacementError, SequentialOrderManager	1✔
29
30
31	def _accumulate_common(	1✔
32	x,
33	axis,
34	dtype,
35	include_initial,
36	out,
37	_accumulate_fn,
38	_accumulate_include_initial_fn,
39	_dtype_supported,
40	_default_accumulation_type_fn,
41	):
42	if not isinstance(x, dpt.usm_ndarray):	1✔
43	raise TypeError(f"Expected dpctl.tensor.usm_ndarray, got {type(x)}")	1✔
44	appended_axis = False	1✔
45	if x.ndim == 0:	1✔
46	x = x[dpt.newaxis]	1✔
47	appended_axis = True	1✔
48	nd = x.ndim	1✔
49	if axis is None:	1✔
50	if nd > 1:	1✔
51	raise ValueError(	1✔
52	"`axis` cannot be `None` for array of dimension `{}`".format(nd)
53	)
54	axis = 0	1✔
55	else:
56	axis = normalize_axis_index(axis, nd, "axis")	1✔
57	sh = x.shape	1✔
58	res_sh = (	1✔
59	sh[:axis] + (sh[axis] + 1,) + sh[axis + 1 :] if include_initial else sh
60	)
61	a1 = axis + 1	1✔
62	if a1 == nd:	1✔
63	perm = list(range(nd))	1✔
64	arr = x	1✔
65	else:
66	perm = [i for i in range(nd) if i != axis] + [	1✔
67	axis,
68	]
69	arr = dpt.permute_dims(x, perm)	1✔
70	q = x.sycl_queue	1✔
71	inp_dt = x.dtype	1✔
72	res_usm_type = x.usm_type	1✔
73	if dtype is None:	1✔
74	res_dt = _default_accumulation_type_fn(inp_dt, q)	1✔
75	else:
76	res_dt = dpt.dtype(dtype)	1✔
77	res_dt = _to_device_supported_dtype(res_dt, q.sycl_device)	1✔
78
79	# checking now avoids unnecessary allocations
80	implemented_types = _dtype_supported(inp_dt, res_dt)	1✔
81	if dtype is None and not implemented_types:	1!
82	raise RuntimeError(	×
83	"Automatically determined accumulation data type does not "
84	"have direct implementation"
85	)
86	orig_out = out	1✔
87	if out is not None:	1✔
88	if not isinstance(out, dpt.usm_ndarray):	1✔
89	raise TypeError(	1✔
90	f"output array must be of usm_ndarray type, got {type(out)}"
91	)
92	if not out.flags.writable:	1✔
93	raise ValueError("provided `out` array is read-only")	1✔
94	out_sh = out.shape	1✔
95	# append an axis to `out` if scalar
96	if appended_axis and not include_initial:	1✔
97	out = out[dpt.newaxis, ...]	1✔
98	orig_out = out	1✔
99	final_res_sh = res_sh[1:]	1✔
100	else:
101	final_res_sh = res_sh	1✔
102	if not out_sh == final_res_sh:	1✔
103	raise ValueError(	1✔
104	"The shape of input and output arrays are inconsistent. "
105	f"Expected output shape is {final_res_sh}, got {out_sh}"
106	)
107	if res_dt != out.dtype:	1✔
108	raise ValueError(	1✔
109	f"Output array of type {res_dt} is needed, " f"got {out.dtype}"
110	)
111	if dpctl.utils.get_execution_queue((q, out.sycl_queue)) is None:	1✔
112	raise ExecutionPlacementError(	1✔
113	"Input and output allocation queues are not compatible"
114	)
115	# permute out array dims if necessary
116	if a1 != nd:	1✔
117	out = dpt.permute_dims(out, perm)	1✔
118	orig_out = out	1✔
119	if ti._array_overlap(x, out) and implemented_types:	1✔
120	out = dpt.empty_like(out)	1✔
121	else:
122	out = dpt.empty(	1✔
123	res_sh, dtype=res_dt, usm_type=res_usm_type, sycl_queue=q
124	)
125	if a1 != nd:	1✔
126	out = dpt.permute_dims(out, perm)	1✔
127
128	final_ev = dpctl.SyclEvent()	1✔
129	_manager = SequentialOrderManager[q]	1✔
130	depends = _manager.submitted_events	1✔
131	if implemented_types:	1✔
132	if not include_initial:	1✔
133	ht_e, acc_ev = _accumulate_fn(	1✔
134	src=arr,
135	trailing_dims_to_accumulate=1,
136	dst=out,
137	sycl_queue=q,
138	depends=depends,
139	)
140	else:
141	ht_e, acc_ev = _accumulate_include_initial_fn(	1✔
142	src=arr, dst=out, sycl_queue=q, depends=depends
143	)
144	_manager.add_event_pair(ht_e, acc_ev)	1✔
145	if not (orig_out is None or out is orig_out):	1✔
146	# Copy the out data from temporary buffer to original memory
147	ht_e_cpy, acc_ev = ti._copy_usm_ndarray_into_usm_ndarray(	1✔
148	src=out, dst=orig_out, sycl_queue=q, depends=[acc_ev]
149	)
150	_manager.add_event_pair(ht_e_cpy, acc_ev)	1✔
151	out = orig_out	1✔
152	final_ev = acc_ev	1✔
153	else:
154	if _dtype_supported(res_dt, res_dt):	1✔
155	tmp = dpt.empty(	1✔
156	arr.shape, dtype=res_dt, usm_type=res_usm_type, sycl_queue=q
157	)
158	ht_e_cpy, cpy_e = ti._copy_usm_ndarray_into_usm_ndarray(	1✔
159	src=arr, dst=tmp, sycl_queue=q, depends=depends
160	)
161	_manager.add_event_pair(ht_e_cpy, cpy_e)	1✔
162	if not include_initial:	1!
163	ht_e, final_ev = _accumulate_fn(	1✔
164	src=tmp,
165	trailing_dims_to_accumulate=1,
166	dst=out,
167	sycl_queue=q,
168	depends=[cpy_e],
169	)
170	else:
NEW 171	ht_e, final_ev = _accumulate_include_initial_fn(	×
172	src=tmp,
173	dst=out,
174	sycl_queue=q,
175	depends=[cpy_e],
176	)
177	_manager.add_event_pair(ht_e, final_ev)	1✔
178	else:
179	buf_dt = _default_accumulation_type_fn(inp_dt, q)	1✔
180	tmp = dpt.empty(	1✔
181	arr.shape, dtype=buf_dt, usm_type=res_usm_type, sycl_queue=q
182	)
183	ht_e_cpy, cpy_e = ti._copy_usm_ndarray_into_usm_ndarray(	1✔
184	src=arr, dst=tmp, sycl_queue=q, depends=depends
185	)
186	_manager.add_event_pair(ht_e_cpy, cpy_e)	1✔
187	tmp_res = dpt.empty(	1✔
188	res_sh, dtype=buf_dt, usm_type=res_usm_type, sycl_queue=q
189	)
190	if a1 != nd:	1✔
191	tmp_res = dpt.permute_dims(tmp_res, perm)	1✔
192	if not include_initial:	1!
193	ht_e, a_e = _accumulate_fn(	1✔
194	src=tmp,
195	trailing_dims_to_accumulate=1,
196	dst=tmp_res,
197	sycl_queue=q,
198	depends=[cpy_e],
199	)
200	else:
201	ht_e, a_e = _accumulate_include_initial_fn(	×
202	src=tmp,
203	dst=tmp_res,
204	sycl_queue=q,
205	depends=[cpy_e],
206	)
207	_manager.add_event_pair(ht_e, a_e)	1✔
208	ht_e_cpy2, final_ev = ti._copy_usm_ndarray_into_usm_ndarray(	1✔
209	src=tmp_res, dst=out, sycl_queue=q, depends=[a_e]
210	)
211	_manager.add_event_pair(ht_e_cpy2, final_ev)	1✔
212
213	if appended_axis:	1✔
214	out = dpt.squeeze(out)	1✔
215	if a1 != nd:	1✔
216	inv_perm = sorted(range(nd), key=lambda d: perm[d])	1✔
217	out = dpt.permute_dims(out, inv_perm)	1✔
218
219	return out	1✔
220
221
222	def cumulative_sum(	1✔
223	x, /, *, axis=None, dtype=None, include_initial=False, out=None
224	):
225	"""
226	cumulative_sum(x, /, *, axis=None, dtype=None, include_initial=False,
227	out=None)
228
229	Calculates the cumulative sum of elements in the input array `x`.
230
231	Args:
232	x (usm_ndarray):
233	input array.
234	axis (Optional[int]):
235	axis along which cumulative sum must be computed.
236	If `None`, the sum is computed over the entire array.
237	If `x` is a one-dimensional array, providing an `axis` is optional;
238	however, if `x` has more than one dimension, providing an `axis`
239	is required.
240	Default: `None`.
241	dtype (Optional[dtype]):
242	data type of the returned array. If `None`, the default data
243	type is inferred from the "kind" of the input array data type.
244
245	* If `x` has a real- or complex-valued floating-point data
246	type, the returned array will have the same data type as
247	`x`.
248	* If `x` has signed integral data type, the returned array
249	will have the default signed integral type for the device
250	where input array `x` is allocated.
251	* If `x` has unsigned integral data type, the returned array
252	will have the default unsigned integral type for the device
253	where input array `x` is allocated.
254	* If `x` has a boolean data type, the returned array will
255	have the default signed integral type for the device
256	where input array `x` is allocated.
257
258	If the data type (either specified or resolved) differs from the
259	data type of `x`, the input array elements are cast to the
260	specified data type before computing the cumulative sum.
261	Default: `None`.
262	include_initial (bool):
263	boolean indicating whether to include the initial value (i.e., the
264	additive identity, zero) as the first value along the provided axis
265	in the output. Default: `False`.
266	out (Optional[usm_ndarray]):
267	the array into which the result is written.
268	The data type of `out` must match the expected shape and the
269	expected data type of the result or (if provided) `dtype`.
270	If `None` then a new array is returned. Default: `None`.
271
272	Returns:
273	usm_ndarray:
274	an array containing cumulative sums. The returned array has the data
275	type as described in the `dtype` parameter description above.
276
277	The returned array shape is determined as follows:
278
279	* If `include_initial` is `False`, the returned array will
280	have the same shape as `x`
281	* If `include_initial` is `True`, the returned array will
282	have the same shape as `x` except the axis along which the
283	cumulative sum is calculated, which will have size `N+1`
284
285	where `N` is the size of the axis the cumulative sums are computed
286	along.
287	"""
288	return _accumulate_common(	1✔
289	x,
290	axis,
291	dtype,
292	include_initial,
293	out,
294	tai._cumsum_over_axis,
295	tai._cumsum_final_axis_include_initial,
296	tai._cumsum_dtype_supported,
297	_default_accumulation_dtype,
298	)
299
300
301	def cumulative_prod(	1✔
302	x, /, *, axis=None, dtype=None, include_initial=False, out=None
303	):
304	"""
305	cumulative_prod(x, /, *, axis=None, dtype=None, include_initial=False,
306	out=None)
307
308	Calculates the cumulative product of elements in the input array `x`.
309
310	Args:
311	x (usm_ndarray):
312	input array.
313	axis (Optional[int]):
314	axis along which cumulative product must be computed.
315	If `None`, the product is computed over the entire array.
316	If `x` is a one-dimensional array, providing an `axis` is optional;
317	however, if `x` has more than one dimension, providing an `axis`
318	is required.
319	Default: `None`.
320	dtype (Optional[dtype]):
321	data type of the returned array. If `None`, the default data
322	type is inferred from the "kind" of the input array data type.
323
324	* If `x` has a real- or complex-valued floating-point data
325	type, the returned array will have the same data type as
326	`x`.
327	* If `x` has signed integral data type, the returned array
328	will have the default signed integral type for the device
329	where input array `x` is allocated.
330	* If `x` has unsigned integral data type, the returned array
331	will have the default unsigned integral type for the device
332	where input array `x` is allocated.
333	* If `x` has a boolean data type, the returned array will
334	have the default signed integral type for the device
335	where input array `x` is allocated.
336
337	If the data type (either specified or resolved) differs from the
338	data type of `x`, the input array elements are cast to the
339	specified data type before computing the cumulative product.
340	Default: `None`.
341	include_initial (bool):
342	boolean indicating whether to include the initial value (i.e., the
343	additive identity, zero) as the first value along the provided
344	axis in the output. Default: `False`.
345	out (Optional[usm_ndarray]):
346	the array into which the result is written.
347	The data type of `out` must match the expected shape and the
348	expected data type of the result or (if provided) `dtype`.
349	If `None` then a new array is returned. Default: `None`.
350
351	Returns:
352	usm_ndarray:
353	an array containing cumulative products. The returned array has
354	the data type as described in the `dtype` parameter description
355	above.
356
357	The returned array shape is determined as follows:
358
359	* If `include_initial` is `False`, the returned array will
360	have the same shape as `x`
361	* If `include_initial` is `True`, the returned array will
362	have the same shape as `x` except the axis along which the
363	cumulative product is calculated, which will have size `N+1`
364
365	where `N` is the size of the axis the cumulative products are
366	computed along.
367	"""
368	return _accumulate_common(	1✔
369	x,
370	axis,
371	dtype,
372	include_initial,
373	out,
374	tai._cumprod_over_axis,
375	tai._cumprod_final_axis_include_initial,
376	tai._cumprod_dtype_supported,
377	_default_accumulation_dtype,
378	)
379
380
381	def cumulative_logsumexp(	1✔
382	x, /, *, axis=None, dtype=None, include_initial=False, out=None
383	):
384	"""
385	cumulative_logsumexp(x, /, *, axis=None, dtype=None, include_initial=False,
386	out=None)
387
388	Calculates the cumulative logsmumexp of elements in the input array `x`.
389
390	Args:
391	x (usm_ndarray):
392	input array.
393	axis (Optional[int]):
394	axis along which cumulative logsumexp must be computed.
395	If `None`, the logsumexp is computed over the entire array.
396	If `x` is a one-dimensional array, providing an `axis` is optional;
397	however, if `x` has more than one dimension, providing an `axis`
398	is required.
399	Default: `None`.
400	dtype (Optional[dtype]):
401	data type of the returned array. If `None`, the default data
402	type is inferred from the "kind" of the input array data type.
403
404	* If `x` has a real- or complex-valued floating-point data
405	type, the returned array will have the same data type as
406	`x`.
407	* If `x` has signed integral data type, the returned array
408	will have the default signed integral type for the device
409	where input array `x` is allocated.
410	* If `x` has unsigned integral data type, the returned array
411	will have the default unsigned integral type for the device
412	where input array `x` is allocated.
413	* If `x` has a boolean data type, the returned array will
414	have the default signed integral type for the device
415	where input array `x` is allocated.
416
417	If the data type (either specified or resolved) differs from the
418	data type of `x`, the input array elements are cast to the
419	specified data type before computing the cumulative logsumexp.
420	Default: `None`.
421	include_initial (bool):
422	boolean indicating whether to include the initial value (i.e., the
423	additive identity, zero) as the first value along the provided axis
424	in the output. Default: `False`.
425	out (Optional[usm_ndarray]):
426	the array into which the result is written.
427	The data type of `out` must match the expected shape and the
428	expected data type of the result or (if provided) `dtype`.
429	If `None` then a new array is returned. Default: `None`.
430
431	Returns:
432	usm_ndarray:
433	an array containing cumulative logsumexp results. The returned
434	array has the data type as described in the `dtype` parameter
435	description above.
436
437	The returned array shape is determined as follows:
438
439	* If `include_initial` is `False`, the returned array will
440	have the same shape as `x`
441	* If `include_initial` is `True`, the returned array will
442	have the same shape as `x` except the axis along which the
443	cumulative logsumexp is calculated, which will have size
444	`N+1`
445	"""
446	return _accumulate_common(	1✔
447	x,
448	axis,
449	dtype,
450	include_initial,
451	out,
452	tai._cumlogsumexp_over_axis,
453	tai._cumlogsumexp_final_axis_include_initial,
454	tai._cumlogsumexp_dtype_supported,
455	_default_accumulation_dtype_fp_types,
456	)

IntelPython / dpctl / 9359853505

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous