Extension for Scikit-learn* Logo
Choose version

Get Started

  • Quick Start
    • Compatibility with Scikit-learn*
    • Integrate Extension for Scikit-learn*
      • Patching
      • Global Patching
      • Unpatching
    • Installation
      • Install from PyPI
      • Install from Anaconda* Cloud
      • Build from Sources
      • Install Intel*(R) AI Tools
    • Release Notes
    • System Requirements
      • Hardware Requirements
      • Software Requirements
      • Memory Requirements
  • Samples
    • k-Nearest Neighbors (kNN) for MNIST dataset
      • Download the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Logistic Regression for Cifar dataset
      • Download the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Support Vector Classification (SVC) for Adult dataset
      • Download the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Random Forest Classification on rain in Australia dataset
      • Download the data
      • Explore the data
      • Preprocessing
      • Patch original Scikit-learn with Intel® Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
      • Comparison
    • ElasticNet for Airlines DepDelay dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Lasso Regression for YearPredictionMSD dataset
      • Download the data
      • Normalize the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Linear Regression for YearPredictionMSD dataset
      • Download the data
      • Normalize the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Nu-Support Vector Regression (NuSVR) for Medical Charges dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Random Forest for Yolanda dataset
      • Download the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Rigde Regression for Airlines DepDelay dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Ridge Regression on New York City Bike Share dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Intel® Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Ridge Regression on IEEE-CIS Fraud Detection dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Intel® Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Ridge Regression on Higgs dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Intel® Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Kmeans for spoken arabic digit dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • DBSCAN for spoken arabic digit dataset
      • Download the data
      • Preprocessing
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Train the same algorithm with original Scikit-learn
    • Extension for Scikit-learn TSNE example
      • Generate the data
      • Patch original Scikit-learn with Extension for Scikit-learn
      • Plot embeddings original scikit-learn and Extension
    • Extension for Scikit-Learn* Getting Started Sample
    • Extension for Scikit-Learn*: SVC for Adult dataset Performance Sample
  • Kaggle Kernels
    • Acceleration
    • Machine Learning Workflows
      • Kaggle kernels that use scikit-learn and Extension for Scikit-learn*:
        • Classification Tasks
          • Binary Classification
          • MultiClass Classification
          • Classification Tasks in Computer Vision
          • Classification Tasks in Natural Language Processing
        • Regression Tasks
          • Using a Single Regressor
          • Stacking Regressors
      • Kaggle kernels that use AutoML with Extension for Scikit-learn*:
        • AutoML Workflows

