Diff Coverage

        Returns:
            DTensor: A new DTensor whose local shard is on CPU.
        """
        new_local = self._local_tensor.cpu()
        return self._from_converted_local(new_local)

    def float(self):
        """Convert the DTensor to float dtype.

def _distribute_module_param_source(param: Any) -> Tensor:
    """Tensor data used as the global tensor for :func:`distribute_tensor` (PyTorch uses ``param.data``)."""
    if isinstance(param, DTensorBase):
        return platform.get_param_local_data(param)
    if hasattr(param, "data"):
        return param.data
    return platform.get_param_local_data(param)

def _tensor_data_descriptor():
    """Return the raw Tensor.data descriptor from Tensor or its base classes."""
    for tensor_cls in getattr(Tensor, "__mro__", ()):  # tolerate tests patching Tensor with a mock object
        descriptor = vars(tensor_cls).get("data")
        if descriptor is not None:
            return descriptor
    descriptor = getattr(Tensor, "data", None)
    if descriptor is not None and hasattr(descriptor, "__get__"):
        return descriptor
    raise AttributeError("Tensor.data descriptor is not available")


class DTensorBase(Tensor):
    """torch dtensor base"""

    @property
    # pylint: disable=C2801
    def data(self):
        data_descriptor = _tensor_data_descriptor()
        local_data = data_descriptor.__get__(self._local_tensor, type(self._local_tensor))
        # pylint: disable=C0415
        from hyper_parallel.core.dtensor.dtensor import DTensor
        return DTensor.from_local(
            local_data,
            self._device_mesh,
            self._alias_placements(),
        )

        requires_grad = getattr(self, "requires_grad", None)
        if isinstance(value, DTensorBase):
            local_value = value.to_local()
            if hasattr(value, "device_mesh"):
                self._device_mesh = value.device_mesh
            if hasattr(value, "placements"):
                self._placements = value.placements
            if hasattr(value, "layout"):
                self._layout = value.layout
        else:
            local_value = value
        data_descriptor = _tensor_data_descriptor()
        with getattr(torch, "_C").DisableTorchFunctionSubclass():

        with getattr(torch, "_C").DisableTorchFunctionSubclass():
            data_descriptor.__set__(self, local_value)
            data_descriptor.__set__(self._local_tensor, local_value)
        if requires_grad is not None and hasattr(self, "requires_grad_"):
            self.requires_grad_(requires_grad)

    def numpy(self, *args, **kwargs):
        """Return the local shard as a NumPy array.

        ``dtensor.data.cpu().numpy()``. NumPy has no distributed layout
        inference path; delegate to the local tensor to keep Tensor-like local
        data semantics.
        """
        return self._local_tensor.numpy(*args, **kwargs)

    @property
    def dtype(self) -> torch.dtype:
        """