scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/logistic_regression.py

@@ -0,0 +1,293 @@
+# ==============================================================================
+# Copyright 2023 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 abc import ABCMeta, abstractmethod
+from numbers import Number
+
+import numpy as np
+
+from daal4py.sklearn._utils import daal_check_version, get_dtype, make2d
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
+
+from .._config import _get_config
+from ..common._estimator_checks import _check_is_fitted
+from ..common._mixin import ClassifierMixin
+from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import (
+    _check_array,
+    _check_n_features,
+    _check_X_y,
+    _is_csr,
+    _num_features,
+    _type_of_target,
+)
+
+
+class BaseLogisticRegression(metaclass=ABCMeta):
+    @abstractmethod
+    def __init__(self, tol, C, fit_intercept, solver, max_iter, algorithm):
+        self.tol = tol
+        self.C = C
+        self.fit_intercept = fit_intercept
+        self.solver = solver
+        self.max_iter = max_iter
+        self.algorithm = algorithm
+
+    @abstractmethod
+    def train(self, params, X, y): ...
+
+    @abstractmethod
+    def infer(self, params, X): ...
+
+    # direct access to the backend model constructor
+    @abstractmethod
+    def model(self): ...
+
+    def _get_onedal_params(self, is_csr, dtype=np.float32):
+        intercept = "intercept|" if self.fit_intercept else ""
+        return {
+            "fptype": dtype,
+            "method": "sparse" if is_csr else self.algorithm,
+            "intercept": self.fit_intercept,
+            "tol": self.tol,
+            "max_iter": self.max_iter,
+            "C": self.C,
+            "optimizer": self.solver,
+            "result_option": (
+                intercept
+                + "coefficients|iterations_count"
+                + ("|inner_iterations_count" if self.solver == "newton-cg" else "")
+            ),
+        }
+
+    def _fit(self, X, y):
+        use_raw_input = _get_config()["use_raw_input"] is True
+
+        sparsity_enabled = daal_check_version((2024, "P", 700))
+        if not use_raw_input:
+            X, y = _check_X_y(
+                X,
+                y,
+                accept_sparse=sparsity_enabled,
+                force_all_finite=True,
+                accept_2d_y=False,
+                dtype=[np.float64, np.float32],
+            )
+            if _type_of_target(y) != "binary":
+                raise ValueError("Only binary classification is supported")
+
+            self.classes_, y = np.unique(y, return_inverse=True)
+            y = y.astype(dtype=np.int32)
+        else:
+            _, xp, _ = _get_sycl_namespace(X)
+            # try catch needed for raw_inputs + array_api data where unlike
+            # numpy the way to yield unique values is via `unique_values`
+            # This should be removed when refactored for gpu zero-copy
+            try:
+                self.classes_ = xp.unique(y)
+            except AttributeError:
+                self.classes_ = xp.unique_values(y)
+
+            n_classes = len(self.classes_)
+            if n_classes != 2:
+                raise ValueError("Only binary classification is supported")
+        is_csr = _is_csr(X)
+
+        self.n_features_in_ = _num_features(X, fallback_1d=True)
+        X_table, y_table = to_table(X, y, queue=QM.get_global_queue())
+        params = self._get_onedal_params(is_csr, X_table.dtype)
+
+        result = self.train(params, X_table, y_table)
+
+        self._onedal_model = result.model
+        self.n_iter_ = np.array([result.iterations_count])
+
+        # _n_inner_iter is the total number of cg-solver iterations
+        if daal_check_version((2024, "P", 300)) and self.solver == "newton-cg":
+            self._n_inner_iter = result.inner_iterations_count
+
+        coeff = from_table(result.model.packed_coefficients)
+        self.coef_, self.intercept_ = coeff[:, 1:], coeff[:, 0]
+
+        return self
+
+    def _create_model(self):
+        m = self.model()
+
+        coefficients = self.coef_
+        dtype = get_dtype(coefficients)
+        coefficients = np.asarray(coefficients, dtype=dtype)
+
+        if coefficients.ndim == 2:
+            n_features_in = coefficients.shape[1]
+            assert coefficients.shape[0] == 1
+        else:
+            n_features_in = coefficients.size
+
+        intercept = self.intercept_
+        if not isinstance(intercept, Number):
+            intercept = np.asarray(intercept, dtype=dtype)
+            assert intercept.size == 1
+
+        intercept = _check_array(
+            intercept,
+            dtype=[np.float64, np.float32],
+            force_all_finite=True,
+            ensure_2d=False,
+        )
+        coefficients = _check_array(
+            coefficients,
+            dtype=[np.float64, np.float32],
+            force_all_finite=True,
+            ensure_2d=False,
+        )
+
+        coefficients, intercept = make2d(coefficients), make2d(intercept)
+
+        assert coefficients.shape == (1, n_features_in)
+        assert intercept.shape == (1, 1)
+
+        desired_shape = (1, n_features_in + 1)
+        packed_coefficients = np.zeros(desired_shape, dtype=dtype)
+
+        packed_coefficients[:, 1:] = coefficients
+        if self.fit_intercept:
+            packed_coefficients[:, 0][:, np.newaxis] = intercept
+
+        m.packed_coefficients = to_table(packed_coefficients, queue=QM.get_global_queue())
+
+        self._onedal_model = m
+
+        return m
+
+    def _infer(self, X):
+        _check_is_fitted(self)
+
+        sparsity_enabled = daal_check_version((2024, "P", 700))
+
+        if not _get_config()["use_raw_input"]:
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                accept_sparse=sparsity_enabled,
+                force_all_finite=True,
+                ensure_2d=False,
+                accept_large_sparse=sparsity_enabled,
+            )
+        is_csr = _is_csr(X)
+        _check_n_features(self, X, False)
+
+        X = make2d(X)
+
+        if hasattr(self, "_onedal_model"):
+            model = self._onedal_model
+        else:
+            model = self._create_model()
+
+        X_table = to_table(X, queue=QM.get_global_queue())
+        params = self._get_onedal_params(is_csr, X.dtype)
+
+        result = self.infer(params, model, X_table)
+        return result
+
+    def _predict(self, X):
+        result = self._infer(X)
+        _, xp, _ = _get_sycl_namespace(X)
+        y = from_table(result.responses, like=X)
+        y = xp.take(xp.asarray(self.classes_), xp.reshape(y, (-1,)), axis=0)
+        return y
+
+    def _predict_proba(self, X):
+        result = self._infer(X)
+        _, xp, _ = _get_sycl_namespace(X)
+        y = from_table(result.probabilities, like=X)
+        y = xp.reshape(y, -1)
+        return xp.stack([1 - y, y], axis=1)
+
+    def _predict_log_proba(self, X):
+        _, xp, _ = _get_sycl_namespace(X)
+        y_proba = self._predict_proba(X)
+        # These are the same thresholds used by oneDAL during the model fitting procedure
+        if y_proba.dtype == np.float32:
+            min_prob = 1e-7
+            max_prob = 1.0 - 1e-7
+        else:
+            min_prob = 1e-15
+            max_prob = 1.0 - 1e-15
+        y_proba = xp.clip(y_proba, min_prob, max_prob)
+        return xp.log(y_proba)
+
+    def _decision_function(self, X):
+        _, xp, _ = _get_sycl_namespace(X)
+        raw = xp.matmul(X, xp.reshape(self.coef_, -1))
+        if self.fit_intercept:
+            raw += self.intercept_
+        return raw
+
+
+class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
+
+    def __init__(
+        self,
+        tol=1e-4,
+        C=1.0,
+        fit_intercept=True,
+        solver="newton-cg",
+        max_iter=100,
+        *,
+        algorithm="dense_batch",
+        **kwargs,
+    ):
+        super().__init__(
+            tol=tol,
+            C=C,
+            fit_intercept=fit_intercept,
+            solver=solver,
+            max_iter=max_iter,
+            algorithm=algorithm,
+        )
+
+    @bind_default_backend("logistic_regression.classification")
+    def train(self, params, X, y, queue=None): ...
+
+    @bind_default_backend("logistic_regression.classification")
+    def infer(self, params, X, model, queue=None): ...
+
+    @bind_default_backend("logistic_regression.classification")
+    def model(self): ...
+
+    @supports_queue
+    def fit(self, X, y, queue=None):
+        return self._fit(X, y)
+
+    @supports_queue
+    def predict(self, X, queue=None):
+        return self._predict(X)
+
+    @supports_queue
+    def predict_proba(self, X, queue=None):
+        return self._predict_proba(X)
+
+    @supports_queue
+    def predict_log_proba(self, X, queue=None):
+        return self._predict_log_proba(X)
+
+    @supports_queue
+    def decision_function(self, X, queue=None):
+        return self._decision_function(X)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/tests/test_incremental_linear_regression.py