Developer Guide

  • Supported Algorithms
    • on CPU
      • Classification
      • Regression
      • Clustering
      • Dimensionality Reduction
      • Nearest Neighbors
      • Other Tasks
    • on GPU
      • Classification
      • Regression
      • Clustering
      • Dimensionality Reduction
      • Nearest Neighbors
      • Other Tasks
    • SPMD Support
      • Classification
      • Regression
      • Clustering
      • Dimensionality Reduction
      • Nearest Neighbors
      • Other Tasks
    • Scikit-learn Tests
  • oneAPI and GPU support in Extension for Scikit-learn*
    • Prerequisites
    • Device offloading
    • Example
  • SPMD (multi-GPU distributed mode)
  • Distributed mode (daal4py, CPU)
    • Introduction
    • Using distributed mode
    • Supported algorithms
  • Non-Scikit-Learn Algorithms
    • BasicStatistics
      • BasicStatistics.min_
      • BasicStatistics.max_
      • BasicStatistics.sum_
      • BasicStatistics.mean_
      • BasicStatistics.variance_
      • BasicStatistics.variation_
      • BasicStatistics.sum_squares_
      • BasicStatistics.standard_deviation_
      • BasicStatistics.sum_squares_centered_
      • BasicStatistics.second_order_raw_moment_
      • BasicStatistics.fit()
      • BasicStatistics.get_metadata_routing()
      • BasicStatistics.get_params()
      • BasicStatistics.set_fit_request()
      • BasicStatistics.set_params()
    • IncrementalBasicStatistics
      • IncrementalBasicStatistics.min_
      • IncrementalBasicStatistics.max_
      • IncrementalBasicStatistics.sum_
      • IncrementalBasicStatistics.mean_
      • IncrementalBasicStatistics.variance_
      • IncrementalBasicStatistics.variation_
      • IncrementalBasicStatistics.sum_squares_
      • IncrementalBasicStatistics.standard_deviation_
      • IncrementalBasicStatistics.sum_squares_centered_
      • IncrementalBasicStatistics.second_order_raw_moment_
      • IncrementalBasicStatistics.n_samples_seen_
      • IncrementalBasicStatistics.batch_size_
      • IncrementalBasicStatistics.n_features_in_
      • IncrementalBasicStatistics.fit()
      • IncrementalBasicStatistics.get_metadata_routing()
      • IncrementalBasicStatistics.get_params()
      • IncrementalBasicStatistics.partial_fit()
      • IncrementalBasicStatistics.set_fit_request()
      • IncrementalBasicStatistics.set_params()
      • IncrementalBasicStatistics.set_partial_fit_request()
    • IncrementalEmpiricalCovariance
      • IncrementalEmpiricalCovariance.location_
      • IncrementalEmpiricalCovariance.covariance_
      • IncrementalEmpiricalCovariance.n_samples_seen_
      • IncrementalEmpiricalCovariance.batch_size_
      • IncrementalEmpiricalCovariance.n_features_in_
      • IncrementalEmpiricalCovariance.error_norm()
      • IncrementalEmpiricalCovariance.fit()
      • IncrementalEmpiricalCovariance.get_metadata_routing()
      • IncrementalEmpiricalCovariance.get_params()
      • IncrementalEmpiricalCovariance.get_precision()
      • IncrementalEmpiricalCovariance.mahalanobis()
      • IncrementalEmpiricalCovariance.partial_fit()
      • IncrementalEmpiricalCovariance.score()
      • IncrementalEmpiricalCovariance.set_params()
      • IncrementalEmpiricalCovariance.set_partial_fit_request()
      • IncrementalEmpiricalCovariance.set_score_request()
    • IncrementalLinearRegression
      • IncrementalLinearRegression.coef_
      • IncrementalLinearRegression.intercept_
      • IncrementalLinearRegression.n_samples_seen_
      • IncrementalLinearRegression.batch_size_
      • IncrementalLinearRegression.n_features_in_
      • IncrementalLinearRegression.fit()
      • IncrementalLinearRegression.get_metadata_routing()
      • IncrementalLinearRegression.get_params()
      • IncrementalLinearRegression.partial_fit()
      • IncrementalLinearRegression.predict()
      • IncrementalLinearRegression.score()
      • IncrementalLinearRegression.set_params()
      • IncrementalLinearRegression.set_partial_fit_request()
      • IncrementalLinearRegression.set_score_request()
    • IncrementalRidge
      • IncrementalRidge.coef_
      • IncrementalRidge.intercept_
      • IncrementalRidge.n_features_in_
      • IncrementalRidge.n_samples_seen_
      • IncrementalRidge.batch_size_
      • IncrementalRidge.fit()
      • IncrementalRidge.get_metadata_routing()
      • IncrementalRidge.get_params()
      • IncrementalRidge.partial_fit()
      • IncrementalRidge.predict()
      • IncrementalRidge.score()
      • IncrementalRidge.set_params()
      • IncrementalRidge.set_partial_fit_request()
      • IncrementalRidge.set_score_request()
  • Other Non-Scikit-Learn Algorithms
  • Serving GBT models from other libraries
    • Introduction
    • Example
    • Notes about computed results
    • Limitations
    • Documentation
  • Serving Logistic Regression from Other Libraries
    • Example
    • Details
    • Documentation
  • Supported input types
  • Array API support
    • Support for DPNP and DPCTL
    • Support for Array API-compatible inputs
    • Example usage
      • DPNP ndarrays
      • DPCTL usm_ndarrays
      • Use of array-api-strict
  • Verbose Mode
  • Preview Functionality
  • Deprecation Notice
    • macOS* Support

