Implement hypothesis strategies and tests for arrays

python/cuml/testing/strategies.py

@@ -12,12 +12,285 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+import cudf
+import cupy as cp
+import numpy as np
 from hypothesis import assume
-from hypothesis.extra.numpy import arrays, floating_dtypes
-from hypothesis.strategies import composite, integers, just, none, one_of
+from hypothesis.extra.numpy import array_shapes, arrays, floating_dtypes
+from hypothesis.strategies import (
+    composite,
+    integers,
+    just,
+    none,
+    one_of,
+    sampled_from,
+)
 from sklearn.datasets import make_regression
 from sklearn.model_selection import train_test_split
 
+from cuml.common.array import CumlArray
+
+_CUML_ARRAY_INPUT_TYPES = ["numpy", "cupy", "series"]
+
+
+_CUML_ARRAY_DTYPES = [
+    np.float16,
+    np.float32,
+    np.float64,
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+]
+
+_CUML_ARRAY_ORDERS = ["F", "C"]
+
+
+_CUML_ARRAY_OUTPUT_TYPES = [
+    "cudf",
+    "cupy",
+    "dataframe",
+    "numba",
+    "numpy",
+    "series",
+]
+
+
+UNSUPPORTED_CUDF_DTYPES = [
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+    np.float16,
+]
+
+
+@composite
+def cuml_array_input_types(draw):
+    """Generates all supported cuml array input types."""
+    return draw(sampled_from(_CUML_ARRAY_INPUT_TYPES))
+
+
+@composite
+def cuml_array_output_types(draw):
+    """Generates all cuml array supported output types."""
+    return draw(sampled_from(_CUML_ARRAY_OUTPUT_TYPES))
+
+
+@composite
+def cuml_array_output_dtypes(draw):
+    """Generates all cuml array supported output dtypes."""
+    return draw(sampled_from(_CUML_ARRAY_DTYPES))
+
+
+@composite
+def cuml_array_dtypes(draw):
+    """Generates all supported cuml array dtypes."""
+    return draw(sampled_from(_CUML_ARRAY_DTYPES))
+
+
+@composite
+def cuml_array_orders(draw):
+    """Generates all supported cuml array orders."""
+    return draw(sampled_from(_CUML_ARRAY_ORDERS))
+
+
+@composite
+def cuml_array_shapes(
+    draw, *, min_dims=1, max_dims=2, min_side=1, max_side=None
+):
+    """
+    Generates cuml array shapes.
+
+    See also: hypothesis.extra.numpy.array_shapes()
+
+    Parameters
+    ----------
+    min_dims: int, default=1
+        Returned shapes will have at least this number of dimensions.
+    max_dims: int, default=2
+        Returned shapes will have at most this number of dimensions.
+    min_side: int, default=1
+        Returned shapes will have at least this size in any dimension.
+    max_side: int | None, default=min_side + 9
+        Returned shapes will have at most this size in any dimension.
+
+    Returns
+    -------
+    Shapes for cuml array inputs.
+    """
+    max_side = min_side + 9 if max_side is None else max_side
+
+    if not (1 <= min_dims <= max_dims):
+        raise ValueError(
+            "Arguments violate condition 1 <= min_dims <= max_dims."
+        )
+    if not (0 < min_side < max_side):
+        raise ValueError(
+            "Arguments violate condition 0 < min_side < max_side."
+        )
+
+    shapes = array_shapes(
+        min_dims=min_dims,
+        max_dims=max_dims,
+        min_side=min_side,
+        max_side=max_side,
+    )
+    just_size = integers(min_side, max_side)
+    return draw(one_of(shapes, just_size))
+
+
+def create_cuml_array_input(input_type, dtype, shape, order):
+    """
+    Creates a valid cuml array input.
+
+    Parameters
+    ----------
+    input_type: str | None, default=cupy
+        Valid input types are "numpy", "cupy", "series".
+    dtype: Data type specifier
+        A numpy/cupy compatible data type, e.g., numpy.float64.
+    shape: int | tuple[int]
+        Dimensions of the array to generate.
+    order : str in {'C', 'F'}
+        Order of arrays to generate, either F- or C-major.
+
+    Returns
+    -------
+    A cuml array input array.
+    """
+
+    input_type = "cupy" if input_type is None else input_type
+
+    multidimensional = (
+        isinstance(shape, tuple) and len([d for d in shape if d > 1]) > 1
+    )
+    assume(
+        not (
+            input_type == "series"
+            and (dtype in UNSUPPORTED_CUDF_DTYPES or multidimensional)
+        )
+    )
+
+    array = cp.ones(shape, dtype=dtype, order=order)
+
+    if input_type == "numpy":
+        return np.array(cp.asnumpy(array), dtype=dtype, order=order)
+
+    elif input_type == "series":
+        return cudf.Series(array)
+
+    elif input_type == "cupy":
+        return array
+
+    raise ValueError(
+        "The value for 'input_type' must be "
+        f"one of {', '.join(_CUML_ARRAY_INPUT_TYPES)}."
+    )
+
+
+@composite
+def cuml_array_inputs(
+    draw,
+    input_types=cuml_array_input_types(),
+    dtypes=cuml_array_dtypes(),
+    shapes=cuml_array_shapes(),
+    orders=cuml_array_orders(),
+):
+    """
+    Generates valid inputs for cuml arrays.
+
+    Parameters
+    ----------
+    input_types: SearchStrategy[("numpy", "cupy", "series")], \
+        default=cuml_array_input_tyes()
+        A search strategy for the type of array input.
+    dtypes: SearchStrategy[np.dtype], default=cuml_array_dtypes()
+        A search strategy for a numpy/cupy compatible data type.
+    shapes: SearchStrategy[int | tuple[int]], default=cuml_array_shapes()
+        A search strategy for array shapes.
+    orders : str in {'C', 'F'}, default=cuml_array_orders()
+        A search strategy for array orders.
+
+    Returns
+    -------
+    A strategy for valid cuml array inputs.
+    """
+    input_type = draw(input_types)
+    dtype = draw(dtypes)
+    shape = draw(shapes)
+    order = draw(orders)
+    multidimensional = (isinstance(shape, tuple) and len(shape) > 1)
+    assume(
+        not (
+            input_type == "series"
+            and (dtype in UNSUPPORTED_CUDF_DTYPES or multidimensional)
+        )
+    )
+
+    data = draw(arrays(dtype=dtype, shape=shape))
+
+    if input_type == "numpy":
+        ret = np.asarray(data, order=order)
+
+    elif input_type == "cupy":
+        ret = cp.array(data, dtype=dtype, order=order)
+
+    elif input_type == "series":
+        ret = cudf.Series(data)
+
+    else:
+        raise ValueError(
+            "The value for 'input_type' must be "
+            f"one of {', '.join(_CUML_ARRAY_INPUT_TYPES)}."
+        )
+
+    # Cupy currently does not support masked arrays.
+    cai = getattr(ret, '__cuda_array_interface__', dict())
+    assume(cai.get('mask') is None)
+
+    return ret
+
+
+@composite
+def cuml_arrays(
+    draw,
+    input_types=cuml_array_input_types(),
+    dtypes=cuml_array_dtypes(),
+    shapes=cuml_array_shapes(),
+    orders=cuml_array_orders(),
+):
+    """
+    Generates cuml arrays.
+
+    Parameters
+    ----------
+    input_types: SearchStrategy[("numpy", "cupy", "series")], \
+        default=cuml_array_input_tyes()
+        A search strategy for the type of array input.
+    dtypes: SearchStrategy[np.dtype], default=cuml_array_dtypes()
+        A search strategy for a numpy/cupy compatible data type.
+    shapes: SearchStrategy[int | tuple[int]], default=cuml_array_shapes()
+        A search strategy for array shapes.
+    orders : str in {'C', 'F'}, default=cuml_array_orders()
+        A search strategy for array orders.
+
+    Returns
+    -------
+    A strategy for cuml arrays.
+    """
+    array_input = create_cuml_array_input(
+        input_type=draw(input_types),
+        dtype=draw(dtypes),
+        shape=draw(shapes),
+        order=draw(orders),
+    )
+    return CumlArray(data=array_input)
+
 
 @composite
 def standard_datasets(

python/cuml/testing/utils.py

@@ -18,6 +18,7 @@
 import numpy as np
 import pandas as pd
 from copy import deepcopy
+from itertools import dropwhile
 
 from numba import cuda
 from numbers import Number
@@ -758,3 +759,24 @@ def svm_array_equal(a, b, tol=1e-6, relative_diff=True, report_summary=False):
         print('Avgdiff:', np.mean(diff), 'stddiyy:', np.std(diff), 'avgval:',
               np.mean(b))
     return equal
+
+
+def normalized_shape(shape):
+    """Normalize shape to tuple."""
+    return (shape, ) if isinstance(shape, int) else shape
+
+
+def squeezed_shape(shape):
+    """Remove all trailing axes of length 1 from shape.
+
+    Similar to, but not exactly like np.squeeze().
+    """
+    return tuple(reversed(list(dropwhile(lambda d: d == 1, reversed(shape)))))
+
+
+def series_squeezed_shape(shape):
+    """Remove all but one axes of length 1 from shape."""
+    if shape:
+        return tuple([d for d in normalized_shape(shape) if d != 1]) or (1,)
+    else:
+        return ()