[doc] Update daal4py

doc/daal4py/_templates/layout.html

@@ -0,0 +1,17 @@
+{% extends "!layout.html" %}
+{% block extrahead %}
+    <script defer type="text/javascript" src="https://www.intel.com/content/dam/www/global/wap/performance-config.js" ></script>
+    <script type="text/javascript">
+        // Configure TMS settings
+        var wapLocalCode = 'us-en'; // Dynamically set per localized site, see mapping table for values
+        var wapSection = "scikit-learn"; // WAP team will give you a unique section for your site
+        // Load TMS
+        if(document.location.href.contains("intel.github.io/scikit-learn-intelex")){
+          (function () {
+            var url = 'https://www.intel.com/content/dam/www/global/wap/tms-loader.js'; // WAP file URL
+            var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true; po.src = url;
+            var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
+          })();
+      }
+      </script>
+{% endblock %}

doc/daal4py/algorithms.rst

@@ -18,6 +18,8 @@
 Algorithms
 ##########
 
+.. include:: note.rst
+
 Classification
 --------------
 See also |onedal-dg-classification|_.

doc/daal4py/conf.py

@@ -37,7 +37,7 @@
 # -- Project information -----------------------------------------------------
 
 project = 'daal4py'
-copyright = '2021, Intel'
+copyright = 'Intel'
 author = 'Intel'
 
 # The short X.Y version
@@ -80,7 +80,7 @@
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -200,3 +200,7 @@
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = True
+
+exclude_patterns = exclude_patterns + [
+"note.rst"
+]

doc/daal4py/contents.rst

@@ -19,6 +19,9 @@
 ########
 Contents
 ########
+
+.. include:: note.rst
+
 .. toctree::
    :maxdepth: 2
    :caption: Contents:

doc/daal4py/data.rst

@@ -19,6 +19,9 @@
 ##########
 Input Data
 ##########
+
+.. include:: note.rst
+
 All array arguments to compute functions and to algorithm constructors can be
 provided in different formats. daal4py will automatically do its best to work on
 the provided data with minimal overhead, most notably without copying the data.

doc/daal4py/examples.rst

@@ -18,6 +18,8 @@
 Examples
 ##########
 
+.. include:: note.rst
+
 Below are examples on how to utilize daal4py for various usage styles.
 
 General usage

doc/daal4py/index.rst

@@ -19,6 +19,9 @@
 #####################################################
 Fast, Scalable and Easy Machine Learning With DAAL4PY
 #####################################################
+
+.. include:: note.rst
+
 Daal4py makes your Machine Learning algorithms in Python lightning fast and easy to use. It provides
 highly configurable Machine Learning kernels, some of which support streaming input data and/or can
 be easily and efficiently scaled out to clusters of workstations.  Internally it uses Intel(R)

doc/daal4py/model-builders.rst

@@ -19,64 +19,69 @@
 ###############################################
 Model Builders for the Gradient Boosting Frameworks
 ###############################################
+
+.. include:: note.rst
+
 Introduction
 ------------------
 Gradient boosting on decision trees is one of the most accurate and efficient 
 machine learning algorithms for classification and regression. 
-The most popular implementations of it are the XGBoost*, 
-LightGBM*, and CatBoost* frameworks.
+The most popular implementations of it are: 
+
+* XGBoost*
+* LightGBM*
+* CatBoost*
+
 daal4py Model Builders deliver the accelerated
 models inference of those frameworks. The inference is performed by the oneDAL GBT implementation tuned 
 for the best performance on the Intel(R) Architecture. 
 
 Conversion
 ---------
-The first step is to convert already trained model. There are similar 
-APIs for different frameworks. 
+The first step is to convert already trained model. The
+API usage for different frameworks is the same:
+
 XGBoost::
 
   import daal4py as d4p
-  d4p_model = d4p.get_gbt_model_from_xgboost(xgb_model)
+  d4p_model = d4p.mb.convert_model(xgb_model)
 
 LightGBM::
 
   import daal4py as d4p