daal4py

  • About daal4py
    • Introduction
    • Using daal4py
      • Streaming mode
      • Distributed mode
      • Documentation
  • daal4py API Reference
    • Thread control
      • daalinit()
      • num_threads()
      • enable_thread_pinning()
    • MPI helpers
      • daalfini()
      • num_procs()
      • my_procid()
    • Model builders (GBT and LogReg serving)
      • convert_model()
      • GBTDAALModel
        • GBTDAALModel.is_classifier_
        • GBTDAALModel.is_regressor_
        • GBTDAALModel.predict()
        • GBTDAALModel.predict_proba()
      • LogisticDAALModel
        • LogisticDAALModel.n_classes_
        • LogisticDAALModel.n_features_in_
        • LogisticDAALModel.dtype_
        • LogisticDAALModel.coef_
        • LogisticDAALModel.intercept_
        • LogisticDAALModel.predict()
        • LogisticDAALModel.predict_log_proba()
        • LogisticDAALModel.predict_multiple()
        • LogisticDAALModel.predict_proba()
    • Classification
      • Results class
        • classifier_prediction_result
          • classifier_prediction_result.logProbabilities
          • classifier_prediction_result.prediction
          • classifier_prediction_result.probabilities
      • Decision Forest Classification
        • decision_forest_classification_training
          • decision_forest_classification_training.compute()
        • decision_forest_classification_training_result
          • decision_forest_classification_training_result.model
          • decision_forest_classification_training_result.outOfBagError
          • decision_forest_classification_training_result.outOfBagErrorAccuracy
          • decision_forest_classification_training_result.outOfBagErrorDecisionFunction
          • decision_forest_classification_training_result.outOfBagErrorPerObservation
          • decision_forest_classification_training_result.variableImportance
        • decision_forest_classification_prediction
          • decision_forest_classification_prediction.compute()
        • decision_forest_classification_model
          • decision_forest_classification_model.NFeatures
          • decision_forest_classification_model.NumberOfClasses
          • decision_forest_classification_model.NumberOfFeatures
          • decision_forest_classification_model.NumberOfTrees
      • Decision Tree Classification
        • decision_tree_classification_training
          • decision_tree_classification_training.compute()
        • decision_tree_classification_training_result
          • decision_tree_classification_training_result.model
        • decision_tree_classification_prediction
          • decision_tree_classification_prediction.compute()
        • decision_tree_classification_model
          • decision_tree_classification_model.NFeatures
          • decision_tree_classification_model.NumberOfFeatures
      • Gradient Boosted Classification
        • gbt_classification_training
          • gbt_classification_training.compute()
        • gbt_classification_training_result
          • gbt_classification_training_result.model
          • gbt_classification_training_result.variableImportanceByCover
          • gbt_classification_training_result.variableImportanceByGain
          • gbt_classification_training_result.variableImportanceByTotalCover
          • gbt_classification_training_result.variableImportanceByTotalGain
          • gbt_classification_training_result.variableImportanceByWeight
        • gbt_classification_prediction
          • gbt_classification_prediction.compute()
        • gbt_classification_model
          • gbt_classification_model.NFeatures
          • gbt_classification_model.NumberOfFeatures
          • gbt_classification_model.NumberOfTrees
          • gbt_classification_model.PredictionBias
      • k-Nearest Neighbors (kNN)
        • kdtree_knn_classification_training
          • kdtree_knn_classification_training.compute()
        • kdtree_knn_classification_training_result
          • kdtree_knn_classification_training_result.model
        • kdtree_knn_classification_prediction
          • kdtree_knn_classification_prediction.compute()
        • kdtree_knn_classification_model
          • kdtree_knn_classification_model.NFeatures
          • kdtree_knn_classification_model.NumberOfFeatures
      • Brute-force k-Nearest Neighbors (kNN)
        • bf_knn_classification_training
          • bf_knn_classification_training.compute()
        • bf_knn_classification_training_result
          • bf_knn_classification_training_result.model
        • bf_knn_classification_prediction
          • bf_knn_classification_prediction.compute()
        • bf_knn_classification_model
          • bf_knn_classification_model.NFeatures
          • bf_knn_classification_model.NumberOfFeatures
      • AdaBoost Classification
        • adaboost_training
          • adaboost_training.compute()
        • adaboost_training_result
          • adaboost_training_result.model
          • adaboost_training_result.weakLearnersErrors
        • adaboost_prediction
          • adaboost_prediction.compute()
        • adaboost_model
          • adaboost_model.Alpha
          • adaboost_model.NFeatures
          • adaboost_model.NumberOfFeatures
          • adaboost_model.NumberOfWeakLearners
          • adaboost_model.WeakLearnerModel()
      • BrownBoost Classification
        • brownboost_training
          • brownboost_training.compute()
        • brownboost_training_result
          • brownboost_training_result.model
        • brownboost_prediction
          • brownboost_prediction.compute()
        • brownboost_model
          • brownboost_model.Alpha
          • brownboost_model.NFeatures
          • brownboost_model.NumberOfFeatures
          • brownboost_model.NumberOfWeakLearners
          • brownboost_model.WeakLearnerModel()
      • LogitBoost Classification
        • logitboost_training
          • logitboost_training.compute()
        • logitboost_training_result
          • logitboost_training_result.model
        • logitboost_prediction
          • logitboost_prediction.compute()
        • logitboost_model
          • logitboost_model.Iterations
          • logitboost_model.NFeatures
          • logitboost_model.NumberOfFeatures
          • logitboost_model.NumberOfWeakLearners
          • logitboost_model.WeakLearnerModel()
      • Stump Weak Learner Classification
        • stump_classification_training
          • stump_classification_training.compute()
        • stump_classification_training_result
          • stump_classification_training_result.model
          • stump_classification_training_result.variableImportance
        • stump_classification_prediction
          • stump_classification_prediction.compute()
        • stump_classification_model
          • stump_classification_model.LeftValue
          • stump_classification_model.NFeatures
          • stump_classification_model.NumberOfFeatures
          • stump_classification_model.RightValue
          • stump_classification_model.SplitFeature
          • stump_classification_model.SplitValue
      • Multinomial Naive Bayes
        • multinomial_naive_bayes_training
          • multinomial_naive_bayes_training.compute()
        • multinomial_naive_bayes_training_result
          • multinomial_naive_bayes_training_result.model
        • multinomial_naive_bayes_prediction
          • multinomial_naive_bayes_prediction.compute()
        • multinomial_naive_bayes_model
          • multinomial_naive_bayes_model.AuxTable
          • multinomial_naive_bayes_model.LogP
          • multinomial_naive_bayes_model.LogTheta
          • multinomial_naive_bayes_model.NFeatures
          • multinomial_naive_bayes_model.NumberOfFeatures
      • Support Vector Machine (SVM)
        • svm_training
          • svm_training.compute()
        • svm_training_result
          • svm_training_result.model
        • svm_prediction
          • svm_prediction.compute()
        • svm_model
          • svm_model.Bias
          • svm_model.ClassificationCoefficients
          • svm_model.NFeatures
          • svm_model.NumberOfFeatures
          • svm_model.SupportIndices
          • svm_model.SupportVectors
      • Logistic Regression
        • logistic_regression_training
          • logistic_regression_training.compute()
        • logistic_regression_training_result
          • logistic_regression_training_result.model
        • logistic_regression_prediction
          • logistic_regression_prediction.compute()
        • logistic_regression_model
          • logistic_regression_model.Beta
          • logistic_regression_model.InterceptFlag
          • logistic_regression_model.NFeatures
          • logistic_regression_model.NumberOfBetas
          • logistic_regression_model.NumberOfFeatures
    • Regression
      • Decision Forest Regression
        • decision_forest_regression_training
          • decision_forest_regression_training.compute()
        • decision_forest_regression_training_result
          • decision_forest_regression_training_result.model
          • decision_forest_regression_training_result.outOfBagError
          • decision_forest_regression_training_result.outOfBagErrorPerObservation
          • decision_forest_regression_training_result.outOfBagErrorPrediction
          • decision_forest_regression_training_result.outOfBagErrorR2
          • decision_forest_regression_training_result.variableImportance
        • decision_forest_regression_prediction
          • decision_forest_regression_prediction.compute()
        • decision_forest_regression_prediction_result
          • decision_forest_regression_prediction_result.prediction
        • decision_forest_regression_model
          • decision_forest_regression_model.NumberOfFeatures
          • decision_forest_regression_model.NumberOfTrees
      • Decision Tree Regression
        • decision_tree_regression_training
          • decision_tree_regression_training.compute()
        • decision_tree_regression_training_result
          • decision_tree_regression_training_result.model
        • decision_tree_regression_prediction
          • decision_tree_regression_prediction.compute()
        • decision_tree_regression_prediction_result
          • decision_tree_regression_prediction_result.prediction
        • decision_tree_regression_model
          • decision_tree_regression_model.NumberOfFeatures
      • Gradient Boosted Regression
        • gbt_regression_training
          • gbt_regression_training.compute()
        • gbt_regression_training_result
          • gbt_regression_training_result.model
          • gbt_regression_training_result.variableImportanceByCover
          • gbt_regression_training_result.variableImportanceByGain
          • gbt_regression_training_result.variableImportanceByTotalCover
          • gbt_regression_training_result.variableImportanceByTotalGain
          • gbt_regression_training_result.variableImportanceByWeight
        • gbt_regression_prediction
          • gbt_regression_prediction.compute()
        • gbt_regression_prediction_result
          • gbt_regression_prediction_result.prediction
        • gbt_regression_model
          • gbt_regression_model.NumberOfFeatures
          • gbt_regression_model.NumberOfTrees
          • gbt_regression_model.PredictionBias
      • Linear Regression
        • linear_regression_training
          • linear_regression_training.compute()
        • linear_regression_training_result
          • linear_regression_training_result.model
        • linear_regression_prediction
          • linear_regression_prediction.compute()
        • linear_regression_prediction_result
          • linear_regression_prediction_result.prediction
        • linear_regression_model
          • linear_regression_model.Beta
          • linear_regression_model.InterceptFlag
          • linear_regression_model.NumberOfBetas
          • linear_regression_model.NumberOfFeatures
          • linear_regression_model.NumberOfResponses
      • LASSO Regression
        • lasso_regression_training
          • lasso_regression_training.compute()
        • lasso_regression_training_result
          • lasso_regression_training_result.gramMatrixId
          • lasso_regression_training_result.model
        • lasso_regression_prediction
          • lasso_regression_prediction.compute()
        • lasso_regression_prediction_result
          • lasso_regression_prediction_result.prediction
        • lasso_regression_model
          • lasso_regression_model.Beta
          • lasso_regression_model.InterceptFlag
          • lasso_regression_model.NumberOfBetas
          • lasso_regression_model.NumberOfFeatures
          • lasso_regression_model.NumberOfResponses
      • Ridge Regression
        • ridge_regression_training
          • ridge_regression_training.compute()
        • ridge_regression_training_result
          • ridge_regression_training_result.model
        • ridge_regression_prediction
          • ridge_regression_prediction.compute()
        • ridge_regression_prediction_result
          • ridge_regression_prediction_result.prediction
        • ridge_regression_model
          • ridge_regression_model.Beta
          • ridge_regression_model.InterceptFlag
          • ridge_regression_model.NumberOfBetas
          • ridge_regression_model.NumberOfFeatures
          • ridge_regression_model.NumberOfResponses
      • Stump Regression
        • stump_regression_training
          • stump_regression_training.compute()
        • stump_regression_training_result
          • stump_regression_training_result.model
          • stump_regression_training_result.variableImportance
        • stump_regression_prediction
          • stump_regression_prediction.compute()
        • stump_regression_prediction_result
          • stump_regression_prediction_result.prediction
        • stump_regression_model
          • stump_regression_model.LeftValue
          • stump_regression_model.NumberOfFeatures
          • stump_regression_model.RightValue
          • stump_regression_model.SplitFeature
          • stump_regression_model.SplitValue
    • Clustering
      • K-Means Clustering
      • K-Means Initialization
        • kmeans_init
          • kmeans_init.compute()
        • kmeans_init_result
          • kmeans_init_result.centroids
      • K-Means
        • kmeans
          • kmeans.compute()
        • kmeans_result
          • kmeans_result.assignments
          • kmeans_result.centroids
          • kmeans_result.nIterations
          • kmeans_result.objectiveFunction
      • DBSCAN
        • dbscan
          • dbscan.compute()
        • dbscan_result
          • dbscan_result.assignments
          • dbscan_result.coreIndices
          • dbscan_result.coreObservations
          • dbscan_result.nClusters
      • Gaussian Mixtures
        • Initialization for the Gaussian Mixture Model
          • em_gmm_init
            • em_gmm_init.compute()
          • em_gmm_init_result
            • em_gmm_init_result.covariances
            • em_gmm_init_result.means
            • em_gmm_init_result.weights
        • EM algorithm for the Gaussian Mixture Model
          • em_gmm
            • em_gmm.compute()
          • em_gmm_result
            • em_gmm_result.covariances
            • em_gmm_result.goalFunction
            • em_gmm_result.means
            • em_gmm_result.nIterations
            • em_gmm_result.weights
    • Dimensionality reduction
      • Principal Component Analysis (PCA)
        • pca
          • pca.compute()
        • pca_result
          • pca_result.dataForTransform
          • pca_result.eigenvalues
          • pca_result.eigenvectors
          • pca_result.means
          • pca_result.variances
      • Principal Component Analysis (PCA) Transform
        • pca_transform
          • pca_transform.compute()
        • pca_transform_result
          • pca_transform_result.transformedData
    • Outlier detection
      • Multivariate Outlier Detection
        • multivariate_outlier_detection
          • multivariate_outlier_detection.compute()
        • multivariate_outlier_detection_result
          • multivariate_outlier_detection_result.weights
      • Univariate Outlier Detection
        • univariate_outlier_detection
          • univariate_outlier_detection.compute()
        • univariate_outlier_detection_result
          • univariate_outlier_detection_result.weights
      • Multivariate Bacon Outlier Detection
        • bacon_outlier_detection
          • bacon_outlier_detection.compute()
        • bacon_outlier_detection_result
          • bacon_outlier_detection_result.weights
    • Optimization Solvers
      • Objective Functions
        • Mean Squared Error Algorithm (MSE)
          • optimization_solver_mse
            • optimization_solver_mse.compute()
            • optimization_solver_mse.setup()
          • optimization_solver_mse_result
        • Logistic Loss
          • optimization_solver_logistic_loss
            • optimization_solver_logistic_loss.compute()
            • optimization_solver_logistic_loss.setup()
          • optimization_solver_logistic_loss_result
        • Cross-entropy Loss
          • optimization_solver_cross_entropy_loss
            • optimization_solver_cross_entropy_loss.compute()
            • optimization_solver_cross_entropy_loss.setup()
          • optimization_solver_cross_entropy_loss_result
        • Sum of Functions
          • optimization_solver_sum_of_functions_result
      • Iterative Solvers
        • Stochastic Gradient Descent Algorithm
          • optimization_solver_sgd
            • optimization_solver_sgd.compute()
          • optimization_solver_sgd_result
            • optimization_solver_sgd_result.minimum
            • optimization_solver_sgd_result.nIterations
        • Limited-Memory Broyden-Fletcher-Goldfarb-Shanno Algorithm
          • optimization_solver_lbfgs
            • optimization_solver_lbfgs.compute()
          • optimization_solver_lbfgs_result
            • optimization_solver_lbfgs_result.minimum
            • optimization_solver_lbfgs_result.nIterations
        • Adaptive Subgradient Method
          • optimization_solver_adagrad
            • optimization_solver_adagrad.compute()
          • optimization_solver_adagrad_result
            • optimization_solver_adagrad_result.minimum
            • optimization_solver_adagrad_result.nIterations
        • Stochastic Average Gradient Descent
          • optimization_solver_saga
            • optimization_solver_saga.compute()
          • optimization_solver_saga_result
            • optimization_solver_saga_result.gradientsTable
            • optimization_solver_saga_result.minimum
            • optimization_solver_saga_result.nIterations
        • Coordinate Descent
          • optimization_solver_coordinate_descent
            • optimization_solver_coordinate_descent.compute()
          • optimization_solver_coordinate_descent_result
            • optimization_solver_coordinate_descent_result.minimum
            • optimization_solver_coordinate_descent_result.nIterations
        • Precomputed Function
          • optimization_solver_precomputed
            • optimization_solver_precomputed.compute()
          • optimization_solver_precomputed_result
    • Recommender systems
      • Association Rules
        • association_rules
          • association_rules.compute()
        • association_rules_result
          • association_rules_result.antecedentItemsets
          • association_rules_result.confidence
          • association_rules_result.consequentItemsets
          • association_rules_result.largeItemsets
          • association_rules_result.largeItemsetsSupport
      • Implicit Alternating Least Squares (implicit ALS)
        • implicit_als_training
          • implicit_als_training.compute()
        • implicit_als_training_result
          • implicit_als_training_result.model
        • implicit_als_model
          • implicit_als_model.ItemsFactors
          • implicit_als_model.UsersFactors
        • implicit_als_prediction_ratings
          • implicit_als_prediction_ratings.compute()
        • implicit_als_prediction_ratings_result
          • implicit_als_prediction_ratings_result.prediction
    • Covariance, correlation, and distances
      • Cosine Distance Matrix
        • cosine_distance
          • cosine_distance.compute()
        • cosine_distance_result
          • cosine_distance_result.cosineDistance
      • Correlation Distance Matrix
        • correlation_distance
          • correlation_distance.compute()
        • correlation_distance_result
          • correlation_distance_result.correlationDistance
      • Correlation and Variance-Covariance Matrices
        • covariance
          • covariance.compute()
        • covariance_result
          • covariance_result.correlation
          • covariance_result.covariance
          • covariance_result.mean
    • Data pre-processing
      • Normalization
        • Z-Score
          • normalization_zscore
            • normalization_zscore.compute()
          • normalization_zscore_result
            • normalization_zscore_result.means
            • normalization_zscore_result.normalizedData
            • normalization_zscore_result.variances
        • Min-Max
          • normalization_minmax
            • normalization_minmax.compute()
          • normalization_minmax_result
            • normalization_minmax_result.normalizedData
    • Statistics
      • Moments of Low Order
        • low_order_moments
          • low_order_moments.compute()
        • low_order_moments_result
          • low_order_moments_result.maximum
          • low_order_moments_result.mean
          • low_order_moments_result.minimum
          • low_order_moments_result.secondOrderRawMoment
          • low_order_moments_result.standardDeviation
          • low_order_moments_result.sum
          • low_order_moments_result.sumSquares
          • low_order_moments_result.sumSquaresCentered
          • low_order_moments_result.variance
          • low_order_moments_result.variation
      • Quantiles
        • quantiles
          • quantiles.compute()
        • quantiles_result
          • quantiles_result.quantiles
    • Linear algebra
      • Cholesky Decomposition
        • cholesky
          • cholesky.compute()
        • cholesky_result
          • cholesky_result.choleskyFactor
      • QR Decomposition
        • QR Decomposition (without pivoting)
          • qr
            • qr.compute()
          • qr_result
            • qr_result.matrixQ
            • qr_result.matrixR
        • Pivoted QR Decomposition
          • pivoted_qr
            • pivoted_qr.compute()
          • pivoted_qr_result
            • pivoted_qr_result.matrixQ
            • pivoted_qr_result.matrixR
            • pivoted_qr_result.permutationMatrix
      • Singular Value Decomposition (SVD)
        • svd
          • svd.compute()
        • svd_result
          • svd_result.leftSingularMatrix
          • svd_result.rightSingularMatrix
          • svd_result.singularValues
    • Random number generation
      • Random Number Engines
        • engines_result
          • engines_result.randomNumbers
        • mt19937
          • engines_mt19937
            • engines_mt19937.compute()
          • engines_mt19937_result
        • mt2203
          • engines_mt2203
            • engines_mt2203.compute()
          • engines_mt2203_result
        • mcg59
          • engines_mcg59
            • engines_mcg59.compute()
          • engines_mcg59_result
        • mrg32k3a
          • engines_mrg32k3a
            • engines_mrg32k3a.compute()
          • engines_mrg32k3a_result
        • philox4x32x10
          • engines_philox4x32x10
            • engines_philox4x32x10.compute()
          • engines_philox4x32x10_result
      • Distributions
        • Bernoulli
          • distributions_bernoulli
            • distributions_bernoulli.compute()
          • distributions_bernoulli_result
        • Normal
          • distributions_normal
            • distributions_normal.compute()
          • distributions_normal_result
        • Uniform
          • distributions_uniform
            • distributions_uniform.compute()
          • distributions_uniform_result
    • Sorting
      • sorting
        • sorting.compute()
      • sorting_result
        • sorting_result.sortedData

