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*
  • License
  • View page source

License

License: https://github.com/uxlfoundation/scikit-learn-intelex/blob/main/LICENSE

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