-  d4p_model = d4p.get_gbt_model_from_lightgbm(lgb_model)
+  d4p_model = d4p.mb.convert_model(lgb_model)
 
 CatBoost::
 
   import daal4py as d4p
-  d4p_model = d4p.get_gbt_model_from_catboost(cb_model)
+  d4p_model = d4p.mb.convert_model(cb_model)
 
 .. note:: Convert model only once and then use it for the inference.
 
 Classification and Regression Inference
----------
-GBT implementation in daal4py assumes separate APIs for the classification and regression.
-Specify the corresponding API and match the corresponding problem 
-in the initial framework.
-
-Classification::
+----------------------------------------
 
-    d4p_cls_algo = d4p.gbt_classification_prediction(
-        nClasses=params['classes_count'],
-        resultsToEvaluate="computeClassLabels",
-        fptype='float'
-    )
+The API is the same for classification and regression inference. 
+Based on the original model passed to the ``convert_model``, ``daal_prediction`` is either the classification or regression output. 
+
+    ::
+
+      daal_prediction = daal_model.predict(test_data)
 
-Regression::
-    d4p_reg_algo = d4p.gbt_regression_prediction()
+Here, the ``predict()`` method of ``daal_model`` is being used to make predictions on the ``test_data`` dataset.
+The ``daal_prediction``variable stores the predictions made by the ``predict()`` method. 
 
-Next, daal4py algorithm object needs compute method to be called. 
-Both the data and the previously converted model should be passed with the results of the prediction 
-available within the  ``.prediction`` parameter.
+Scikit-learn-style Estimators
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Compute::
+You can also use the scikit-learn-style classes ``GBTDAALClassifier`` and ``GBTDAALRegressor`` to convert and infer your models. For example:
 
-    d4p_predictions = d4p_reg_algo.compute(X_test, d4p_model).prediction
+:: 
 
-The one-line variant of the same code::
-    d4p_prediction = d4p.gbt_regression_prediction().compute(X_test, d4p_model).prediction
+  from daal4py.sklearn.ensemble import GBTDAALRegressor
+  reg = xgb.XGBRegressor()
+  reg.fit(X, y)
+  d4p_predt = GBTDAALRegressor.convert_model(reg).predict(X)
 
 
 Limitations
@@ -97,4 +102,4 @@ Model Builders models conversion
 Articles and Blog Posts
 ---------------------------------
 
--  `Improving the Performance of XGBoost and LightGBM Inference <https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e>` _
+-  `Improving the Performance of XGBoost and LightGBM Inference <https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e>`_

doc/daal4py/note.rst

@@ -0,0 +1,4 @@
+.. _note:
+
+.. note:: Scikit-learn patching functionality in daal4py was deprecated and moved to a separate package, `Intel(R) Extension for Scikit-learn* <https://github.com/intel/scikit-learn-intelex>`_. 
+                All future patches will be available only in Intel(R) Extension for Scikit-learn*. Use the scikit-learn-intelex package instead of daal4py for the scikit-learn acceleration.

doc/daal4py/scaling.rst

@@ -19,6 +19,9 @@
 ###############################################
 Scaling on Distributed Memory (Multiprocessing)
 ###############################################
+
+.. include:: note.rst
+
 It's Easy
 ---------
 daal4py operates in SPMD style (Single Program Multiple Data), which means your

doc/daal4py/sklearn.rst

@@ -20,6 +20,7 @@
 Scikit-Learn API and patching
 #############################
 
+
 Python interface to efficient Intel(R) oneAPI Data Analytics Library provided by daal4py allows one
 to create scikit-learn compatible estimators, transformers, clusterers, etc. powered by oneDAL which
 are nearly as efficient as native programs.

doc/daal4py/streaming.rst

@@ -19,6 +19,9 @@
 ##############
 Streaming Data
 ##############
+
+.. include:: note.rst
+
 For large quantities of data it might be impossible to provide all input data at
 once. This might be because the data resides in multiple files and merging it is
 to costly (or not feasible in other ways). In other cases the data is simply too