Performance

  • Tuning Guide
    • TSNE
    • Random Forest

Learn

  • Tutorials & Case Studies
    • Tutorials
    • Case Studies
  • Medium Blogs

More

  • Support
    • Issues
  • How to Contribute
    • Licensing
    • Pull Requests
      • Before Contributing Changes
    • Code Style
  • Ideas
    • Implement Covariance Estimators for Supercomputers
      • Oracle Approximating Shrinkage Estimator (small)
      • ShrunkCovariance Estimator (small)
    • Implement the Preprocessing Estimators for Supercomputers
      • StandardScaler Estimator (small)
      • MaxAbsScaler Estimator (small)
      • MinMaxScaler Estimator (small)
      • Normalizer Estimator (small)
    • Expose Accelerated Kernel Distance Functions
      • sigmoid_kernel Function (small)
      • polynomial_kernel Function (small)
      • rbf_kernel Function (small)
  • License
Extension for Scikit-learn*
  • Samples
  • View page source

Samples

The following samples are also provided as Jupyter notebooks in Extension for Scikit-learn* repository. If you want to run them locally, refer to these instructions.

Classification Tasks

  • k-Nearest Neighbors (kNN) for MNIST dataset
  • Logistic Regression for Cifar dataset
  • Support Vector Classification (SVC) for Adult dataset
  • Random Forest Classification on rain in Australia dataset