@@ -0,0 +1,213 @@
+# ==============================================================================
+# Copyright 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.
+# ==============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from sklearn.datasets import load_diabetes
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+
+from onedal.datatypes import from_table
+from onedal.linear_model import IncrementalLinearRegression
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_diabetes(queue, dtype):
+    X, y = load_diabetes(return_X_y=True)
+    X, y = X.astype(dtype), y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, train_size=0.8, random_state=777
+    )
+    X_train_split = np.array_split(X_train, 2)
+    y_train_split = np.array_split(y_train, 2)
+    model = IncrementalLinearRegression(fit_intercept=True)
+    for i in range(2):
+        model.partial_fit(X_train_split[i], y_train_split[i], queue=queue)
+    model.finalize_fit()
+    y_pred = model.predict(X_test, queue=queue)
+    assert mean_squared_error(y_test, y_pred) < 2396
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_blocks", [1, 2, 10])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_full_results(queue, num_blocks, dtype):
+    seed = 42
+    num_features, num_targets = 19, 7
+    num_samples_train, num_samples_test = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=num_targets, dtype=dtype)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples_train, num_features), dtype=dtype)
+    y = X @ coef + intercept[np.newaxis, :]
+    X_split = np.array_split(X, num_blocks)
+    y_split = np.array_split(y, num_blocks)
+
+    model = IncrementalLinearRegression(fit_intercept=True)
+    for i in range(num_blocks):
+        model.partial_fit(X_split[i], y_split[i], queue=queue)
+    model.finalize_fit()
+
+    if queue and queue.sycl_device.is_gpu:
+        tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
+    else:
+        tol = 3e-3 if model.coef_.dtype == np.float32 else 1e-5
+    atol = 1e-4 if model.coef_.dtype == np.float32 else 1e-6
+    assert_allclose(coef, model.coef_.T, rtol=tol, atol=atol)
+
+    tol = 3e-3 if model.intercept_.dtype == np.float32 else 1e-5
+    assert_allclose(intercept, model.intercept_, rtol=tol)
+
+    Xt = gen.random(size=(num_samples_test, num_features), dtype=dtype)
+    gtr = Xt @ coef + intercept[np.newaxis, :]
+
+    res = model.predict(Xt, queue=queue)
+
+    tol = 2e-4 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_blocks", [1, 2, 10])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_no_intercept_results(queue, num_blocks, dtype):
+    seed = 42
+    num_features, num_targets = 19, 7
+    num_samples_train, num_samples_test = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples_train, num_features), dtype=dtype)
+    y = X @ coef
+
+    X_split = np.array_split(X, num_blocks)
+    y_split = np.array_split(y, num_blocks)
+
+    model = IncrementalLinearRegression(fit_intercept=False)
+    for i in range(num_blocks):
+        model.partial_fit(X_split[i], y_split[i], queue=queue)
+    model.finalize_fit()
+
+    # TODO Find out is it necessary to have accuracy so different for float32 and float64
+    if queue and queue.sycl_device.is_gpu:
+        tol = 3e-3 if model.coef_.dtype == np.float32 else 1e-7
+    else:
+        tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-7
+    assert_allclose(coef, model.coef_.T, rtol=tol)
+
+    Xt = gen.random(size=(num_samples_test, num_features), dtype=dtype)
+    gtr = Xt @ coef
+
+    res = model.predict(Xt, queue=queue)
+
+    tol = 5e-5 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_reconstruct_model(queue, dtype):
+    seed = 42
+    num_samples = 3500
+    num_features, num_targets = 14, 9
+
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=num_targets, dtype=dtype)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples, num_features), dtype=dtype)
+    gtr = X @ coef + intercept[np.newaxis, :]
+
+    model = IncrementalLinearRegression(fit_intercept=True)
+    model.coef_ = coef.T
+    model.intercept_ = intercept
+
+    res = model.predict(X, queue=queue)
+
+    tol = 1e-5 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.linear_model import IncrementalLinearRegression
+
+    inclr = IncrementalLinearRegression()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inclr)
+    inclr_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    coef = gen.random(size=(1, 10), dtype=dtype).T
+    y = X @ coef
+    X_split = np.array_split(X, 2)
+    y_split = np.array_split(y, 2)
+    inclr.partial_fit(X_split[0], y_split[0], queue=queue)
+    inclr_loaded.partial_fit(X_split[0], y_split[0], queue=queue)
+
+    # inclr.finalize_fit()
+
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inclr)
+    inclr_loaded = pickle.loads(dump)
+
+    partial_xtx = from_table(inclr._partial_result.partial_xtx)
+    partial_xtx_loaded = from_table(inclr_loaded._partial_result.partial_xtx)
+    assert_allclose(partial_xtx, partial_xtx_loaded)
+
+    partial_xty = from_table(inclr._partial_result.partial_xty)
+    partial_xty_loaded = from_table(inclr_loaded._partial_result.partial_xty)
+    assert_allclose(partial_xty, partial_xty_loaded)
+
+    assert inclr._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert inclr_loaded._need_to_finalize == False
+
+    inclr.partial_fit(X_split[1], y_split[1], queue=queue)
+    inclr_loaded.partial_fit(X_split[1], y_split[1], queue=queue)
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(inclr_loaded)
+    inclr_loaded = pickle.loads(dump)
+
+    assert inclr._need_to_finalize == True
+    assert inclr_loaded._need_to_finalize == False
+
+    inclr.finalize_fit()
+    inclr_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inclr_loaded)
+    inclr_loaded = pickle.loads(dump)
+
+    assert_allclose(inclr.coef_, inclr_loaded.coef_, atol=1e-6)
+    assert_allclose(inclr.intercept_, inclr_loaded.intercept_, atol=1e-6)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/tests/test_incremental_ridge_regression.py

