:mod:`heat.regression` ====================== .. py:module:: heat.regression .. autoapi-nested-parse:: include regression algorithms into heat namespace Submodules ---------- .. toctree:: :titlesonly: :maxdepth: 1 lasso/index.rst Package Contents ---------------- .. py:class:: DNDarray(array: torch.Tensor, gshape: tuple[int, ...], dtype: heat.core.types.datatype, split: int | None, device: heat.core.devices.Device, comm: Communication, balanced: bool) Distributed N-Dimensional array. The core element of Heat. It is composed of PyTorch tensors local to each process. :param array: Local array elements :type array: torch.Tensor :param gshape: The global shape of the array :type gshape: tuple[int,...] :param dtype: The datatype of the array :type dtype: datatype :param split: The axis on which the array is divided between processes :type split: int or None :param device: The device on which the local arrays are using (cpu or gpu) :type device: Device :param comm: The communications object for sending and receiving data :type comm: Communication :param balanced: Describes whether the data are evenly distributed across processes. If this information is not available (``self.balanced is None``), it can be gathered via the :func:`is_balanced()` method (requires communication). :type balanced: bool or None .. attribute:: __array .. attribute:: __gshape .. attribute:: __dtype .. attribute:: __split .. attribute:: __device .. attribute:: __comm .. attribute:: __balanced :annotation: :bool .. attribute:: __ishalo :annotation: = False .. attribute:: __halo_next :annotation: :torch.Tensor | None = None .. attribute:: __halo_prev :annotation: :torch.Tensor | None = None .. attribute:: __partitions_dict__ :annotation: = None .. attribute:: __lshape_map :annotation: = None .. attribute:: __counts_displs :annotation: = None .. role:: raw-html(raw) :format: html .. method:: __prephalo(start, end) -> torch.Tensor Extracts the halo indexed by start, end from ``self.array`` in the direction of ``self.split`` :param start: Start index of the halo extracted from ``self.array`` :type start: int :param end: End index of the halo extracted from ``self.array`` :type end: int .. method:: get_halo(halo_size: int, prev: bool = True, next: bool = True) Fetch halos of size ``halo_size`` from neighboring ranks and save them in ``self.halo_next/self.halo_prev``. :param halo_size: Size of the halo. :type halo_size: int :param prev: If True, fetch the halo from the previous rank. Default: True. :type prev: bool, optional :param next: If True, fetch the halo from the next rank. Default: True. :type next: bool, optional .. method:: __cat_halo() -> torch.Tensor Return local array concatenated to halos if they are available. .. method:: __array__() -> numpy.ndarray Returns a view of the process-local slice of the :class:`DNDarray` as a numpy ndarray, if the ``DNDarray`` resides on CPU. Otherwise, it returns a copy, on CPU, of the process-local slice of ``DNDarray`` as numpy ndarray. .. method:: __array_ufunc__(ufunc, method, *inputs, **kwargs) Override NumPy's universal functions. .. method:: __array_function__(func, types, args, kwargs) Augments NumPy's functions. .. method:: __array_namespace__(*, api_version: str | None = None) -> Any Returns an object that has all the array API functions on it. :param api_version: string representing the version of the array API specification to be returned, in ``'YYYY.MM'`` form. If it is ``None`` (default), it returns the namespace corresponding to latest version of the array API specification. :type api_version: Optional[str] .. method:: astype(dtype, copy=True, device: heat.core.devices.Device = None) -> DNDarray Returns a casted version of this array. Casted array is a new array of the same shape but with given type of this array. If copy is ``True``, the same array is returned instead. :param dtype: Heat type to which the array is cast :type dtype: datatype :param copy: By default the operation returns a copy of this array. If copy is set to ``False`` the cast is performed in-place and this array is returned :type copy: bool, optional :param device: The device on which to place the array. If ``None``, keep device. Default: None. :type device: ht.Device, optional .. method:: balance_() -> None Function for balancing a :class:`DNDarray` between all nodes. To determine if this is needed use the :func:`is_balanced()` function. If the ``DNDarray`` is already balanced this function will do nothing. This function modifies the ``DNDarray`` itself and will not return anything. .. rubric:: Examples >>> a = ht.zeros((10, 2), split=0) >>> a[:, 0] = ht.arange(10) >>> b = a[3:] [0/2] tensor([[3., 0.], [1/2] tensor([[4., 0.], [5., 0.], [6., 0.]]) [2/2] tensor([[7., 0.], [8., 0.], [9., 0.]]) >>> b.balance_() >>> print(b.gshape, b.lshape) [0/2] (7, 2) (1, 2) [1/2] (7, 2) (3, 2) [2/2] (7, 2) (3, 2) >>> b [0/2] tensor([[3., 0.], [4., 0.], [5., 0.]]) [1/2] tensor([[6., 0.], [7., 0.]]) [2/2] tensor([[8., 0.], [9., 0.]]) >>> print(b.gshape, b.lshape) [0/2] (7, 2) (3, 2) [1/2] (7, 2) (2, 2) [2/2] (7, 2) (2, 2) .. method:: __bool__() -> bool Boolean scalar casting. .. method:: __cast(cast_function) -> float | int Implements a generic cast function for ``DNDarray`` objects. :param cast_function: The actual cast function, e.g. ``float`` or ``int`` :type cast_function: function :raises TypeError: If the ``DNDarray`` object cannot be converted into a scalar. .. method:: collect_(target_rank: int = 0) -> None A method collecting a distributed DNDarray to one MPI rank, chosen by the `target_rank` variable. It is a specific case of the ``redistribute_`` method. :param target_rank: The rank to which the DNDarray will be collected. Default: 0. :type target_rank: int, optional :raises TypeError: If the target rank is not an integer. :raises ValueError: If the target rank is out of bounds. .. rubric:: Examples >>> st = ht.ones((50, 81, 67), split=2) >>> print(st.lshape) [0/2] (50, 81, 23) [1/2] (50, 81, 22) [2/2] (50, 81, 22) >>> st.collect_() >>> print(st.lshape) [0/2] (50, 81, 67) [1/2] (50, 81, 0) [2/2] (50, 81, 0) >>> st.collect_(1) >>> print(st.lshape) [0/2] (50, 81, 0) [1/2] (50, 81, 67) [2/2] (50, 81, 0) .. method:: __complex__() -> DNDarray Complex scalar casting. .. method:: counts_displs() -> tuple[tuple[int, ...], tuple[int, ...]] Returns actual counts (number of items per process) and displacements (offsets) of the DNDarray. Does not assume load balance. .. method:: cpu() -> DNDarray Returns a copy of this object in main memory. If this object is already in main memory, then no copy is performed and the original object is returned. .. method:: create_lshape_map(force_check: bool = False) -> torch.Tensor Generate a 'map' of the lshapes of the data on all processes. Units are ``(process rank, lshape)`` :param force_check: if False (default) and the lshape map has already been created, use the previous result. Otherwise, create the lshape_map :type force_check: bool, optional .. method:: create_partition_interface() Create a partition interface in line with the DPPY proposal. This is subject to change. The intention of this to facilitate the usage of a general format for the referencing of distributed datasets. An example of the output and shape is shown below. __partitioned__ = { 'shape': (27, 3, 2), 'partition_tiling': (4, 1, 1), 'partitions': { (0, 0, 0): { 'start': (0, 0, 0), 'shape': (7, 3, 2), 'data': tensor([...], dtype=torch.int32), 'location': [0], 'dtype': torch.int32, 'device': 'cpu' }, (1, 0, 0): { 'start': (7, 0, 0), 'shape': (7, 3, 2), 'data': None, 'location': [1], 'dtype': torch.int32, 'device': 'cpu' }, (2, 0, 0): { 'start': (14, 0, 0), 'shape': (7, 3, 2), 'data': None, 'location': [2], 'dtype': torch.int32, 'device': 'cpu' }, (3, 0, 0): { 'start': (21, 0, 0), 'shape': (6, 3, 2), 'data': None, 'location': [3], 'dtype': torch.int32, 'device': 'cpu' } }, 'locals': [(rank, 0, 0)], 'get': lambda x: x, } :rtype: dictionary containing the partition interface as shown above. .. method:: __dlpack__(*args, **kwargs) -> Any Exports the undistributed array for consumption by ``from_dlpack()`` as a DLPack capsule. Any positional arguments ``*args`` and keyword arguments ``**kwargs`` are directly forwarded to torch ``__dlpack__``. .. note:: See `Array API `_ for details and the function signature as implemented by torch. :raises BufferError: if the DNDarray is distributed, as this is not supported by DLPack. .. method:: __dlpack_device__() -> tuple[enum.Enum, int] Returns device type and device ID in DLPack format. Meant for use within ``from_dlpack()``. .. method:: __float__() -> float Float scalar casting. .. seealso:: :func:`~heat.core.manipulations.flatten` .. method:: fill_diagonal(value: float) -> DNDarray Fill the main diagonal of a 2D :class:`DNDarray`. This function modifies the input tensor in-place, and returns the input array. :param value: The value to be placed in the ``DNDarrays`` main diagonal :type value: float .. method:: __broadcast_value(key: int | tuple[int, ...] | slice, value: DNDarray, **kwargs) Broadcasts the assignment DNDarray `value` to the shape of the indexed array `arr[key]` if necessary. .. method:: __set(key: int | tuple[int, ...] | list[int], value: float | DNDarray | torch.Tensor) Setter for not advanced indexing, i.e. when arr[key] is an in-place view of arr. .. method:: __advanced_setitem_unordered_local(x_local: torch.Tensor, split_key: torch.Tensor, value_torch: torch.Tensor, *, split_axis: int, value_key_start_dim: int, local_offset: int, local_size: int, value_is_scalar: bool, out_dtype: torch.dtype, base_index: tuple | None = None) -> None The function is a helper that updates ``x_local`` in-place according to the logical advanced indexing pattern encoded by ``split_key`` and the broadcasted ``value_torch``. This helper operates exclusively on local ``torch.Tensor`` views: - ``x_local`` is the local slice of the distributed array on this rank. - ``split_key`` contains GLOBAL indices along the split axis. - Only those indices that fall into ``[local_offset, local_offset + local_size)`` are applied on this rank. .. method:: __getitem_scalar(p: ProcessedKey) -> DNDarray Handles single-element extraction. If the scalar index falls on the split axis, the extracted value is broadcasted from the root process to all others. .. method:: __getitem_local(p: ProcessedKey) -> DNDarray Handles process-local indexing (including standard slices and local advanced indices) directly on local array partitions without MPI communication. .. method:: __getitem_descending_slice_distributed(p: ProcessedKey) -> DNDarray Handles negative step slicing along the split axis. This is a workaround as torch does not support negative-step slicing. .. method:: __getitem_mask(p: ProcessedKey) -> DNDarray Handles fast-path boolean masking. Applies the mask locally without requiring MPI communication during extraction, returning a flattened array distributed along the specified split axis. .. method:: __getitem_advanced_distributed(p: ProcessedKey) -> DNDarray Handles advanced indexing with unordered global indices. Defers to ``__getitem_unordered`` to resolve data dependencies via an ``Alltoallv`` exchange. .. method:: __getitem_unordered(key: tuple, output_shape: tuple, output_split: int, out_is_balanced: bool, key_is_mask_like: bool) -> DNDarray Handles the MPI communication (Alltoallv) when the key along the split axis is unordered and indices are global. .. method:: __prepare_unordered_comm(split_key_flat: torch.Tensor, displs: tuple) -> tuple Helper function for distributed unordered indexing. Determines destination ranks, sorts the key, and computes Alltoallv parameters. .. method:: __getitem__(key: Indexer) -> DNDarray Global getter function for DNDarrays. Returns a new DNDarray corresponding to the selection of values from the original DNDarray as specified by `key`. The `key` can be a variety of indexers, including integers, slices, lists, boolean masks, DNDarrays, ndarrays, torch tensors, and a combination thereof. The function determines the appropriate method to retrieve the requested data based on the type and structure of `key`, executing MPI communication if the indexing pattern requires data from multiple processes. .. rubric:: Notes The returned DNDarray will have its shape, split, and balanced status determined according to the indexing operation performed. For more details on supported indexing behaviors, see the :doc:`indexing documentation `. :param key: Indices to get from the ``DNDarray``. :type key: array-like indexer .. rubric:: Examples >>> a = ht.arange(10, split=0) (1/2) >>> tensor([0, 1, 2, 3, 4], dtype=torch.int32) (2/2) >>> tensor([5, 6, 7, 8, 9], dtype=torch.int32) >>> a[1:6] (1/2) >>> tensor([1, 2, 3, 4], dtype=torch.int32) (2/2) >>> tensor([5], dtype=torch.int32) >>> a = ht.zeros((4, 5), split=0) (1/2) >>> tensor([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) (2/2) >>> tensor([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) >>> a[1:4, 1] (1/2) >>> tensor([0.]) (2/2) >>> tensor([0., 0.]) .. method:: gpu() -> DNDarray Returns a copy of this object in GPU memory. If this object is already in GPU memory, then no copy is performed and the original object is returned. .. method:: __index__() -> int Converts a zero-dimensional integer array to a Python ``int`` object. .. method:: __int__() -> int Integer scalar casting. .. method:: is_balanced(force_check: bool = False) -> bool Determine if ``self`` is balanced evenly (or as evenly as possible) across all nodes distributed evenly (or as evenly as possible) across all processes. This is equivalent to returning ``self.balanced``. If no information is available (``self.balanced = None``), the balanced status will be assessed via collective communication. :param force_check: If True, the balanced status of the ``DNDarray`` will be assessed via collective communication in any case. :type force_check: bool, optional .. method:: is_distributed() -> bool Determines whether the data of this ``DNDarray`` is distributed across multiple processes. .. method:: item() Returns the only element of a 1-element :class:`DNDarray`. Mirror of the pytorch command by the same name. If size of ``DNDarray`` is >1 element, then a ``ValueError`` is raised (by pytorch) .. rubric:: Examples >>> import heat as ht >>> x = ht.zeros((1)) >>> x.item() 0.0 .. method:: __len__() -> int The length of the ``DNDarray``, i.e. the number of items in the first dimension. .. method:: numpy() -> numpy.typing.NDArray[Any] Returns a copy of the :class:`DNDarray` as numpy ndarray. If the ``DNDarray`` resides on the GPU, the underlying data will be copied to the CPU first. If the ``DNDarray`` is distributed, an MPI Allgather operation will be performed before converting to np.ndarray, i.e. each MPI process will end up holding a copy of the entire array in memory. Make sure process memory is sufficient! .. rubric:: Examples >>> import heat as ht T1 = ht.random.randn((10,8)) T1.numpy() .. method:: _repr_pretty_(p, cycle) Pretty print for IPython. .. method:: __repr__() -> str Returns a printable representation of the passed DNDarray, targeting developers. .. method:: ravel() -> DNDarray Flattens the ``DNDarray``. .. seealso:: :func:`~heat.core.manipulations.ravel` .. rubric:: Examples >>> a = ht.ones((2, 3), split=0) >>> b = a.ravel() >>> a[0, 0] = 4 >>> b DNDarray([4., 1., 1., 1., 1., 1.], dtype=ht.float32, device=cpu:0, split=0) .. method:: redistribute_(lshape_map: torch.Tensor | None = None, target_map: torch.Tensor | None = None) -> None Redistributes the data of the :class:`DNDarray` *along the split axis* to match the given target map. This function does not modify the non-split dimensions of the ``DNDarray``. This is an abstraction and extension of the balance function. :param lshape_map: The current lshape of processes. Units are ``[rank, lshape]``. :type lshape_map: torch.Tensor, optional :param target_map: The desired distribution across the processes. Units are ``[rank, target lshape]``. Note: the only important parts of the target map are the values along the split axis, values which are not along this axis are there to mimic the shape of the ``lshape_map``. :type target_map: torch.Tensor, optional .. rubric:: Examples >>> st = ht.ones((50, 81, 67), split=2) >>> target_map = torch.zeros((st.comm.size, 3), dtype=torch.int64) >>> target_map[0, 2] = 67 >>> print(target_map) [0/2] tensor([[ 0, 0, 67], [0/2] [ 0, 0, 0], [0/2] [ 0, 0, 0]], dtype=torch.int32) [1/2] tensor([[ 0, 0, 67], [1/2] [ 0, 0, 0], [1/2] [ 0, 0, 0]], dtype=torch.int32) [2/2] tensor([[ 0, 0, 67], [2/2] [ 0, 0, 0], [2/2] [ 0, 0, 0]], dtype=torch.int32) >>> print(st.lshape) [0/2] (50, 81, 23) [1/2] (50, 81, 22) [2/2] (50, 81, 22) >>> st.redistribute_(target_map=target_map) >>> print(st.lshape) [0/2] (50, 81, 67) [1/2] (50, 81, 0) [2/2] (50, 81, 0) .. method:: __redistribute_shuffle(snd_pr: int | torch.Tensor, send_amt: int | torch.Tensor, rcv_pr: int | torch.Tensor, snd_dtype: torch.dtype) Function to abstract the function used during redistribute for shuffling data between processes along the split axis :param snd_pr: Sending process :type snd_pr: int or torch.Tensor :param send_amt: Amount of data to be sent by the sending process :type send_amt: int or torch.Tensor :param rcv_pr: Receiving process :type rcv_pr: int or torch.Tensor :param snd_dtype: Torch type of the data in question :type snd_dtype: torch.dtype .. method:: resplit_(axis: int = None) In-place option for resplitting a :class:`DNDarray`. :param axis: The new split axis, ``None`` denotes gathering, an int will set the new split axis :type axis: int .. rubric:: Examples >>> a = ht.zeros( ... ( ... 4, ... 5, ... ), ... split=0, ... ) >>> a.lshape (0/2) (2, 5) (1/2) (2, 5) >>> ht.resplit_(a, None) >>> a.split None >>> a.lshape (0/2) (4, 5) (1/2) (4, 5) >>> a = ht.zeros( ... ( ... 4, ... 5, ... ), ... split=0, ... ) >>> a.lshape (0/2) (2, 5) (1/2) (2, 5) >>> ht.resplit_(a, 1) >>> a.split 1 >>> a.lshape (0/2) (4, 3) (1/2) (4, 2) .. method:: __setitem_scalar(p: ProcessedKey, value: DNDarray, value_is_scalar: bool) -> None .. method:: __setitem_local(p: ProcessedKey, value: DNDarray, value_is_scalar: bool) -> None Handles process-local item assignment (slices and local indices) directly on local partitions. If `value` is distributed, MPI communication might be necessary to align it with the target slice before assignment. .. method:: __setitem_descending_slice_distributed(p: ProcessedKey, value: DNDarray, value_is_scalar: bool) -> None Handles assignment via negative-step slicing. Flips the `value` array and redistributes it to align with the descending split key before performing the local assignment. .. method:: __setitem_mask(p: ProcessedKey, value: DNDarray, value_is_scalar: bool) -> None Handles assignment using boolean masks. If `value` is distributed, it will be redistributed to match the number of True elements in the local mask before assignment. If `value` is not distributed, it will be assigned directly to the masked positions on each process, with PyTorch handling any necessary broadcasting. .. method:: __setitem_advanced_distributed(p: ProcessedKey, original_key, value: DNDarray, value_is_scalar: bool, original_split: int = None) -> None Handles advanced indexing assignments where the indexing key is distributed. This method ensures that the value array is properly aligned and redistributed if necessary before performing the local assignment on each process. .. method:: __setitem_unordered(key: tuple | list | torch.Tensor, key_is_mask_like: bool, value: DNDarray, key_is_single_tensor: bool, counts: tuple, displs: tuple, rank: int, key_is_distributed: bool = False) -> DNDarray Handles the MPI communication when assigning a distributed value to a distributed array with unordered global indices. .. method:: __setitem__(key: Indexer, value: float | DNDarray | torch.Tensor) Global item setter for DNDarrays. Assigns values to the specified positions in the ``DNDarray``. The `key` can be a variety of indexers, including integers, slices, lists, boolean masks, DNDarrays, ndarrays, torch tensors, or a combination thereof. If a distributed ``DNDarray`` is given as the `value` to be set, this function will automatically attempt to align its distribution scheme (split axis and local shapes) with the target indexed array via MPI communication. If the distributions cannot be safely aligned, a ``ValueError`` or ``RuntimeError`` is raised. :param key: Index/indices to be set :type key: array-like indexer :param value: Value to be set to the specified positions in the DNDarray (self) :type value: float | "DNDarray" | torch.Tensor .. rubric:: Notes For more details on supported indexing behaviors, see the :doc:`indexing documentation `. .. rubric:: Examples >>> a = ht.zeros((4, 5), split=0) (1/2) >>> tensor([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) (2/2) >>> tensor([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) >>> a[1:4, 1] = 1 >>> a (1/2) >>> tensor([[0., 0., 0., 0., 0.], [0., 1., 0., 0., 0.]]) (2/2) >>> tensor([[0., 1., 0., 0., 0.], [0., 1., 0., 0., 0.]]) .. method:: __str__() -> str Computes a string representation of the passed ``DNDarray``. .. method:: to_device(device: heat.core.devices.Device, /, *, stream: int | Any | None = None) -> DNDarray Copy the array from the device on which it currently resides to the specified ``device``. :param device: A ``Device`` object. :type device: Device :param stream: Stream object to use during copy. :type stream: Int or Any, optional .. method:: tolist(keepsplit: bool = False) -> list[int | float] Return a copy of the local array data as a (nested) Python list. For scalars, a standard Python number is returned. :param keepsplit: Whether the list should be returned locally or globally. :type keepsplit: bool .. rubric:: Examples >>> a = ht.array([[0, 1], [2, 3]]) >>> a.tolist() [[0, 1], [2, 3]] >>> a = ht.array([[0, 1], [2, 3]], split=0) >>> a.tolist() [[0, 1], [2, 3]] >>> a = ht.array([[0, 1], [2, 3]], split=1) >>> a.tolist(keepsplit=True) (1/2) [[0], [2]] (2/2) [[1], [3]] .. method:: __torch_function__(func, types, args=(), kwargs=None) Supports PyTorch's dispatch mechanism. .. method:: __torch_proxy__() -> torch.Tensor Return a 1-element `torch.Tensor` strided as the global `self` shape. Used internally for sanitation purposes. .. py:class:: Lasso(lam: Optional[float] = 0.1, max_iter: Optional[int] = 100, tol: Optional[float] = 1e-06) Bases: :class:`heat.RegressionMixin`, :class:`heat.BaseEstimator` ``Least absolute shrinkage and selection operator``(LASSO), a linear model with L1 regularization. The optimization objective for Lasso is: .. math:: E(w) = \frac{1}{2 m} ||y - Xw||^2_2 + \lambda ||w\_||_1 with .. math:: w\_=(w_1,w_2,...,w_n), w=(w_0,w_1,w_2,...,w_n), .. math:: y \in M(m \times 1), w \in M(n \times 1), X \in M(m \times n) :param lam: Constant that multiplies the L1 term. Default value: 0.1 ``lam = 0.`` is equivalent to an ordinary least square (OLS). For numerical reasons, using ``lam = 0.,`` with the ``Lasso`` object is not advised. :type lam: float, optional :param max_iter: The maximum number of iterations. Default value: 100 :type max_iter: int, optional :param tol: The tolerance for the optimization. :type tol: float, optional. Default value: 1e-8 :ivar __theta: :vartype __theta: array, shape (n_features + 1,), first element is the interception parameter vector w. :ivar coef_: parameter vector (w in the cost function formula) :vartype coef_: array, shape (n_features,) | (n_targets, n_features) :ivar intercept_: independent term in decision function. :vartype intercept_: float | array, shape (n_targets,) :ivar n_iter_: number of iterations run by the coordinate descent solver to reach the specified tolerance. :vartype n_iter_: int or None | array-like, shape (n_targets,) .. rubric:: Examples >>> X = ht.random.randn(10, 4, split=0) >>> y = ht.random.randn(10, 1, split=0) >>> estimator = ht.regression.lasso.Lasso(max_iter=100, tol=None) >>> estimator.fit(X, y) .. attribute:: __lam :annotation: = 0.1 .. attribute:: max_iter :annotation: = 100 .. attribute:: tol :annotation: = 1e-06 .. attribute:: __theta :annotation: = None .. attribute:: n_iter :annotation: = None .. role:: raw-html(raw) :format: html .. method:: soft_threshold(rho: heat.core.dndarray.DNDarray) -> Union[heat.core.dndarray.DNDarray, float] Soft threshold operator :param rho: Input model data, Shape = (1,) :type rho: DNDarray :param out: Thresholded model data, Shape = (1,) :type out: DNDarray or float .. method:: rmse(gt: heat.core.dndarray.DNDarray, yest: heat.core.dndarray.DNDarray) -> heat.core.dndarray.DNDarray Root mean square error (RMSE) :param gt: Input model data, Shape = (1,) :type gt: DNDarray :param yest: Thresholded model data, Shape = (1,) :type yest: DNDarray .. method:: fit(x: heat.core.dndarray.DNDarray, y: heat.core.dndarray.DNDarray) -> None Fit lasso model with coordinate descent :param x: Input data, Shape = (n_samples, n_features) :type x: DNDarray :param y: Labels, Shape = (n_samples,) :type y: DNDarray .. method:: predict(x: heat.core.dndarray.DNDarray) -> heat.core.dndarray.DNDarray Apply lasso model to input data. First row data corresponds to interception :param x: Input data, Shape = (n_samples, n_features) :type x: DNDarray