Welcome.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning using oneAPI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The concepts build on top of each other introducing and reinforcing the concepts of maching learning using oneAPI. At a high level you learn to accelerate end-to-end AI and data analytics pipelines with libraries optimized for Intel® architectures in commonly used machine learning algorithms including popular packages such as Numpy*, SciPy*, Pandas*, Scikit-learn*, XGBoost*.\n",
    "\n",
    "You will be able to identify dentify performance limiting coding patterns and address them with simple code changes which target Intel CPU & GPU with minimal coding efforts.\n",
    "\n",
    "# Introducing Intel AI Tools\n",
    "\n",
    "This course will cover using Intel AI tools and some of the lower level optimization librairies depicted in this graphic, including the Machine Learning section, and an indepth look at how to accelerate python loop centric code by replacing ineefcient loops with NumPy, SciPy, or Scitkit-learn algorithms.\n",
    "\n",
    "![01_Intel_Extensions_for_Scikit-learn_Patching_CPU/Assets/AIAnalyticsToolkitOverview.jpg](01_Introduction_to_Machine_Learning_using_oneAPI/Assets/AIAnalyticsToolkitOverview.jpg)\n",
    "\n",
    "\n",
    "## Module 0 - Introduction to Jupyter Notebook\n",
    "\n",
    "- [**Introduction to Jupyter Notebook (Optional)**](00_sklearnex_Prerequisites/Setup_Instructions_Numba.ipynb)\n",
    "**`Optional`** This module explains how to use Jupyter Notebook which is used in all of the modules to edit and run coding excecises, this can be skipped if you are already familiar with using Jupyter Notebooks.\n",
    "\n",
    "## Module 1 - Introduction to Intel_Extensions for Scikit-learn: Patching on CPU\n",
    "These initial hands-on exercises introduce you to concepts of Intel Extensions for Scikit-learn*. You will be introduced to the concept of 'patching' and 'unpatching' using Intel Extensions for Scikit-learn*. You wil also learn about Coarse versus Finer grained patching in this exercise \n",
    "- [**01_sklearnex_Intro_Acceleration**](01_Introduction_to_Machine_Learning_using_oneAPI/01_Patching_Classifier_CPU.ipynb) Demonstrates where and how to apply a patch with two line of code.\n",
    "\n",
    "- [**02_sklearnex_Motivation_Acceleration**](01_Introduction_to_Machine_Learning_using_oneAPI/02_sklearnex_Motivation_Acceleration.ipynb) Demonstrates the speedups achievable over stock scikit-learn* and where and how to apply a patch  to accomate a range of alogorithms in a test harness.\n",
    "\n",
    "- [**03_Coarse_Patching_Instructions**](01_Introduction_to_Machine_Learning_using_oneAPI/03_Coarse_Patching_Strategy.ipynb) Convert a Jupyter Notebook to a python file and then apply patching at the command line.\n",
    "\n",
    "## Module 2 - Applied Patching on CPU\n",
    "These hands-on exercises present how apply patching to a variety of scikit-learn classification algorithms\n",
    "- [**01_Patching_Clustering_CPU**](02_Intel_Extension_for_Scikit-learn_on_CPU/01_Patching_Clustering_CPU.ipynb) Using KMeans to find 3 data clusters in the iris dataset.\n",
    "  \n",
    "- [**02_Patching KNN on CPU**](02_Intel_Extension_for_Scikit-learn_on_CPU/02_PatchingSVM_CPU-Breast_Cancer_Dataset.ipynb) Using KNN to Predict forest coverage type of the CovType dataset\n",
    "\n",
    "- [**03_Pairwise_DistanceVectorizedStockSImulationReadPortfolio**](02_Intel_Extension_for_Scikit-learn_on_CPU/03_Pairwise_DistanceVectorizedStockSimulationReadPortfolio.ipynb) Using pairwise distance to compare a portfoilio of stock like time series data \n",
    "\n",
    "- [**04_Patching multiple classifiers on CPU**](02_Intel_Extension_for_Scikit-learn_on_CPU/04_Practicum_AnalyzeGalaxyBatch.ipynb) This hands-on exercise allows you to apply what you have learned to a more complex code that classifies stars as belonging to either of two colliding galaxies. This allows you to apply patching on code that searhces hyperparameter space, repeatedly calling fit and predct for a handul of classifiers. This is a **Practicum** intended to test your retention of knowledge related to patching principles.\n",
    "- [**05_Patching multiple classifiers on CPU**](02_Intel_Extension_for_Scikit-learn_on_CPU/05_Practicum_Display3D.ipynb) This hands-on exercise allows you to apply what you have learned to a more complex code that classifies stars as belonging to either of two colliding galaxies. This allows you to apply patching on code that searhces hyperparameter space, repeatedly calling fit and predct for a handul of classifiers. This is a **Practicum** intended to test your retention of knowledge related to patching principles.\n",
    "\n",
    "## Module 3 - Introduction dpctl for GPU\n",
    "- [**01_Introduction_dpctl_for GPU**](03_Intel_Extension_for_Scikit-learn_on_GPU/01_Introduction_simple_gallery_dpctl_for_GPU.ipynb) Demonstrates where and how to apply a patch and dpctl (Comcpute follows data) to accomate a range of alogorithms in a test harness. You will compute the **fit** function **on an Intel GPU** for a number of alogorithms, then **predict** using the fitted model to **inference on a CPU**.\n",
    "\n",
    "- [**02_Patching KNN on GPU**](03_Intel_Extension_for_Scikit-learn_on_GPU/02_PatchingClassifier.ipynb) Using KNN on Intel GPU to predict forest coverage type of the CovType dataset, leveraging patching and \"Compute Follows Data\". In this notebook, you will apply \"Compute Follows Data\" for **both KNN.Fit and KNN.Predict on an Intel GPU** \n",
    "\n",
    "- [**03_Gallery of functions on GPU**](03_Intel_Extension_for_Scikit-learn_on_GPU/03_Gallery_of_Functions_on_GPU.ipynb) Apply Patching AND Compute Follows Data to a gallery of KNN Regression, Linear Regression, dbscan, k_means_random, pca.\n",
    "\n",
    "## Module 4 - Introduction to NumPy, SciPy, Pandas powered by oneAPI\n",
    "- [**01_Numpy_How_Fast_Are_Numpy_Ops**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/01_Numpy_How_Fast_Are_Numpy_Ops.ipynb) Describe why replacing inefficient code, such as time-consuming loops, wastes resources, and time. \n",
    "Describe why replacing inefficient code such as python loops makes code simpler, more readable, more maintainable and faster on existing hardware and ready for future hardware advance.s\n",
    "\n",
    "- [**02_NumPy_UFUNCS**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/02_NumPy_UFUNCS.ipynb)\n",
    "Describe how Universal functions might accelerate simple python loops and how the underlying optimizations are built upon the Intel oneMKL library. Apply NumPy Universal functions and observe the degree of speedup acheivable\n",
    "\n",
    "- [**03_NumPy_Aggregations**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/03_NumPy_Aggregations.ipynb) Describe what aggregatsions are and enumerate several common aggregations used by data scientists. Apply NumPy Aggregation to simple codes to observe the acceleration achievable.\n",
    "\n",
    "- [**04_NumPy_Broadcasting & Fancy Slicing**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/04_NumPy_Broadcasting.ipynb) Describe what broadcasting and fancy slicing are, and apply these techniques to acheive remarkable speedups via oneMKL vectorization.\n",
    "\n",
    "- [**05_NumPy_Where & Select**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/05_NumPy_Where_Select.ipynb) Describe what NumPy Where and Select clauses are, how they do not resemble SQL WHERE/SELECT, and how these statements can accelerate and vectorize conditional logic in code..\n",
    "- [**06_Pandas**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/06_Pandas.ipynb) Describe how NumPy Where and Select clauses can acclerate Pandas APply statements with conditional logic.\n",
    "\n",
    "- [**07_SciPy**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/07_SciPy.ipynb) Describe how NumPy and SciPy are different and target different levels of coding abstractions. Describe the advantage of using SciPy over rolling your own loops.\n",
    "\n",
    "- [**08_Numpy_Sorting**](04_Machine_Learning_Speedups_for_NumPy_Pandas_and_SciPy_with_oneAPI/08_Numpy_Sorting.ipynb) Describe what how optimizations by Intel accelerated the NumPy sorting algorithms. Describe three sorting algorithms accelerated by NumPy powered by Intel oneAPI.\n",
    "\n",
    "## Module 5 - XGBoost\n",
    "- [**05_XGBoost_powered_by_oneAPI**](05_XGBoost_powered_by_oneAPI/XGBoost.ipynb)\n",
    "Utilize XGBoost with Intel's AI Kit. Take advantage of Intel extensions to SciKit Learnand oneDAL library  by enabling them with XGBoost. \n",
    "\n",
    "# Dependences:\n",
    "\n",
    "Prior to labs, use pip to installed the dependencies in the requirements.txt file\n",
    "- pip install -r requirements.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "384.391px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}