Regression Tasks

  • ElasticNet for Airlines DepDelay dataset
  • Lasso Regression for YearPredictionMSD dataset
  • Linear Regression for YearPredictionMSD dataset
  • Nu-Support Vector Regression (NuSVR) for Medical Charges dataset
  • Random Forest for Yolanda dataset
  • Rigde Regression for Airlines DepDelay dataset
  • Ridge Regression on New York City Bike Share dataset
  • Ridge Regression on IEEE-CIS Fraud Detection dataset
  • Ridge Regression on Higgs dataset

Clustering Tasks

  • Kmeans for spoken arabic digit dataset
  • DBSCAN for spoken arabic digit dataset

Dimensionality Reduction Tasks

  • Extension for Scikit-learn TSNE example

Jupyter Notebook Samples

  • Extension for Scikit-Learn* Getting Started Sample
  • Extension for Scikit-Learn*: SVC for Adult dataset Performance Sample

See also

There are also Kaggle kernels that use Extension for Scikit-learn* for a variety of machine learning scenarios.

Note

Explore the complete list of oneAPI code samples in the oneAPI Samples Catalog. These samples were designed to help you develop, offload, and optimize multiarchitecture applications targeting CPUs, GPUs, and FPGAs.

Previous Next

Cookies Privacy Do Not Share My Personal Information
Built with Sphinx using a theme provided by Read the Docs.
Choose version