@@ -0,0 +1,171 @@
+# ==============================================================================
+# Copyright 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 daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2024, "P", 600)):
+    import numpy as np
+    import pytest
+    from numpy.testing import assert_allclose, assert_array_equal
+    from sklearn.datasets import load_diabetes
+    from sklearn.metrics import mean_squared_error
+    from sklearn.model_selection import train_test_split
+
+    from onedal.datatypes import from_table
+    from onedal.linear_model import IncrementalRidge
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_diabetes(queue, dtype):
+        X, y = load_diabetes(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, train_size=0.8, random_state=777
+        )
+        X_train_split = np.array_split(X_train, 2)
+        y_train_split = np.array_split(y_train, 2)
+        model = IncrementalRidge(fit_intercept=True, alpha=0.1)
+        for i in range(2):
+            model.partial_fit(X_train_split[i], y_train_split[i], queue=queue)
+        model.finalize_fit()
+        y_pred = model.predict(X_test, queue=queue)
+        assert_allclose(mean_squared_error(y_test, y_pred), 2388.775, rtol=1e-5)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.skip(reason="pickling not implemented for oneDAL entities")
+    def test_pickle(queue, dtype):
+        # TODO Implement pickling for oneDAL entities
+        X, y = load_diabetes(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        model = IncrementalRidge(fit_intercept=True, alpha=0.5)
+        model.partial_fit(X, y, queue=queue)
+        model.finalize_fit()
+        expected = model.predict(X, queue=queue)
+
+        import pickle
+
+        dump = pickle.dumps(model)
+        model2 = pickle.loads(dump)
+
+        assert isinstance(model2, model.__class__)
+        result = model2.predict(X, queue=queue)
+
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("num_blocks", [1, 2, 10])
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_no_intercept_results(queue, num_blocks, dtype):
+        seed = 42
+        n_features, n_targets = 19, 7
+        n_train_samples, n_test_samples = 3500, 1999
+
+        gen = np.random.default_rng(seed)
+
+        X = gen.random(size=(n_train_samples, n_features), dtype=dtype)
+        y = gen.random(size=(n_train_samples, n_targets), dtype=dtype)
+        X_split = np.array_split(X, num_blocks)
+        y_split = np.array_split(y, num_blocks)
+        alpha = 0.5
+
+        lambda_identity = alpha * np.eye(X.shape[1])
+        inverse_term = np.linalg.inv(np.dot(X.T, X) + lambda_identity)
+        xt_y = np.dot(X.T, y)
+        coef = np.dot(inverse_term, xt_y)
+
+        model = IncrementalRidge(fit_intercept=False, alpha=alpha)
+        for i in range(num_blocks):
+            model.partial_fit(X_split[i], y_split[i], queue=queue)
+        model.finalize_fit()
+
+        if queue and queue.sycl_device.is_gpu:
+            tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
+        else:
+            tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-5
+        assert_allclose(coef, model.coef_.T, rtol=tol)
+
+        Xt = gen.random(size=(n_test_samples, n_features), dtype=dtype)
+        gtr = Xt @ coef
+
+        res = model.predict(Xt, queue=queue)
+
+        tol = 2e-4 if res.dtype == np.float32 else 1e-7
+        assert_allclose(gtr, res, rtol=tol)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_incremental_estimator_pickle(queue, dtype):
+        import pickle
+
+        model = IncrementalRidge()
+
+        # Check that estimator can be serialized without any data.
+        dump = pickle.dumps(model)
+        model_loaded = pickle.loads(dump)
+        seed = 77
+        gen = np.random.default_rng(seed)
+        X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+        X = X.astype(dtype)
+        coef = gen.random(size=(1, 10), dtype=dtype).T
+        y = X @ coef
+        X_split = np.array_split(X, 2)
+        y_split = np.array_split(y, 2)
+        model.partial_fit(X_split[0], y_split[0], queue=queue)
+        model_loaded.partial_fit(X_split[0], y_split[0], queue=queue)
+
+        # model.finalize_fit()
+
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == True
+
+        # Check that estimator can be serialized after partial_fit call.
+        dump = pickle.dumps(model)
+        model_loaded = pickle.loads(dump)
+
+        partial_xtx = from_table(model._partial_result.partial_xtx)
+        partial_xtx_loaded = from_table(model_loaded._partial_result.partial_xtx)
+        assert_allclose(partial_xtx, partial_xtx_loaded)
+
+        partial_xty = from_table(model._partial_result.partial_xty)
+        partial_xty_loaded = from_table(model_loaded._partial_result.partial_xty)
+        assert_allclose(partial_xty, partial_xty_loaded)
+
+        assert model._need_to_finalize == False
+        # Finalize is called during serialization to make sure partial results are finalized correctly.
+        assert model_loaded._need_to_finalize == False
+
+        model.partial_fit(X_split[1], y_split[1], queue=queue)
+        model_loaded.partial_fit(X_split[1], y_split[1], queue=queue)
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == True
+
+        dump = pickle.dumps(model_loaded)
+        model_loaded = pickle.loads(dump)
+
+        assert model._need_to_finalize == True
+        assert model_loaded._need_to_finalize == False
+
+        model.finalize_fit()
+        model_loaded.finalize_fit()
+
+        # Check that finalized estimator can be serialized.
+        dump = pickle.dumps(model_loaded)
+        model_loaded = pickle.loads(dump)
+
+        assert_allclose(model.coef_, model_loaded.coef_, atol=1e-6)
+        assert_allclose(model.intercept_, model_loaded.intercept_, atol=1e-6)