oneapi-src
diff --git a/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/Jupyter_Run.jpg
-13.6 KB b/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/Jupyter_Run.jpg
-13.6 KB
diff --git a/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/Jupyter_Save_Py.jpg
-34 KB b/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/Jupyter_Save_Py.jpg
-34 KB
diff --git a/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/README.md
+83-75 b/‎AI-and-Analytics/Features-and-Functionality/IntelPython_XGBoost_daal4pyPrediction/README.md
+83-75
@@ -1,131 +1,139 @@
-# `Intel® Python XGBoost daal4py Prediction Sample`
-This sample code illustrates how to analyze the performance benefit of minimal code changes to port pre-trained XGBoost model to daal4py prediction for much faster prediction. It demonstrates how to use software products that can be found in the [Intel® AI Analytics Toolkit (AI Kit)](https://software.intel.com/content/www/us/en/develop/tools/oneapi/ai-analytics-toolkit.html).
+# `Intel® Python XGBoost Daal4py Prediction` Sample
 
-| Optimized for                     | Description
-| :---                              | :---
-| OS                                | 64-bit Linux: Ubuntu 18.04 or higher
-| Hardware                          | Intel Atom® Processors; Intel® Core™ Processor Family; Intel® Xeon® Processor Family; Intel® Xeon® Scalable processor family
-| Software                          | XGBoost, Intel® AI Analytics Toolkit
-| What you will learn               | How to analyze the performance benefit of minimal code changes to port pre-trained XGBoost model to daal4py prediction for much faster prediction
-| Time to complete                  | 5-8 minutes
+This sample code illustrates how to analyze the performance benefit of minimal code changes to port pre-trained XGBoost model to daal4py prediction for much faster prediction. 
+
+| Area                   | Description
+| :---                   | :---
+| What you will learn    | How to analyze the performance benefit of minimal code changes to port pre-trained XGBoost model to daal4py prediction for much faster prediction
+| Time to complete       | 5-8 minutes
+| Category               | Code Optimization
 
 ## Purpose
 
-XGBoost is a widely used gradient boosting library in the classical ML area. Designed for flexibility, performance, and portability, XGBoost includes optimized distributed gradient boosting frameworks and implements Machine Learning algorithms underneath. In addition, daal4py provides functionality to bring even more optimizations to gradient boosting prediction with XGBoost without modifying XGBoost models or learning an additional API.
+This sample illustrates how to analyze the performance benefit of minimal code changes to port pre-trained XGBoost models to Daal4py prediction for much faster prediction.
 
-This sample code illustrates how to analyze the performance benefit of minimal code changes to port pre-trained XGBoost models to daal4py prediction for much faster prediction.
+XGBoost is a widely used gradient boosting library in the classical machine learning (ML) area. Designed for flexibility, performance, and portability, XGBoost includes optimized distributed gradient boosting frameworks and implements Machine Learning algorithms underneath. In addition, Daal4py provides functionality to bring even more optimizations to gradient boosting prediction with XGBoost without modifying XGBoost models or learning an additional API.
 
-In this sample, you will run an XGBoost model with daal4py prediction and XGBoost API prediction to see the performance benefit of daal4py gradient boosting prediction. You will also learn how to port a pre-trained XGBoost model to daal4py prediction.
+## Prerequisites
 
-## Key Implementation Details
-This sample code is implemented for CPU using the Python language. The example assumes you have XGboost and daal4py installed inside a conda environment, similar to what is delivered with the installation of the Intel® Distribution for Python* as part of the [Intel® AI Analytics Toolkit](https://software.intel.com/en-us/oneapi/ai-kit).
+| Optimized for   | Description
+|:---             |:---
+| OS              | Ubuntu* 18.04 or higher
+| Hardware        | Intel Atom® processors <br> Intel® Core™ processor family <br> Intel® Xeon® processor family <br> Intel® Xeon® Scalable processor family
+| Software        | XGBoost model <br> Intel® AI Analytics Toolkit (AI Kit)
 
-## License
-Code samples are licensed under the MIT license. See
-[License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details.
+This sample code is implemented for CPU using the Python language. The sample assumes you have XGboost, Daal4py, and Matplotlib installed inside a conda environment. Installing the Intel® Distribution for Python* as part of the [Intel® AI Analytics Toolkit](https://software.intel.com/en-us/oneapi/ai-kit) should suffice in most cases.
+
+You can refer to the oneAPI [main page](https://software.intel.com/en-us/oneapi) for toolkit installation and the Toolkit [Getting Started Guide for Linux](https://software.intel.com/en-us/get-started-with-intel-oneapi-linux-get-started-with-the-intel-ai-analytics-toolkit) for post-installation steps and scripts.
 
-Third-party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt)
+## Key Implementation Details
 
-## Building XGBoost for CPU
+In this sample, you will run an XGBoost model with Daal4py prediction and XGBoost API prediction to see the performance benefit of Daal4py gradient boosting prediction. You will also learn how to port a pre-trained XGBoost model to Daal4py prediction.
 
 XGBoost* is ready for use once you finish the Intel® AI Analytics Toolkit installation and have run the post installation script.
 
-You can refer to the oneAPI [main page](https://software.intel.com/en-us/oneapi) for toolkit installation and the Toolkit [Getting Started Guide for Linux](https://software.intel.com/en-us/get-started-with-intel-oneapi-linux-get-started-with-the-intel-ai-analytics-toolkit) for post-installation steps and scripts.
+## Set Environment Variables
+
+When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development.
 
+## Run the `Intel® Python XGBoost Daal4py Prediction` Sample
+
+### On Linux*
 
 > **Note**: If you have not already done so, set up your CLI
-> environment by sourcing  the `setvars` script located in
-> the root of your oneAPI installation.
->
-> Linux Sudo: . /opt/intel/oneapi/setvars.sh
+> environment by sourcing  the `setvars` script in the root of your oneAPI installation.
 >
-> Linux User: . ~/intel/oneapi/setvars.sh
+> Linux*:
+> - For system wide installations: `. /opt/intel/oneapi/setvars.sh`
+> - For private installations: ` . ~/intel/oneapi/setvars.sh`
+> - For non-POSIX shells, like csh, use the following command: `bash -c 'source <install-dir>/setvars.sh ; exec csh'`
 >
-> Windows: C:\Program Files(x86)\Intel\oneAPI\setvars.bat
->
->For more information on environment variables, see Use the setvars Script for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html).
-
+> For more information on configuring environment variables, see *[Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html)*.
 
-### Activate conda environment With Root Access
+#### Activate Conda with Root Access
 
-Intel Python environment will be active by default. However, if you activated another environment, you can return with the following command:
+By default, the AI Kit is installed in the `/opt/intel/oneapi` folder and requires root privileges to manage it. However, if you activated another environment, you can return with the following command.
 
-#### On a Linux* System
 ```
 source activate base
 ```
 
-### Activate conda environment Without Root Access (Optional)
+#### Activate Conda without Root Access (Optional)
 
-By default, the Intel® AI Analytics Toolkit is installed in the inteloneapi folder, which requires root privileges to manage it. If you would like to bypass using root access to manage your conda environment, then you can clone your desired conda environment using the following command:
+You can choose to activate Conda environment without root access. To bypass root access to manage your Conda environment, clone and activate your desired Conda environment using the following commands similar to the following.
 
-#### On a Linux* System
 ```
 conda create --name usr_intelpython --clone base
-```
-
-Then activate your conda environment with the following command:
-
-```
 source activate usr_intelpython
 ```
 
-### Install Jupyter Notebook
+#### Install Jupyter Notebook
+
 ```
 conda install jupyter nb_conda_kernels
 ```
 
-#### View in Jupyter Notebook
+#### Open Jupyter Notebook
 
-_Note: This distributed execution cannot be launched from the jupyter notebook version, but you can still view inside the notebook to follow the included write-up and description._
+> **Note**: This distributed sample cannot be executed from the Jupyter Notebook, but you can read the description and follow the program flow in the Notebook.
 
-Launch Jupyter Notebook in the directory housing the code example
+1. Change to the sample directory.
+2. Launch Jupyter Notebook.
+   ```
+   jupyter notebook
+   ```
+3. Locate and select the Notebook.
+   ```
+   IntelPython_XGBoost_daal4pyPrediction.ipynb
+   ```
+4. Click the **Run** button to move through the cells in sequence.
 
-```
-jupyter notebook
-```
+#### Download and Run the Script
 
-## Running the Sample
+1. Still in Jupyter Notebook.
 
-### Running the Sample as a Jupyter Notebook
+2. Select **Download as** > **python (py)**.
 
-Open .ipynb file and run cells in Jupyter Notebook using the "Run" button (see the image using "Modin Getting Started" sample)
+3. Locate the downloaded script.
 
-![Click the Run Button in the Jupyter Notebook](Jupyter_Run.jpg "Run Button on Jupyter Notebook")
+4. Run the script.
+   ```
+   python IntelPython_XGBoost_daal4pyPrediction.py
+   ```
+   When it finishes, you will see two plots: one for prediction time and one for prediction accuracy. You might need to dismiss the first plot to view the second plot.
 
-##### Expected Printed Output for Cells (with similar numbers):
-```
-[CODE_SAMPLE_COMPLETED_SUCCESFULLY]
-```
+## Example Output
 
-### Running the Sample as a Python File
+In addition to the plots for prediction time and prediction accuracy, you should see output similar to the following example.
 
-Open notebook in Jupyter and download as python file (see the image using "daal4py Hello World"  sample)
+```
+XGBoost prediction results (first 10 rows):
+ [4. 2. 2. 2. 3. 1. 3. 4. 3. 4.]
 
-![Download as python file in the Jupyter Notebook](Jupyter_Save_Py.jpg "Download as python file in the Jupyter Notebook")
+daal4py prediction results (first 10 rows):
+ [4. 2. 2. 2. 3. 1. 3. 4. 3. 4.]
 
-Run the Program
+Ground truth (first 10 rows):
+ [4. 2. 2. 2. 3. 1. 3. 4. 3. 4.]
+XGBoost errors count: 10
+XGBoost accuracy score: 0.99
 
-`python IntelPython_XGBoost_Performance.py`
+daal4py errors count: 10
+daal4py accuracy score: 0.99
 
-The output files of the script will be saved in the included models and result directories.
+ XGBoost Prediction Time: 0.03896141052246094
 
-##### Expected Printed Output (with similar numbers):
-```
+ daal4py Prediction Time: 0.10008668899536133
+
+All looks good!
+speedup: 0.3892766452116991
+Accuracy Difference 0.0
 [CODE_SAMPLE_COMPLETED_SUCCESFULLY]
 ```
-### Using Visual Studio Code*  (VS Code)
-
-You can use VS Code extensions to set your environment, create launch configurations,
-and browse and download samples.
 
-The basic steps to build and run a sample using VS Code include:
- - Download a sample using the extension **Code Sample Browser for Intel oneAPI Toolkits**.
- - Configure the oneAPI environment with the extension **Environment Configurator for Intel oneAPI Toolkits**.
- - Open a Terminal in VS Code (**Terminal>New Terminal**).
- - Run the sample in the VS Code terminal using the instructions below.
+## License
 
-To learn more about the extensions and how to configure the oneAPI environment, see
-[Using Visual Studio Code with Intel® oneAPI Toolkits](https://software.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html).
+Code samples are licensed under the MIT license. See
+[License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details.
 
-After learning how to use the extensions for Intel oneAPI Toolkits, return to this readme for instructions on how to build and run a sample.
+Third-party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt).