{"id":13574454,"url":"https://github.com/oneapi-src/purchase-prediction","last_synced_at":"2025-04-04T15:31:03.398Z","repository":{"id":63299334,"uuid":"560595329","full_name":"oneapi-src/purchase-prediction","owner":"oneapi-src","description":"AI Starter Kit for Purchase Prediction model using Intel® Extension for Scikit-learn*","archived":true,"fork":false,"pushed_at":"2024-02-08T23:17:29.000Z","size":689,"stargazers_count":3,"open_issues_count":0,"forks_count":5,"subscribers_count":4,"default_branch":"main","last_synced_at":"2024-11-05T09:44:38.756Z","etag":null,"topics":["machine-learning","scikit-learn"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"bsd-3-clause","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/oneapi-src.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-11-01T20:55:27.000Z","updated_at":"2024-04-08T18:26:01.000Z","dependencies_parsed_at":"2024-11-05T09:44:26.634Z","dependency_job_id":null,"html_url":"https://github.com/oneapi-src/purchase-prediction","commit_stats":null,"previous_names":[],"tags_count":2,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oneapi-src%2Fpurchase-prediction","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oneapi-src%2Fpurchase-prediction/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oneapi-src%2Fpurchase-prediction/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oneapi-src%2Fpurchase-prediction/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/oneapi-src","download_url":"https://codeload.github.com/oneapi-src/purchase-prediction/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247202648,"owners_count":20900822,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["machine-learning","scikit-learn"],"created_at":"2024-08-01T15:00:51.748Z","updated_at":"2025-04-04T15:30:58.380Z","avatar_url":"https://github.com/oneapi-src.png","language":"Python","readme":"PROJECT NOT UNDER ACTIVE MANAGEMENT\n\nThis project will no longer be maintained by Intel.\n\nIntel has ceased development and contributions including, but not limited to, maintenance, bug fixes, new releases, or updates, to this project.  \n\nIntel no longer accepts patches to this project.\n\nIf you have an ongoing need to use this project, are interested in independently developing it, or would like to maintain patches for the open source software community, please create your own fork of this project.  \n\nContact: webadmin@linux.intel.com\n# **Purchase Prediction**\r\n\r\n## Introduction\r\nMany retailers are trapped in the death spiral of never-ending sales designed to “buy” customers with deals. This vicious cycle of price slashing is not sustainable. Retail profit margins are razor thin as it is. More worryingly, as much as five percent of their customer base typically is loss-making because these customers are so adept at using discounts, promotions and returning items. To overcome this issue, Machine Learning (ML) is utilized to understand and optimize complex, multi-touch customer journeys, products and services. Core customer-centric use cases should enable purchase prediction modeling.\r\n\r\nThis example creates an end-to-end Machine Learning solution to build a deeper understanding of customer segments based on historical purchases, which can be further used to implement operational and product marketing strategies. It also describes how we can leverage the [Intel® Distribution for Python*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html#gs.52te4z) and [Intel® Extension for Scikit-Learn*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/scikit-learn.html) to accelerate the pipeline. This distribution and extension are part of the [Intel® oneAPI AI Analytics Toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/ai-analytics-toolkit.html), which gives data scientists, AI developers, and researchers familiar Python tools and frameworks to accelerate end-to-end data science and analytics pipelines on Intel® architectures. Check out more workflow examples in the [Developer Catalog](https://developer.intel.com/aireferenceimplementations).\r\n\r\n## Solution Technical Overview\r\nOne important aspect of purchase prediction for a new customer is to map them to a segment with similar customer purchase history. In this reference kit, we build a Machine Learning model based on the historic details of various customer purchases on different time frames to predict if a customer belongs to a certain segment. This would help the retail business to devise their operational and product marketing strategies based on real data when a customer comes back on the channel next time. \r\n\r\nOne of the primary methods for deriving an understanding of how we can accomplish this is by analyzing and exploring different AI based Machine Learning algorithms on various feature sets to categorize the customers to appropriate segments.\r\n\r\nThe reference kit explores ways to have:\r\n- Faster model development that helps in building purchase prediction models\r\n- Performance efficient purchase prediction mechanisms\r\n\r\nThis Reference Solution approach involves clustering of data in the initial analysis to create the product categories, unsupervised Machine Learning technique (K-Means) is used for this. We also need to create and predict the customer segment based on their purchase which is solved as a classification problem. A K-Means model is used again for the creation of customer segments. The benchmarking is done only for the classifier models involved in predicting the next purchase date with the features of known product categories and customer segments from their product purchase history. For this, multiple below classifiers algorithms are analyzed:\r\n- K-Nearest Neighbor\r\n- Decision Tree\r\n- Random Forest\r\n\r\n![image](assets/e2e_flow_2024.png)\r\n\r\nThe use case extends to demonstrate the advantages of using the Intel® oneAPI AI Analytics Toolkit on the task of building a targeted understanding of customer characteristics from purchase data. The savings gained from using the Intel® Extension for Scikit-learn can lead an analyst to more efficiently explore and understand customer archetypes, leading to better and more precise targeted solutions.\r\n\r\nThe solution contained in this repo uses the following Intel® packages:\r\n\r\n* ***Intel® Distribution for Python\\****\r\n\r\n    The [Intel® Distribution for Python*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html#gs.52te4z) provides:\r\n    * Scalable performance using all available CPU cores on laptops, desktops, and powerful servers\r\n    * Support for the latest CPU instructions\r\n    * Near-native performance through acceleration of core numerical and machine learning packages with libraries like the Intel® oneAPI Math Kernel Library (oneMKL) and Intel® oneAPI Data Analytics Library\r\n    * Productivity tools for compiling Python code into optimized instructions\r\n    * Essential Python bindings for easing integration of Intel® native tools with your Python* project\r\n\r\n* ***Intel® Extension for Scikit-learn\\****\r\n\r\n    Designed for data scientists, [Intel® Extension for Scikit-Learn*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/scikit-learn.html) is a seamless way to speed up your Scikit-learn applications for machine learning to solve real-world problems This extension package dynamically patches scikit-learn estimators to use Intel® oneAPI Data Analytics Library (oneDAL) as the underlying solver, while achieving the speed up for your machine learning algorithms out-of-box.\r\n\r\nFor more details, visit [Intel® Distribution for Python*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html), [Intel® Extension for Scikit-Learn*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/scikit-learn.html) and [Purchase Prediction](https://github.com/oneapi-src/purchase-prediction).\r\n\r\n## Solution Technical Details\r\nIn this section, we describe the data and how to replicate the results.\r\n\r\n### ***Dataset***\r\nThe reference kit uses data from https://archive-beta.ics.uci.edu/ml/datasets/online+retail \r\n\r\n\u003e *Please see this dataset's applicable license for terms and conditions. Intel® does not own the rights to this dataset and does not confer any rights to it.*\r\n\r\nThe dimension of the dataset is (541909, 8). Each record in the dataset represents purchase details of the product made by a customer with below eight features:\r\n- InvoiceNo: Purchase Invoice Number\r\n- StockCode: Product Stock Code\r\n- Description: Product Description\r\n- Quantity: Purchased Quantity\r\n- InvoiceDate: Purchase Date\r\n- UnitPrice: Unit price of the product\r\n- CustomerID: Unique Customer ID\r\n- Country: Country of the purchase\r\n\r\nAt first, the above features are used to create unique categories of products from the product stock code and product description corpus. Once the product categories are identified, every invoice purchase is re-arranged to include the category of the products bought. Based on the categories of the product the customer segmentation is created. Based on these categorical features (Product Category and Customer Segmentation) multiple classification models are developed that allow to predict when the next purchases will take place by a customer. This will allow retailers to provide offers only for the predicted purchase date. This process can be shown as:\r\n\r\n**Raw Inputs**                                 | **Inputs**                                 | **Output** |\r\n| :---: | :---: | :---: |\r\n| `[InvoiceNo,StockCode,Description,Quantity,InvoiceDate,UnitPrice,CustomerID,Country]`          | `[mean,categ_0,categ_1,categ_2,categ_3,categ_4,FirstPurchase,cluster]`          | `[LastPurchase]`\r\n\r\n### ***Hyperparameter Analysis***\r\nIn realistic scenarios, an analyst will run the same Machine Learning algorithm multiple times on the same dataset, scanning across different hyperparameters.  To capture this, we measure the total amount of time it takes to generate results across a grid of hyperparameters for a fixed algorithm, which we define as hyperparameter analysis.  In practice, the results of each hyperparameter analysis provides the analyst with many different customer segments and purchase predictions that they can take and further analyze.\r\n\r\nThe below table provides details about the hyperparameters \u0026 values used for hyperparameter tuning for each of the algorithms used in our benchmarking experiments:\r\n| **Algorithm**                     | **Hyperparameters**\r\n| :---                              | :---\r\n| kNN                               | `space or parameters = pd.np.arange(1, 50, 1) ,`\u003cbr\u003e `cross validation generator = 5 ,` \u003cbr\u003e `n_jobs=-1` \u003cbr\u003e\r\n| Decision Tree Classifier          | `criterion = ['entropy', 'gini'] ,` \u003cbr\u003e `'max_features' = ['sqrt', 'log2']` \u003cbr\u003e\r\n| Random Forest Classifier          | `criterion = ['gini'] ,` \u003cbr\u003e `'n_estimators' =[20, 40, 60, 80, 100],` \u003cbr\u003e `'max_features' = ['sqrt', 'log2']` \u003cbr\u003e\r\n\r\n## Validated Hardware Details\r\nThere are workflow-specific hardware and software setup requirements to run this use case.\r\n\r\n| Recommended Hardware\r\n| ----------------------------\r\n| CPU: Intel® 2nd Gen Xeon® Platinum 8280 CPU @ 2.70GHz or higher\r\n| RAM: 187 GB\r\n| Recommended Free Disk Space: 20 GB or more\r\n\r\n#### Minimal Requirements\r\n* RAM: 64 GB total memory\r\n* CPUs: 8\r\n* Storage: 20GB\r\n* Operating system: Ubuntu\\* 22.04 LTS\r\n\r\n## How it Works\r\nThe included code demonstrates a complete framework for:\r\n1. Setting up a virtual environment for Intel®-accelerated ML.\r\n2. Preprocessing data using Pandas and NLTK*.\r\n3. Clustering data to create product categories using Intel® Extension for Scikit-learn*.\r\n3. Training a kNN, Decision Tree or Random Forest Classifier model for purchase prediction using Intel® Extension for Scikit-learn*.\r\n4. Predicting from the trained model on new data using Intel® Extension for Scikit-learn*.\r\n\r\n## Get Started\r\nStart by defining environment variables that will store the workspace, dataset and output paths. These directories will be used for all the commands executed using absolute paths.\r\n\r\n[//]: # (capture: baremetal)\r\n```bash\r\nexport WORKSPACE=$PWD/purchase-prediction\r\nexport DATA_DIR=$WORKSPACE/data\r\nexport OUTPUT_DIR=$WORKSPACE/output\r\n```\r\n\r\n### Download the Workflow Repository\r\nCreate a working directory for the workflow and clone the [Purchase Prediction](https://github.com/oneapi-src/purchase-prediction) repository into your working directory.\r\n\r\n[//]: # (capture: baremetal)\r\n```bash\r\nmkdir -p $WORKSPACE \u0026\u0026 cd $WORKSPACE\r\n```\r\n\r\n```bash\r\ngit clone https://github.com/oneapi-src/purchase-prediction.git $WORKSPACE\r\n```\r\n\r\n[//]: # (capture: baremetal)\r\n```bash\r\nmkdir -p $DATA_DIR $OUTPUT_DIR\r\nmkdir $OUTPUT_DIR/models $OUTPUT_DIR/logs\r\n```\r\n\r\n### Set Up Conda\r\nTo learn more, please visit [install anaconda on Linux](https://docs.anaconda.com/free/anaconda/install/linux/). \r\n```bash\r\nwget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh\r\nbash Miniconda3-latest-Linux-x86_64.sh\r\nrm Miniconda3-latest-Linux-x86_64.sh\r\n```\r\n\r\n### Set Up Environment\r\nInstall and set the libmamba solver as default solver. Do this by running the following commands:\r\n\r\n```bash\r\nconda install -n base conda-libmamba-solver -y\r\nconda config --set solver libmamba\r\n```\r\n\r\nThe `$WORKSPACE/env/intel_env.yml` file contains all dependencies to create the intel environment necesary for runnig the workflow. \r\n\r\n| **Packages required in YAML file:**                 | **Version:**\r\n| :---                          | :--\r\n| `python`  | 3.10\r\n| `intelpython3_core`  | 2024.0.0\r\n| `scikit-learn-intelex`  | 2024.0.0\r\n| `pandas`  | 2.1.3\r\n| `nltk`  | 3.8.1\r\n| `xlsx2csv`  | 0.8.1\r\n\r\nExecute next command to create the conda environment.\r\n\r\n```bash\r\nconda env create -f $WORKSPACE/env/intel_env.yml\r\n```\r\n\r\nEnvironment setup is required only once. This step does not cleanup the existing environment with the same name; make sure no conda environment exists with the same name. During this setup a new conda environment will be created with the dependencies listed in the YAML configuration.\r\n\r\nOnce the appropriate environment is created with the previous step then it has to be activated using the conda command as given below:\r\n```bash\r\nconda activate purchase_prediction_intel\r\n```\r\n\r\n### Download the Dataset\r\nExecute the below commands to download the dataset and convert the excel file to a csv file.\r\n\r\n[//]: # (capture: baremetal)\r\n```bash\r\nwget https://archive.ics.uci.edu/ml/machine-learning-databases/00352/Online%20Retail.xlsx --no-check-certificate -O $DATA_DIR/data.xlsx\r\nxlsx2csv $DATA_DIR/data.xlsx $DATA_DIR/data.csv\r\n```\r\n\r\n\u003e *Please see this dataset's applicable license for terms and conditions. Intel® does not own the rights to this dataset and does not confer any rights to it.*\r\n\r\n## Supported Runtime Environment\r\nYou can execute the references pipelines using the following environments:\r\n* Bare Metal\r\n\r\n---\r\n### Run Using Bare Metal\r\nFollow these instructions to set up and run this workflow on your own development system.\r\n\r\n#### Set Up System Software\r\nOur examples use the `conda` package and environment on your local computer. If you don't already have `conda` installed or the `conda` environment created, go to [Set Up Conda*](#set-up-conda) or see the [Conda* Linux installation instructions](https://docs.conda.io/projects/conda/en/stable/user-guide/install/linux.html).\r\n\r\n#### Run Workflow\r\nAs mentioned above, this hyperpersonalized target recommendation uses KNN, DecisionTreeClassifier and RandomForestClassifier from scikit learn library to train a AI model and generate labels for the passed in data. This process is captured within the `purchase-prediction-module.py` script. This script *reads and preprocesses the data*, and *performs hyperparameter analysis on either KNN, DecisionTreeClassifier or RandomForestClassifier*, while also reporting on the execution time for preprocessing and hyperparameter analysis steps.  Furthermore, this script can also save each of the intermediate models for an in-depth analysis of the quality of fit.  \r\n\r\nThis script mainly performs two objectives - Data preparation \u0026 Benchmarking of Intel® oneAPI Libraries.\r\n\r\nData preparation step is performed first. It involves the following:\r\n1. Removing null values in the raw data\r\n2. Analysing the description column by listing all the keywords \u0026 figuring out the most frequent occurring keywords\r\n3. Defining the product categories\r\n4. Using one hot encoding to create group of products\r\n5. Creating customer categories\r\n\r\nThe script takes the following arguments:\r\n```sh\r\nusage: purchase-prediction-module.py [-h] [-rtd RAW_TRAIN_DATA] [-daf DATA_AUG_FACTOR] [-ftd FINAL_TRAIN_DATA] [-t TUNING] [-alg ALGORITHM]\r\n\r\noptional arguments:\r\n  -h, --help                                                    show this help message and exit\r\n  -rtd RAW_TRAIN_DATA, --raw-train-data RAW_TRAIN_DATA          raw data csv file, if this parameter is specified then it will only perform the data preparation part\r\n  -daf DATA_AUG_FACTOR, --data-aug-factor DATA_AUG_FACTOR       data augmentation/multiplication factor, requires --raw-train-data parameter\r\n  -ftd FINAL_TRAIN_DATA, --final-train-data FINAL_TRAIN_DATA    final filtered data csv file, if this parameter is specified then it will skip the data preparation part\r\n  -t TUNING, --tuning TUNING                                    hyperparameter tuning (0/1)\r\n  -alg ALGORITHM, --algorithm ALGORITHM                         scikit learn classifier algorithm to be used (knn,dtc,rfc) - knn=KNearestNeighborClassifier, dtc=DecisionTreeClassifier, rfc=RandomForestClassifier\r\n  -b BATCH_SIZE, --batch_size BATCH_SIZE                        batch size to run training without hyperparameter tuning\r\n  -inf INFERENCE, --inference INFERENCE                         performs Inference on the saved models for batch data. Specify the model files i.e knn_model, dtc_model or rfc_model for knn=KNearestNeighborClassifier, dtc=DecisionTreeClassifier, rfc=RandomForestClassifier respectively\r\n  -l LOGFILE, --logfile LOGFILE                                 log file to output benchmarking results to\r\n```\r\n\r\n**Data preparation**\r\n\r\nBelow command can be used to generate different dataset sizes which can be later used for feeding to the scikit-learn algorithms for benchmarking.\r\n\r\n[//]: # (capture: baremetal)\r\n```sh\r\npython $WORKSPACE/src/purchase-prediction-module.py -rtd $DATA_DIR/data.csv -daf 5\r\n```\r\n\r\nThe above example generates `$DATA_DIR/data_aug_5.csv` dataset which is the 5 fold multiplication of the initial filtered data.\r\n\r\n**Training**\r\n\r\nUse the below command to run the training with the generated data and default tuned hyperparameters for the algorithm KNeighborClassifier.\r\n\r\n[//]: # (capture: baremetal)\r\n```sh\r\npython $WORKSPACE/src/purchase-prediction-module.py -ftd $DATA_DIR/data_aug_5.csv -t 0 -alg knn\r\n```\r\n\r\n**Hyperparameter tuning**\r\n\r\nIn case of hyperparameter tuning mode training, use `-t 1` option. Gridsearch CV process is used for hyperparameter tuning.\r\n\r\n[//]: # (capture: baremetal)\r\n```sh\r\npython $WORKSPACE/src/purchase-prediction-module.py -ftd $DATA_DIR/data_aug_5.csv -t 1 -alg knn\r\n```\r\n\r\nThis will save the trained model in the path /model. i.e. knn_model.joblib will be saved in the path /model. Similarly, we would need to run the same for Decision Tree or Random Forest Classifier algorithms.\r\n\r\n\u003e Note: The tuned models will be saved as part of hyperparameter tuning and used for inference.\r\n\r\n**Inference / Prediction**\r\n\r\nOnce the models are saved, we need to use them for inferencing. When the current source code is ran, batch inference is performed. The saved model is loaded \u0026 fed with a batchdata \u0026 the prediction output is obtained. The entire dataset file is passed to function for inference.\r\n\r\nWe need to pass the model name as a parameter in the console as shown below for KNearestNeighborClassifier model.\r\n\r\n[//]: # (capture: baremetal)\r\n```sh\r\npython $WORKSPACE/src/purchase-prediction-module.py -ftd $DATA_DIR/data_aug_5.csv -inf knn_model -l $OUTPUT_DIR/logs/intel.log\r\n```\r\n\r\nYou can use the following command to review the performance of the model:\r\n\r\n[//]: # (capture: baremetal)\r\n```sh\r\ntail -n 4 $OUTPUT_DIR/logs/intel.log\r\n```\r\n\r\n**Note:** Inference benchmarking is done only for KNN model.\r\n\r\n| **Algorithm**               | **Model Name to be passed**           \r\n| :---                        | :---                            \r\n| KNearestNeighborClassifier  | knn_model                         \r\n\r\n\r\n#### Clean Up Bare Metal\r\nFollow these steps to restore your ``$WORKSPACE`` directory to an initial step. Please note that all downloaded dataset files, conda environment, and logs created by the workflow will be deleted. Before executing next steps back up your important files.\r\n\r\n```bash\r\nconda deactivate\r\nconda remove --name purchase_prediction_intel --all -y\r\n```\r\n\r\n```bash\r\nrm -r $DATA_DIR/*\r\nrm -r $OUTPUT_DIR/*\r\n```\r\n\r\n## Expected Output\r\nBelow sample output would be generated by the training module which will capture the overall training time.\r\n```\r\nINFO:__main__:Running KNeighborsClassifier ...\r\nINFO:__main__:====\u003eKNeighborsClassifier Average Training Time with default hyperparameters 0.007310628890991211 secs\r\nINFO:__main__:====\u003e Program execution time 0.19111275672912598 secs\r\n```\r\n\r\nBelow output would be generated by the training module which will capture the hyperparameter tuning training time.\r\n```\r\nINFO:__main__:====\u003e KNeighborsClassifier Training Time with hyperparameter tuning 67.140428619385 secs\r\nINFO:__main__:Saving the model ...\r\nINFO:__main__:KNeighborsClassifier model 'knn_model.joblib' is saved in: /model\r\nINFO:__main__:====\u003e Program execution time 68.47586631774902 secs\r\n```\r\n\r\nBelow output would be generated by the inference module which will capture the hyperparameter tuning inference time and accuracy.\r\n```\r\nkNN model loaded successfully\r\n====\u003e KNeighborsClassifier Model Inference Time is 0.20563340187072754 secs\r\n====\u003e Accuracy for kNN is: 100.0 % \r\n====\u003e F1 score for kNN is: 1.0\r\n====\u003e Program execution time 1.6182811260223389 secs\r\n```\r\n\r\n## Summary and Next Steps\r\nTo build a customer segmentation solution at scale, Data Scientists will need to train models for substantial datasets and run inference more frequently.The ability to accelerate training will allow them to train more frequently and achieve better accuracy. Besides training, faster speed in inference will allow them to run prediction in real-time scenarios as well as more frequently. A Data Scientist will also look at data classification to tag and categorize data so that it can be better understood and analyzed. This task requires a lot of training and retraining, making the job tedious. The ability to get it faster speed will accelerate the ML pipeline. This reference kit implementation provides performance-optimized guide around customer purchase prediction use cases that can be easily scaled across similar use cases.\r\n\r\n## Learn More\r\nFor more information about or to read about other relevant workflow examples, see these guides and software resources:\r\n\r\n- [Intel® AI Analytics Toolkit (AI Kit)](https://www.intel.com/content/www/us/en/developer/tools/oneapi/ai-analytics-toolkit.html)\r\n- [Intel® Distribution for Python*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html)\r\n- [Intel® Extension for Scikit-Learn*](https://www.intel.com/content/www/us/en/developer/tools/oneapi/scikit-learn.html)\r\n\r\n## Support\r\nIf you have questions or issues about this use case, want help with troubleshooting, want to report a bug or submit enhancement requests, please submit a GitHub issue.\r\n\r\n## Appendix\r\n\\*Names and brands that may be claimed as the property of others. [Trademarks](https://www.intel.com/content/www/us/en/legal/trademarks.html).\r\n\r\n### Reference\r\n\u003ca id=\"fabien_2018\"\u003e[1]\u003c/a\u003e Fabien, D. (2018). \"Customer Segmentation\". Kaggle. Found in: https://www.kaggle.com/code/fabiendaniel/customer-segmentation/\r\n\r\n### Disclaimers\r\nTo the extent that any public or non-Intel® datasets or models are referenced by or accessed using tools or code on this site those datasets or models are provided by the third party indicated as the content source. Intel® does not create the content and does not warrant its accuracy or quality. By accessing the public content, or using materials trained on or with such content, you agree to the terms associated with that content and that your use complies with the applicable license.\r\n\r\nIntel® expressly disclaims the accuracy, adequacy, or completeness of any such public content, and is not liable for any errors, omissions, or defects in the content, or for any reliance on the content. Intel® is not liable for any liability or damages relating to your use of public content.\r\n","funding_links":[],"categories":["Table of Contents"],"sub_categories":["AI - Frameworks and Toolkits"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Foneapi-src%2Fpurchase-prediction","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Foneapi-src%2Fpurchase-prediction","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Foneapi-src%2Fpurchase-prediction/lists"}