scikit-learn sklearn contributors rst Version 0 17 changes0171

Answer:
.. include:: _contributors.rst

.. currentmodule:: sklearn

============
Version 0.17
============

.. _changes_0_17_1:

Version 0.17.1
==============

**February 18, 2016**

Changelog
---------

Bug fixes
.........

- Upgrade vendored joblib to version 0.9.4 that fixes an important bug in
  ``joblib.Parallel`` that can silently yield to wrong results when working
  on datasets larger than 1MB:
  https://github.com/joblib/joblib/blob/0.9.4/CHANGES.rst

- Fixed reading of Bunch pickles generated with scikit-learn
  version <= 0.16. This can affect users who have already
  downloaded a dataset with scikit-learn 0.16 and are loading it
  with scikit-learn 0.17. See :issue:`6196` for
  how this affected :func:`datasets.fetch_20newsgroups`. By `Loic
  Esteve`_.

- Fixed a bug that prevented using ROC AUC score to perform grid search on
  several CPU / cores on large arrays. See :issue:`6147`
  By `Olivier Grisel`_.

- Fixed a bug that prevented to properly set the ``presort`` parameter
  in :class:`ensemble.GradientBoostingRegressor`. See :issue:`5857`
  By Andrew McCulloh.

- Fixed a joblib error when evaluating the perplexity of a
  :class:`decomposition.LatentDirichletAllocation` model. See :issue:`6258`
  By Chyi-Kwei Yau.

.. _changes_0_17:

Version 0.17
============

**November 5, 2015**

Changelog
---------

New features
............

- All the Scaler classes but :class:`preprocessing.RobustScaler` can be fitted online by
  calling `partial_fit`. By :user:`Giorgio Patrini <giorgiop>`.

- The new class :class:`ensemble.VotingClassifier` implements a
  "majority rule" / "soft voting" ensemble classifier to combine
  estimators for classification. By `Sebastian Raschka`_.

- The new class :class:`preprocessing.RobustScaler` provides an
  alternative to :class:`preprocessing.StandardScaler` for feature-wise
  centering and range normalization that is robust to outliers.
  By :user:`Thomas Unterthiner <untom>`.

- The new class :class:`preprocessing.MaxAbsScaler` provides an
  alternative to :class:`preprocessing.MinMaxScaler` for feature-wise
  range normalization when the data is already centered or sparse.
  By :user:`Thomas Unterthiner <untom>`.

- The new class :class:`preprocessing.FunctionTransformer` turns a Python
  function into a ``Pipeline``-compatible transformer object.
  By Joe Jevnik.

- The new classes `cross_validation.LabelKFold` and
  `cross_validation.LabelShuffleSplit` generate train-test folds,
  respectively similar to `cross_validation.KFold` and
  `cross_validation.ShuffleSplit`, except that the folds are
  conditioned on a label array. By `Brian McFee`_, :user:`Jean
  Kossaifi <JeanKossaifi>` and `Gilles Louppe`_.

- :class:`decomposition.LatentDirichletAllocation` implements the Latent
  Dirichlet Allocation topic model with online  variational
  inference. By :user:`Chyi-Kwei Yau <chyikwei>`, with code based on an implementation
  by Matt Hoffman. (:issue:`3659`)

- The new solver ``sag`` implements a Stochastic Average Gradient descent
  and is available in both :class:`linear_model.LogisticRegression` and
  :class:`linear_model.Ridge`. This solver is very efficient for large
  datasets. By :user:`Danny Sullivan <dsullivan7>` and `Tom Dupre la Tour`_.
  (:issue:`4738`)

- The new solver ``cd`` implements a Coordinate Descent in
  :class:`decomposition.NMF`. Previous solver based on Projected Gradient is
  still available setting new parameter ``solver`` to ``pg``, but is
  deprecated and will be removed in 0.19, along with
  `decomposition.ProjectedGradientNMF` and parameters ``sparseness``,
  ``eta``, ``beta`` and ``nls_max_iter``. New parameters ``alpha`` and
  ``l1_ratio`` control L1 and L2 regularization, and ``shuffle`` adds a
  shuffling step in the ``cd`` solver.
  By `Tom Dupre la Tour`_ and `Mathieu Blondel`_.

Enhancements
............
- :class:`manifold.TSNE` now supports approximate optimization via the
  Barnes-Hut method, leading to much faster fitting. By Christopher Erick Moody.
  (:issue:`4025`)

- :class:`cluster.MeanShift` now supports parallel execution,
  as implemented in the ``mean_shift`` function. By :user:`Martino
  Sorbaro <martinosorb>`.

- :class:`naive_bayes.GaussianNB` now supports fitting with ``sample_weight``.
  By `Jan Hendrik Metzen`_.

- :class:`dummy.DummyClassifier` now supports a prior fitting strategy.
  By `Arnaud Joly`_.

- Added a ``fit_predict`` method for `mixture.GMM` and subclasses.
  By :user:`Cory Lorenz <clorenz7>`.

- Added the :func:`metrics.label_ranking_loss` metric.
  By `Arnaud Joly`_.

- Added the :func:`metrics.cohen_kappa_score` metric.

- Added a ``warm_start`` constructor parameter to the bagging ensemble
  models to increase the size of the ensemble. By :user:`Tim Head <betatim>`.

- Added option to use multi-output regression metrics without averaging.
  By Konstantin Shmelkov and :user:`Michael Eickenberg<eickenberg>`.

- Added ``stratify`` option to `cross_validation.train_test_split`
  for stratified splitting. By Miroslav Batchkarov.

- The :func:`tree.export_graphviz` function now supports aesthetic
  improvements for :class:`tree.DecisionTreeClassifier` and
  :class:`tree.DecisionTreeRegressor`, including options for coloring nodes
  by their majority class or impurity, showing variable names, and using
  node proportions instead of raw sample counts. By `Trevor Stephens`_.

- Improved speed of ``newton-cg`` solver in
  :class:`linear_model.LogisticRegression`, by avoiding loss computation.
  By `Mathieu Blondel`_ and `Tom Dupre la Tour`_.

- The ``class_weight="auto"`` heuristic in classifiers supporting
  ``class_weight`` was deprecated and replaced by the ``class_weight="balanced"``
  option, which has a simpler formula and interpretation.
  By `Hanna Wallach`_ and `Andreas Müller`_.

- Add ``class_weight`` parameter to automatically weight samples by class
  frequency for :class:`linear_model.PassiveAggressiveClassifier`. By
  `Trevor Stephens`_.

- Added backlinks from the API reference pages to the user guide. By
  `Andreas Müller`_.

- The ``labels`` parameter to :func:`sklearn.metrics.f1_score`,
  :func:`sklearn.metrics.fbeta_score`,
  :func:`sklearn.metrics.recall_score` and
  :func:`sklearn.metrics.precision_score` has been extended.
  It is now possible to ignore one or more labels, such as where
  a multiclass problem has a majority class to ignore. By `Joel Nothman`_.

- Add ``sample_weight`` support to :class:`linear_model.RidgeClassifier`.
  By `Trevor Stephens`_.

- Provide an option for sparse output from
  :func:`sklearn.metrics.pairwise.cosine_similarity`. By
  :user:`Jaidev Deshpande <jaidevd>`.

- Add :func:`preprocessing.minmax_scale` to provide a function interface for
  :class:`preprocessing.MinMaxScaler`. By :user:`Thomas Unterthiner <untom>`.

- ``dump_svmlight_file`` now handles multi-label datasets.
  By Chih-Wei Chang.

- RCV1 dataset loader (:func:`sklearn.datasets.fetch_rcv1`).
  By `Tom Dupre la Tour`_.

- The "Wisconsin Breast Cancer" classical two-class classification dataset
  is now included in scikit-learn, available with
  :func:`datasets.load_breast_cancer`.

- Upgraded to joblib 0.9.3 to benefit from the new automatic batching of
  short tasks. This makes it possible for scikit-learn to benefit from
  parallelism when many very short tasks are executed in parallel, for
  instance by the `grid_search.GridSearchCV` meta-estimator
  with ``n_jobs > 1`` used with a large grid of parameters on a small
  dataset. By `Vlad Niculae`_, `Olivier Grisel`_ and `Loic Esteve`_.

- For more details about changes in joblib 0.9.3 see the release notes:
  https://github.com/joblib/joblib/blob/master/CHANGES.rst#release-093

- Improved speed (3 times per iteration) of
  `decomposition.DictLearning` with coordinate descent method
  from :class:`linear_model.Lasso`. By :user:`Arthur Mensch <arthurmensch>`.

- Parallel processing (threaded) for queries of nearest neighbors
  (using the ball-tree) by Nikolay Mayorov.

- Allow :func:`datasets.make_multilabel_classification` to output
  a sparse ``y``. By Kashif Rasul.

- :class:`cluster.DBSCAN` now accepts a sparse matrix of precomputed
  distances, allowing memory-efficient distance precomputation. By
  `Joel Nothman`_.

- :class:`tree.DecisionTreeClassifier` now exposes an ``apply`` method
  for retrieving the leaf indices samples are predicted as. By
  :user:`Daniel Galvez <galv>` and `Gilles Louppe`_.

- Speed up decision tree regressors, random forest regressors, extra trees
  regressors and gradient boosting estimators by computing a proxy
  of the impurity improvement during the tree growth. The proxy quantity is
  such that the split that maximizes this value also maximizes the impurity
  improvement. By `Arnaud Joly`_, :user:`Jacob Schreiber <jmschrei>`
  and `Gilles Louppe`_.

- Speed up tree based methods by reducing the number of computations needed
  when computing the impurity measure taking into account linear
  relationship of the computed statistics. The effect is particularly
  visible with extra trees and on datasets with categorical or sparse
  features. By `Arnaud Joly`_.

- :class:`ensemble.GradientBoostingRegressor` and
  :class:`ensemble.GradientBoostingClassifier` now expose an ``apply``
  method for retrieving the leaf indices each sample ends up in under
  each try. By :user:`Jacob Schreiber <jmschrei>`.

- Add ``sample_weight`` support to :class:`linear_model.LinearRegression`.
  By Sonny Hu. (:issue:`#4881`)

- Add ``n_iter_without_progress`` to :class:`manifold.TSNE` to control
  the stopping criterion. By Santi Villalba. (:issue:`5186`)

- Added optional parameter ``random_state`` in :class:`linear_model.Ridge`
  , to set the seed of the pseudo random generator used in ``sag`` solver. By `Tom Dupre la Tour`_.

- Added optional parameter ``warm_start`` in
  :class:`linear_model.LogisticRegression`. If set to True, the solvers
  ``lbfgs``, ``newton-cg`` and ``sag`` will be initialized with the
  coefficients computed in the previous fit. By `Tom Dupre la Tour`_.

- Added ``sample_weight`` support to :class:`linear_model.LogisticRegression` for
  the ``lbfgs``, ``newton-cg``, and ``sag`` solvers. By `Valentin Stolbunov`_.
  Support added to the ``liblinear`` solver. By `Manoj Kumar`_.

- Added optional parameter ``presort`` to :class:`ensemble.GradientBoostingRegressor`
  and :class:`ensemble.GradientBoostingClassifier`, keeping default behavior
  the same. This allows gradient boosters to turn off presorting when building
  deep trees or using sparse data. By :user:`Jacob Schreiber <jmschrei>`.

- Altered :func:`metrics.roc_curve` to drop unnecessary thresholds by
  default. By :user:`Graham Clenaghan <gclenaghan>`.

- Added :class:`feature_selection.SelectFromModel` meta-transformer which can
  be used along with estimators that have `coef_` or `feature_importances_`
  attribute to select important features of the input data. By
  :user:`Maheshakya Wijewardena <maheshakya>`, `Joel Nothman`_ and `Manoj Kumar`_.

- Added :func:`metrics.pairwise.laplacian_kernel`.  By `Clyde Fare <https://github.com/Clyde-fare>`_.

- `covariance.GraphLasso` allows separate control of the convergence criterion
  for the Elastic-Net subproblem via  the ``enet_tol`` parameter.

- Improved verbosity in :class:`decomposition.DictionaryLearning`.

- :class:`ensemble.RandomForestClassifier` and
  :class:`ensemble.RandomForestRegressor` no longer explicitly store the
  samples used in bagging, resulting in a much reduced memory footprint for
  storing random forest models.

- Added ``positive`` option to :class:`linear_model.Lars` and
  :func:`linear_model.lars_path` to force coefficients to be positive.
  (:issue:`5131`)

- Added the ``X_norm_squared`` parameter to :func:`metrics.pairwise.euclidean_distances`
  to provide precomputed squared norms for ``X``.

- Added the ``fit_predict`` method to :class:`pipeline.Pipeline`.

- Added the :func:`preprocessing.minmax_scale` function.

Bug fixes
.........

- Fixed non-determinism in :class:`dummy.DummyClassifier` with sparse
  multi-label output. By `Andreas Müller`_.

- Fixed the output shape of :class:`linear_model.RANSACRegressor` to
  ``(n_samples, )``. By `Andreas Müller`_.

- Fixed bug in `decomposition.DictLearning` when ``n_jobs < 0``. By
  `Andreas Müller`_.

- Fixed bug where `grid_search.RandomizedSearchCV` could consume a
  lot of memory for large discrete grids. By `Joel Nothman`_.

- Fixed bug in :class:`linear_model.LogisticRegressionCV` where `penalty` was ignored
  in the final fit. By `Manoj Kumar`_.

- Fixed bug in `ensemble.forest.ForestClassifier` while computing
  oob_score and X is a sparse.csc_matrix. By :user:`Ankur Ankan <ankurankan>`.

- All regressors now consistently handle and warn when given ``y`` that is of
  shape ``(n_samples, 1)``. By `Andreas Müller`_ and Henry Lin.
  (:issue:`5431`)

- Fix in :class:`cluster.KMeans` cluster reassignment for sparse input by
  `Lars Buitinck`_.

- Fixed a bug in :class:`discriminant_analysis.LinearDiscriminantAnalysis` that
  could cause asymmetric covariance matrices when using shrinkage. By `Martin
  Billinger`_.

- Fixed `cross_validation.cross_val_predict` for estimators with
  sparse predictions. By Buddha Prakash.

- Fixed the ``predict_proba`` method of :class:`linear_model.LogisticRegression`
  to use soft-max instead of one-vs-rest normalization. By `Manoj Kumar`_.
  (:issue:`5182`)

- Fixed the `partial_fit` method of :class:`linear_model.SGDClassifier`
  when called with ``average=True``. By :user:`Andrew Lamb <andylamb>`.
  (:issue:`5282`)

- Dataset fetchers use different filenames under Python 2 and Python 3 to
  avoid pickling compatibility issues. By `Olivier Grisel`_.
  (:issue:`5355`)

- Fixed a bug in :class:`naive_bayes.GaussianNB` which caused classification
  results to depend on scale. By `Jake Vanderplas`_.

- Fixed temporarily :class:`linear_model.Ridge`, which was incorrect
  when fitting the intercept in the case of sparse data. The fix
  automatically changes the solver to 'sag' in this case.
  :issue:`5360` by `Tom Dupre la Tour`_.

- Fixed a performance bug in `decomposition.RandomizedPCA` on data
  with a large number of features and fewer samples. (:issue:`4478`)
  By `Andreas Müller`_, `Loic Esteve`_ and :user:`Giorgio Patrini <giorgiop>`.

- Fixed bug in `cross_decomposition.PLS` that yielded unstable and
  platform dependent output, and failed on `fit_transform`.
  By :user:`Arthur Mensch <arthurmensch>`.

- Fixes to the ``Bunch`` class used to store datasets.

- Fixed `ensemble.plot_partial_dependence` ignoring the
  ``percentiles`` parameter.

- Providing a ``set`` as vocabulary in ``CountVectorizer`` no longer
  leads to inconsistent results when pickling.

- Fixed the conditions on when a precomputed Gram matrix needs to
  be recomputed in :class:`linear_model.LinearRegression`,
  :class:`linear_model.OrthogonalMatchingPursuit`,
  :class:`linear_model.Lasso` and :class:`linear_model.ElasticNet`.

- Fixed inconsistent memory layout in the coordinate descent solver
  that affected `linear_model.DictionaryLearning` and
  `covariance.GraphLasso`. (:issue:`5337`)
  By `Olivier Grisel`_.

- :class:`manifold.LocallyLinearEmbedding` no longer ignores the ``reg``
  parameter.

- Nearest Neighbor estimators with custom distance metrics can now be pickled.
  (:issue:`4362`)

- Fixed a bug in :class:`pipeline.FeatureUnion` where ``transformer_weights``
  were not properly handled when performing grid-searches.

- Fixed a bug in :class:`linear_model.LogisticRegression` and
  :class:`linear_model.LogisticRegressionCV` when using
  ``class_weight='balanced'`` or ``class_weight='auto'``.
  By `Tom Dupre la Tour`_.

- Fixed bug :issue:`5495` when
  doing OVR(SVC(decision_function_shape="ovr")). Fixed by
  :user:`Elvis Dohmatob <dohmatob>`.

API changes summary
-------------------
- Attribute `data_min`, `data_max` and `data_range` in
  :class:`preprocessing.MinMaxScaler` are deprecated and won't be available
  from 0.19. Instead, the class now exposes `data_min_`, `data_max_`
  and `data_range_`. By :user:`Giorgio Patrini <giorgiop>`.

- All Scaler classes now have an `scale_` attribute, the feature-wise
  rescaling applied by their `transform` methods. The old attribute `std_`
  in :class:`preprocessing.StandardScaler` is deprecated and superseded
  by `scale_`; it won't be available in 0.19. By :user:`Giorgio Patrini <giorgiop>`.

- :class:`svm.SVC` and :class:`svm.NuSVC` now have an ``decision_function_shape``
  parameter to make their decision function of shape ``(n_samples, n_classes)``
  by setting ``decision_function_shape='ovr'``. This will be the default behavior
  starting in 0.19. By `Andreas Müller`_.

- Passing 1D data arrays as input to estimators is now deprecated as it
  caused confusion in how the array elements should be interpreted
  as features or as samples. All data arrays are now expected
  to be explicitly shaped ``(n_samples, n_features)``.
  By :user:`Vighnesh Birodkar <vighneshbirodkar>`.

- `lda.LDA` and `qda.QDA` have been moved to
  :class:`discriminant_analysis.LinearDiscriminantAnalysis` and
  :class:`discriminant_analysis.QuadraticDiscriminantAnalysis`.

- The ``store_covariance`` and ``tol`` parameters have been moved from
  the fit method to the constructor in
  :class:`discriminant_analysis.LinearDiscriminantAnalysis` and the
  ``store_covariances`` and ``tol`` parameters have been moved from the
  fit method to the constructor in
  :class:`discriminant_analysis.QuadraticDiscriminantAnalysis`.

- Models inheriting from ``_LearntSelectorMixin`` will no longer support the
  transform methods. (i.e,  RandomForests, GradientBoosting, LogisticRegression,
  DecisionTrees, SVMs and SGD related models). Wrap these models around the
  metatransfomer :class:`feature_selection.SelectFromModel` to remove
  features (according to `coefs_` or `feature_importances_`)
  which are below a certain threshold value instead.

- :class:`cluster.KMeans` re-runs cluster-assignments in case of non-convergence,
  to ensure consistency of ``predict(X)`` and ``labels_``. By
  :user:`Vighnesh Birodkar <vighneshbirodkar>`.

- Classifier and Regressor models are now tagged as such using the
  ``_estimator_type`` attribute.

- Cross-validation iterators always provide indices into training and test set,
  not boolean masks.

- The ``decision_function`` on all regressors was deprecated and will be
  removed in 0.19.  Use ``predict`` instead.

- `datasets.load_lfw_pairs` is deprecated and will be removed in 0.19.
  Use :func:`datasets.fetch_lfw_pairs` instead.

- The deprecated ``hmm`` module was removed.

- The deprecated ``Bootstrap`` cross-validation iterator was removed.

- The deprecated ``Ward`` and ``WardAgglomerative`` classes have been removed.
  Use :class:`cluster.AgglomerativeClustering` instead.

- `cross_validation.check_cv` is now a public function.

- The property ``residues_`` of :class:`linear_model.LinearRegression` is deprecated
  and will be removed in 0.19.

- The deprecated ``n_jobs`` parameter of :class:`linear_model.LinearRegression` has been moved
  to the constructor.

- Removed deprecated ``class_weight`` parameter from :class:`linear_model.SGDClassifier`'s ``fit``
  method. Use the construction parameter instead.

- The deprecated support for the sequence of sequences (or list of lists) multilabel
  format was removed. To convert to and from the supported binary
  indicator matrix format, use
  :class:`MultiLabelBinarizer <preprocessing.MultiLabelBinarizer>`.

- The behavior of calling the ``inverse_transform`` method of ``Pipeline.pipeline`` will
  change in 0.19. It will no longer reshape one-dimensional input to two-dimensional input.

- The deprecated attributes ``indicator_matrix_``, ``multilabel_`` and ``classes_`` of
  :class:`preprocessing.LabelBinarizer` were removed.

- Using ``gamma=0`` in :class:`svm.SVC` and :class:`svm.SVR` to automatically set the
  gamma to ``1. / n_features`` is deprecated and will be removed in 0.19.
  Use ``gamma="auto"`` instead.

Code Contributors
-----------------
Aaron Schumacher, Adithya Ganesh, akitty, Alexandre Gramfort, Alexey Grigorev,
Ali Baharev, Allen Riddell, Ando Saabas, Andreas Mueller, Andrew Lamb, Anish
Shah, Ankur Ankan, Anthony Erlinger, Ari Rouvinen, Arnaud Joly, Arnaud Rachez,
Arthur Mensch, banilo, Barmaley.exe, benjaminirving, Boyuan Deng, Brett Naul,
Brian McFee, Buddha Prakash, Chi Zhang, Chih-Wei Chang, Christof Angermueller,
Christoph Gohlke, Christophe Bourguignat, Christopher Erick Moody, Chyi-Kwei
Yau, Cindy Sridharan, CJ Carey, Clyde-fare, Cory Lorenz, Dan Blanchard, Daniel
Galvez, Daniel Kronovet, Danny Sullivan, Data1010, David, David D Lowe, David
Dotson, djipey, Dmitry Spikhalskiy, Donne Martin, Dougal J. Sutherland, Dougal
Sutherland, edson duarte, Eduardo Caro, Eric Larson, Eric Martin, Erich
Schubert, Fernando Carrillo, Frank C. Eckert, Frank Zalkow, Gael Varoquaux,
Ganiev Ibraim, Gilles Louppe, Giorgio Patrini, giorgiop, Graham Clenaghan,
Gryllos Prokopis, gwulfs, Henry Lin, Hsuan-Tien Lin, Immanuel Bayer, Ishank
Gulati, Jack Martin, Jacob Schreiber, Jaidev Deshpande, Jake Vanderplas, Jan
Hendrik Metzen, Jean Kossaifi, Jeffrey04, Jeremy, jfraj, Jiali Mei,
Joe Jevnik, Joel Nothman, John Kirkham, John Wittenauer, Joseph, Joshua Loyal,
Jungkook Park, KamalakerDadi, Kashif Rasul, Keith Goodman, Kian Ho, Konstantin
Shmelkov, Kyler Brown, Lars Buitinck, Lilian Besson, Loic Esteve, Louis Tiao,
maheshakya, Maheshakya Wijewardena, Manoj Kumar, MarkTab marktab.net, Martin
Ku, Martin Spacek, MartinBpr, martinosorb, MaryanMorel, Masafumi Oyamada,
Mathieu Blondel, Matt Krump, Matti Lyra, Maxim Kolganov, mbillinger, mhg,
Michael Heilman, Michael Patterson, Miroslav Batchkarov, Nelle Varoquaux,
Nicolas, Nikolay Mayorov, Olivier Grisel, Omer Katz, Óscar Nájera, Pauli
Virtanen, Peter Fischer, Peter Prettenhofer, Phil Roth, pianomania, Preston
Parry, Raghav RV, Rob Zinkov, Robert Layton, Rohan Ramanath, Saket Choudhary,
Sam Zhang, santi, saurabh.bansod, scls19fr, Sebastian Raschka, Sebastian
Saeger, Shivan Sornarajah, SimonPL, sinhrks, Skipper Seabold, Sonny Hu, sseg,
Stephen Hoover, Steven De Gryze, Steven Seguin, Theodore Vasiloudis, Thomas
Unterthiner, Tiago Freitas Pereira, Tian Wang, Tim Head, Timothy Hopper,
tokoroten, Tom Dupré la Tour, Trevor Stephens, Valentin Stolbunov, Vighnesh
Birodkar, Vinayak Mehta, Vincent, Vincent Michel, vstolbunov, wangz10, Wei Xue,
Yucheng Low, Yury Zhauniarovich, Zac Stewart, zhai_pro, Zichen Wang

include    contributors rst     currentmodule   sklearn               Version 0 17                   changes 0 17 1   Version 0 17 1                   February 18  2016    Changelog            Bug fixes               Upgrade vendored joblib to version 0 9 4 that fixes an important bug in     joblib Parallel   that can silently yield to wrong results when working   on datasets larger than 1MB    https   github com joblib joblib blob 0 9 4 CHANGES rst    Fixed reading of Bunch pickles generated with scikit learn   version    0 16  This can affect users who have already   downloaded a dataset with scikit learn 0 16 and are loading it   with scikit learn 0 17  See  issue  6196  for   how this affected  func  datasets fetch 20newsgroups   By  Loic   Esteve       Fixed a bug that prevented using ROC AUC score to perform grid search on   several CPU   cores on large arrays  See  issue  6147    By  Olivier Grisel       Fixed a bug that prevented to properly set the   presort   parameter   in  class  ensemble GradientBoostingRegressor   See  issue  5857    By Andrew McCulloh     Fixed a joblib error when evaluating the perplexity of a    class  decomposition LatentDirichletAllocation  model  See  issue  6258    By Chyi Kwei Yau        changes 0 17   Version 0 17                 November 5  2015    Changelog            New features                 All the Scaler classes but  class  preprocessing RobustScaler  can be fitted online by   calling  partial fit   By  user  Giorgio Patrini  giorgiop       The new class  class  ensemble VotingClassifier  implements a    majority rule     soft voting  ensemble classifier to combine   estimators for classification  By  Sebastian Raschka       The new class  class  preprocessing RobustScaler  provides an   alternative to  class  preprocessing StandardScaler  for feature wise   centering and range normalization that is robust to outliers    By  user  Thomas Unterthiner  untom       The new class  class  preprocessing MaxAbsScaler  provides an   alternative to  class  preprocessing MinMaxScaler  for feature wise   range normalization when the data is already centered or sparse    By  user  Thomas Unterthiner  untom       The new class  class  preprocessing FunctionTransformer  turns a Python   function into a   Pipeline   compatible transformer object    By Joe Jevnik     The new classes  cross validation LabelKFold  and    cross validation LabelShuffleSplit  generate train test folds    respectively similar to  cross validation KFold  and    cross validation ShuffleSplit   except that the folds are   conditioned on a label array  By  Brian McFee     user  Jean   Kossaifi  JeanKossaifi   and  Gilles Louppe        class  decomposition LatentDirichletAllocation  implements the Latent   Dirichlet Allocation topic model with online  variational   inference  By  user  Chyi Kwei Yau  chyikwei    with code based on an implementation   by Matt Hoffman    issue  3659      The new solver   sag   implements a Stochastic Average Gradient descent   and is available in both  class  linear model LogisticRegression  and    class  linear model Ridge   This solver is very efficient for large   datasets  By  user  Danny Sullivan  dsullivan7   and  Tom Dupre la Tour        issue  4738      The new solver   cd   implements a Coordinate Descent in    class  decomposition NMF   Previous solver based on Projected Gradient is   still available setting new parameter   solver   to   pg    but is   deprecated and will be removed in 0 19  along with    decomposition ProjectedGradientNMF  and parameters   sparseness        eta      beta   and   nls max iter    New parameters   alpha   and     l1 ratio   control L1 and L2 regularization  and   shuffle   adds a   shuffling step in the   cd   solver    By  Tom Dupre la Tour   and  Mathieu Blondel     Enhancements                 class  manifold TSNE  now supports approximate optimization via the   Barnes Hut method  leading to much faster fitting  By Christopher Erick Moody      issue  4025       class  cluster MeanShift  now supports parallel execution    as implemented in the   mean shift   function  By  user  Martino   Sorbaro  martinosorb        class  naive bayes GaussianNB  now supports fitting with   sample weight      By  Jan Hendrik Metzen        class  dummy DummyClassifier  now supports a prior fitting strategy    By  Arnaud Joly       Added a   fit predict   method for  mixture GMM  and subclasses    By  user  Cory Lorenz  clorenz7       Added the  func  metrics label ranking loss  metric    By  Arnaud Joly       Added the  func  metrics cohen kappa score  metric     Added a   warm start   constructor parameter to the bagging ensemble   models to increase the size of the ensemble  By  user  Tim Head  betatim       Added option to use multi output regression metrics without averaging    By Konstantin Shmelkov and  user  Michael Eickenberg eickenberg       Added   stratify   option to  cross validation train test split    for stratified splitting  By Miroslav Batchkarov     The  func  tree export graphviz  function now supports aesthetic   improvements for  class  tree DecisionTreeClassifier  and    class  tree DecisionTreeRegressor   including options for coloring nodes   by their majority class or impurity  showing variable names  and using   node proportions instead of raw sample counts  By  Trevor Stephens       Improved speed of   newton cg   solver in    class  linear model LogisticRegression   by avoiding loss computation    By  Mathieu Blondel   and  Tom Dupre la Tour       The   class weight  auto    heuristic in classifiers supporting     class weight   was deprecated and replaced by the   class weight  balanced      option  which has a simpler formula and interpretation    By  Hanna Wallach   and  Andreas M ller       Add   class weight   parameter to automatically weight samples by class   frequency for  class  linear model PassiveAggressiveClassifier   By    Trevor Stephens       Added backlinks from the API reference pages to the user guide  By    Andreas M ller       The   labels   parameter to  func  sklearn metrics f1 score      func  sklearn metrics fbeta score      func  sklearn metrics recall score  and    func  sklearn metrics precision score  has been extended    It is now possible to ignore one or more labels  such as where   a multiclass problem has a majority class to ignore  By  Joel Nothman       Add   sample weight   support to  class  linear model RidgeClassifier     By  Trevor Stephens       Provide an option for sparse output from    func  sklearn metrics pairwise cosine similarity   By    user  Jaidev Deshpande  jaidevd       Add  func  preprocessing minmax scale  to provide a function interface for    class  preprocessing MinMaxScaler   By  user  Thomas Unterthiner  untom         dump svmlight file   now handles multi label datasets    By Chih Wei Chang     RCV1 dataset loader   func  sklearn datasets fetch rcv1      By  Tom Dupre la Tour       The  Wisconsin Breast Cancer  classical two class classification dataset   is now included in scikit learn  available with    func  datasets load breast cancer      Upgraded to joblib 0 9 3 to benefit from the new automatic batching of   short tasks  This makes it possible for scikit learn to benefit from   parallelism when many very short tasks are executed in parallel  for   instance by the  grid search GridSearchCV  meta estimator   with   n jobs   1   used with a large grid of parameters on a small   dataset  By  Vlad Niculae     Olivier Grisel   and  Loic Esteve       For more details about changes in joblib 0 9 3 see the release notes    https   github com joblib joblib blob master CHANGES rst release 093    Improved speed  3 times per iteration  of    decomposition DictLearning  with coordinate descent method   from  class  linear model Lasso   By  user  Arthur Mensch  arthurmensch       Parallel processing  threaded  for queries of nearest neighbors    using the ball tree  by Nikolay Mayorov     Allow  func  datasets make multilabel classification  to output   a sparse   y    By Kashif Rasul      class  cluster DBSCAN  now accepts a sparse matrix of precomputed   distances  allowing memory efficient distance precomputation  By    Joel Nothman        class  tree DecisionTreeClassifier  now exposes an   apply   method   for retrieving the leaf indices samples are predicted as  By    user  Daniel Galvez  galv   and  Gilles Louppe       Speed up decision tree regressors  random forest regressors  extra trees   regressors and gradient boosting estimators by computing a proxy   of the impurity improvement during the tree growth  The proxy quantity is   such that the split that maximizes this value also maximizes the impurity   improvement  By  Arnaud Joly     user  Jacob Schreiber  jmschrei     and  Gilles Louppe       Speed up tree based methods by reducing the number of computations needed   when computing the impurity measure taking into account linear   relationship of the computed statistics  The effect is particularly   visible with extra trees and on datasets with categorical or sparse   features  By  Arnaud Joly        class  ensemble GradientBoostingRegressor  and    class  ensemble GradientBoostingClassifier  now expose an   apply     method for retrieving the leaf indices each sample ends up in under   each try  By  user  Jacob Schreiber  jmschrei       Add   sample weight   support to  class  linear model LinearRegression     By Sonny Hu    issue   4881      Add   n iter without progress   to  class  manifold TSNE  to control   the stopping criterion  By Santi Villalba    issue  5186      Added optional parameter   random state   in  class  linear model Ridge      to set the seed of the pseudo random generator used in   sag   solver  By  Tom Dupre la Tour       Added optional parameter   warm start   in    class  linear model LogisticRegression   If set to True  the solvers     lbfgs      newton cg   and   sag   will be initialized with the   coefficients computed in the previous fit  By  Tom Dupre la Tour       Added   sample weight   support to  class  linear model LogisticRegression  for   the   lbfgs      newton cg    and   sag   solvers  By  Valentin Stolbunov      Support added to the   liblinear   solver  By  Manoj Kumar       Added optional parameter   presort   to  class  ensemble GradientBoostingRegressor    and  class  ensemble GradientBoostingClassifier   keeping default behavior   the same  This allows gradient boosters to turn off presorting when building   deep trees or using sparse data  By  user  Jacob Schreiber  jmschrei       Altered  func  metrics roc curve  to drop unnecessary thresholds by   default  By  user  Graham Clenaghan  gclenaghan       Added  class  feature selection SelectFromModel  meta transformer which can   be used along with estimators that have  coef   or  feature importances     attribute to select important features of the input data  By    user  Maheshakya Wijewardena  maheshakya     Joel Nothman   and  Manoj Kumar       Added  func  metrics pairwise laplacian kernel    By  Clyde Fare  https   github com Clyde fare         covariance GraphLasso  allows separate control of the convergence criterion   for the Elastic Net subproblem via  the   enet tol   parameter     Improved verbosity in  class  decomposition DictionaryLearning       class  ensemble RandomForestClassifier  and    class  ensemble RandomForestRegressor  no longer explicitly store the   samples used in bagging  resulting in a much reduced memory footprint for   storing random forest models     Added   positive   option to  class  linear model Lars  and    func  linear model lars path  to force coefficients to be positive      issue  5131      Added the   X norm squared   parameter to  func  metrics pairwise euclidean distances    to provide precomputed squared norms for   X       Added the   fit predict   method to  class  pipeline Pipeline      Added the  func  preprocessing minmax scale  function   Bug fixes              Fixed non determinism in  class  dummy DummyClassifier  with sparse   multi label output  By  Andreas M ller       Fixed the output shape of  class  linear model RANSACRegressor  to      n samples       By  Andreas M ller       Fixed bug in  decomposition DictLearning  when   n jobs   0    By    Andreas M ller       Fixed bug where  grid search RandomizedSearchCV  could consume a   lot of memory for large discrete grids  By  Joel Nothman       Fixed bug in  class  linear model LogisticRegressionCV  where  penalty  was ignored   in the final fit  By  Manoj Kumar       Fixed bug in  ensemble forest ForestClassifier  while computing   oob score and X is a sparse csc matrix  By  user  Ankur Ankan  ankurankan       All regressors now consistently handle and warn when given   y   that is of   shape    n samples  1     By  Andreas M ller   and Henry Lin      issue  5431      Fix in  class  cluster KMeans  cluster reassignment for sparse input by    Lars Buitinck       Fixed a bug in  class  discriminant analysis LinearDiscriminantAnalysis  that   could cause asymmetric covariance matrices when using shrinkage  By  Martin   Billinger       Fixed  cross validation cross val predict  for estimators with   sparse predictions  By Buddha Prakash     Fixed the   predict proba   method of  class  linear model LogisticRegression    to use soft max instead of one vs rest normalization  By  Manoj Kumar        issue  5182      Fixed the  partial fit  method of  class  linear model SGDClassifier    when called with   average True    By  user  Andrew Lamb  andylamb        issue  5282      Dataset fetchers use different filenames under Python 2 and Python 3 to   avoid pickling compatibility issues  By  Olivier Grisel        issue  5355      Fixed a bug in  class  naive bayes GaussianNB  which caused classification   results to depend on scale  By  Jake Vanderplas       Fixed temporarily  class  linear model Ridge   which was incorrect   when fitting the intercept in the case of sparse data  The fix   automatically changes the solver to  sag  in this case     issue  5360  by  Tom Dupre la Tour       Fixed a performance bug in  decomposition RandomizedPCA  on data   with a large number of features and fewer samples    issue  4478     By  Andreas M ller     Loic Esteve   and  user  Giorgio Patrini  giorgiop       Fixed bug in  cross decomposition PLS  that yielded unstable and   platform dependent output  and failed on  fit transform     By  user  Arthur Mensch  arthurmensch       Fixes to the   Bunch   class used to store datasets     Fixed  ensemble plot partial dependence  ignoring the     percentiles   parameter     Providing a   set   as vocabulary in   CountVectorizer   no longer   leads to inconsistent results when pickling     Fixed the conditions on when a precomputed Gram matrix needs to   be recomputed in  class  linear model LinearRegression      class  linear model OrthogonalMatchingPursuit      class  linear model Lasso  and  class  linear model ElasticNet      Fixed inconsistent memory layout in the coordinate descent solver   that affected  linear model DictionaryLearning  and    covariance GraphLasso     issue  5337     By  Olivier Grisel        class  manifold LocallyLinearEmbedding  no longer ignores the   reg     parameter     Nearest Neighbor estimators with custom distance metrics can now be pickled      issue  4362      Fixed a bug in  class  pipeline FeatureUnion  where   transformer weights     were not properly handled when performing grid searches     Fixed a bug in  class  linear model LogisticRegression  and    class  linear model LogisticRegressionCV  when using     class weight  balanced    or   class weight  auto       By  Tom Dupre la Tour       Fixed bug  issue  5495  when   doing OVR SVC decision function shape  ovr     Fixed by    user  Elvis Dohmatob  dohmatob      API changes summary                       Attribute  data min    data max  and  data range  in    class  preprocessing MinMaxScaler  are deprecated and won t be available   from 0 19  Instead  the class now exposes  data min     data max     and  data range    By  user  Giorgio Patrini  giorgiop       All Scaler classes now have an  scale   attribute  the feature wise   rescaling applied by their  transform  methods  The old attribute  std     in  class  preprocessing StandardScaler  is deprecated and superseded   by  scale    it won t be available in 0 19  By  user  Giorgio Patrini  giorgiop        class  svm SVC  and  class  svm NuSVC  now have an   decision function shape     parameter to make their decision function of shape    n samples  n classes      by setting   decision function shape  ovr     This will be the default behavior   starting in 0 19  By  Andreas M ller       Passing 1D data arrays as input to estimators is now deprecated as it   caused confusion in how the array elements should be interpreted   as features or as samples  All data arrays are now expected   to be explicitly shaped    n samples  n features       By  user  Vighnesh Birodkar  vighneshbirodkar        lda LDA  and  qda QDA  have been moved to    class  discriminant analysis LinearDiscriminantAnalysis  and    class  discriminant analysis QuadraticDiscriminantAnalysis      The   store covariance   and   tol   parameters have been moved from   the fit method to the constructor in    class  discriminant analysis LinearDiscriminantAnalysis  and the     store covariances   and   tol   parameters have been moved from the   fit method to the constructor in    class  discriminant analysis QuadraticDiscriminantAnalysis      Models inheriting from    LearntSelectorMixin   will no longer support the   transform methods   i e   RandomForests  GradientBoosting  LogisticRegression    DecisionTrees  SVMs and SGD related models   Wrap these models around the   metatransfomer  class  feature selection SelectFromModel  to remove   features  according to  coefs   or  feature importances      which are below a certain threshold value instead      class  cluster KMeans  re runs cluster assignments in case of non convergence    to ensure consistency of   predict X    and   labels     By    user  Vighnesh Birodkar  vighneshbirodkar       Classifier and Regressor models are now tagged as such using the      estimator type   attribute     Cross validation iterators always provide indices into training and test set    not boolean masks     The   decision function   on all regressors was deprecated and will be   removed in 0 19   Use   predict   instead      datasets load lfw pairs  is deprecated and will be removed in 0 19    Use  func  datasets fetch lfw pairs  instead     The deprecated   hmm   module was removed     The deprecated   Bootstrap   cross validation iterator was removed     The deprecated   Ward   and   WardAgglomerative   classes have been removed    Use  class  cluster AgglomerativeClustering  instead      cross validation check cv  is now a public function     The property   residues    of  class  linear model LinearRegression  is deprecated   and will be removed in 0 19     The deprecated   n jobs   parameter of  class  linear model LinearRegression  has been moved   to the constructor     Removed deprecated   class weight   parameter from  class  linear model SGDClassifier  s   fit     method  Use the construction parameter instead     The deprecated support for the sequence of sequences  or list of lists  multilabel   format was removed  To convert to and from the supported binary   indicator matrix format  use    class  MultiLabelBinarizer  preprocessing MultiLabelBinarizer       The behavior of calling the   inverse transform   method of   Pipeline pipeline   will   change in 0 19  It will no longer reshape one dimensional input to two dimensional input     The deprecated attributes   indicator matrix       multilabel    and   classes    of    class  preprocessing LabelBinarizer  were removed     Using   gamma 0   in  class  svm SVC  and  class  svm SVR  to automatically set the   gamma to   1    n features   is deprecated and will be removed in 0 19    Use   gamma  auto    instead   Code Contributors                   Aaron Schumacher  Adithya Ganesh  akitty  Alexandre Gramfort  Alexey Grigorev  Ali Baharev  Allen Riddell  Ando Saabas  Andreas Mueller  Andrew Lamb  Anish Shah  Ankur Ankan  Anthony Erlinger  Ari Rouvinen  Arnaud Joly  Arnaud Rachez  Arthur Mensch  banilo  Barmaley exe  benjaminirving  Boyuan Deng  Brett Naul  Brian McFee  Buddha Prakash  Chi Zhang  Chih Wei Chang  Christof Angermueller  Christoph Gohlke  Christophe Bourguignat  Christopher Erick Moody  Chyi Kwei Yau  Cindy Sridharan  CJ Carey  Clyde fare  Cory Lorenz  Dan Blanchard  Daniel Galvez  Daniel Kronovet  Danny Sullivan  Data1010  David  David D Lowe  David Dotson  djipey  Dmitry Spikhalskiy  Donne Martin  Dougal J  Sutherland  Dougal Sutherland  edson duarte  Eduardo Caro  Eric Larson  Eric Martin  Erich Schubert  Fernando Carrillo  Frank C  Eckert  Frank Zalkow  Gael Varoquaux  Ganiev Ibraim  Gilles Louppe  Giorgio Patrini  giorgiop  Graham Clenaghan  Gryllos Prokopis  gwulfs  Henry Lin  Hsuan Tien Lin  Immanuel Bayer  Ishank Gulati  Jack Martin  Jacob Schreiber  Jaidev Deshpande  Jake Vanderplas  Jan Hendrik Metzen  Jean Kossaifi  Jeffrey04  Jeremy  jfraj  Jiali Mei  Joe Jevnik  Joel Nothman  John Kirkham  John Wittenauer  Joseph  Joshua Loyal  Jungkook Park  KamalakerDadi  Kashif Rasul  Keith Goodman  Kian Ho  Konstantin Shmelkov  Kyler Brown  Lars Buitinck  Lilian Besson  Loic Esteve  Louis Tiao  maheshakya  Maheshakya Wijewardena  Manoj Kumar  MarkTab marktab net  Martin Ku  Martin Spacek  MartinBpr  martinosorb  MaryanMorel  Masafumi Oyamada  Mathieu Blondel  Matt Krump  Matti Lyra  Maxim Kolganov  mbillinger  mhg  Michael Heilman  Michael Patterson  Miroslav Batchkarov  Nelle Varoquaux  Nicolas  Nikolay Mayorov  Olivier Grisel  Omer Katz   scar N jera  Pauli Virtanen  Peter Fischer  Peter Prettenhofer  Phil Roth  pianomania  Preston Parry  Raghav RV  Rob Zinkov  Robert Layton  Rohan Ramanath  Saket Choudhary  Sam Zhang  santi  saurabh bansod  scls19fr  Sebastian Raschka  Sebastian Saeger  Shivan Sornarajah  SimonPL  sinhrks  Skipper Seabold  Sonny Hu  sseg  Stephen Hoover  Steven De Gryze  Steven Seguin  Theodore Vasiloudis  Thomas Unterthiner  Tiago Freitas Pereira  Tian Wang  Tim Head  Timothy Hopper  tokoroten  Tom Dupr  la Tour  Trevor Stephens  Valentin Stolbunov  Vighnesh Birodkar  Vinayak Mehta  Vincent  Vincent Michel  vstolbunov  wangz10  Wei Xue  Yucheng Low  Yury Zhauniarovich  Zac Stewart  zhai pro  Zichen Wang


scikit-learn orphan Who is using scikit learn Testimonials testimonials

Answer:
:orphan:

.. title:: Testimonials

.. _testimonials:

==========================
Who is using scikit-learn?
==========================

`J.P.Morgan <https://www.jpmorgan.com>`_
----------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-learn is an indispensable part of the Python machine learning
    toolkit at JPMorgan. It is very widely used across all parts of the bank
    for classification, predictive analytics, and very many other machine
    learning tasks. Its straightforward API, its breadth of algorithms, and
    the quality of its documentation combine to make scikit-learn
    simultaneously very approachable and very powerful.

    .. rst-class:: annotation

      Stephen Simmons, VP, Athena Research, JPMorgan

  .. div:: image-box

    .. image:: images/jpmorgan.png
      :target: https://www.jpmorgan.com

`Spotify <https://www.spotify.com>`_
------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-learn provides a toolbox with solid implementations of a bunch of
    state-of-the-art models and makes it easy to plug them into existing
    applications. We've been using it quite a lot for music recommendations at
    Spotify and I think it's the most well-designed ML package I've seen so far.

    .. rst-class:: annotation

      Erik Bernhardsson, Engineering Manager Music Discovery & Machine Learning, Spotify

  .. div:: image-box

    .. image:: images/spotify.png
      :target: https://www.spotify.com

`Inria <https://www.inria.fr/>`_
--------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At INRIA, we use scikit-learn to support leading-edge basic research in many
    teams: `Parietal <https://team.inria.fr/parietal/>`_ for neuroimaging, `Lear
    <https://lear.inrialpes.fr/>`_ for computer vision, `Visages
    <https://team.inria.fr/visages/>`_ for medical image analysis, `Privatics
    <https://team.inria.fr/privatics>`_ for security. The project is a fantastic
    tool to address difficult applications of machine learning in an academic
    environment as it is performant and versatile, but all easy-to-use and well
    documented, which makes it well suited to grad students.

    .. rst-class:: annotation

      Gaël Varoquaux, research at Parietal

  .. div:: image-box

    .. image:: images/inria.png
      :target: https://www.inria.fr/

`betaworks <https://betaworks.com>`_
------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Betaworks is a NYC-based startup studio that builds new products, grows
    companies, and invests in others. Over the past 8 years we've launched a
    handful of social data analytics-driven services, such as Bitly, Chartbeat,
    digg and Scale Model. Consistently the betaworks data science team uses
    Scikit-learn for a variety of tasks. From exploratory analysis, to product
    development, it is an essential part of our toolkit. Recent uses are included
    in `digg's new video recommender system
    <https://medium.com/i-data/the-digg-video-recommender-2f9ade7c4ba3>`_,
    and Poncho's `dynamic heuristic subspace clustering
    <https://medium.com/@DiggData/scaling-poncho-using-data-ca24569d56fd>`_.

    .. rst-class:: annotation

      Gilad Lotan, Chief Data Scientist

  .. div:: image-box

    .. image:: images/betaworks.png
      :target: https://betaworks.com

`Hugging Face <https://huggingface.co>`_
----------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Hugging Face we're using NLP and probabilistic models to generate
    conversational Artificial intelligences that are fun to chat with. Despite using
    deep neural nets for `a few <https://medium.com/huggingface/understanding-emotions-from-keras-to-pytorch-3ccb61d5a983>`_
    of our `NLP tasks <https://huggingface.co/coref/>`_, scikit-learn is still the
    bread-and-butter of our daily machine learning routine. The ease of use and
    predictability of the interface, as well as the straightforward mathematical
    explanations that are here when you need them, is the killer feature. We use a
    variety of scikit-learn models in production and they are also operationally very
    pleasant to work with.

    .. rst-class:: annotation

      Julien Chaumond, Chief Technology Officer

  .. div:: image-box

    .. image:: images/huggingface.png
      :target: https://huggingface.co

`Evernote <https://evernote.com>`_
----------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Building a classifier is typically an iterative process of exploring
    the data, selecting the features (the attributes of the data believed
    to be predictive in some way), training the models, and finally
    evaluating them. For many of these tasks, we relied on the excellent
    scikit-learn package for Python.

    `Read more <http://blog.evernote.com/tech/2013/01/22/stay-classified/>`_

    .. rst-class:: annotation

      Mark Ayzenshtat, VP, Augmented Intelligence

  .. div:: image-box

    .. image:: images/evernote.png
      :target: https://evernote.com

`Télécom ParisTech <https://www.telecom-paristech.fr/>`_
--------------------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Telecom ParisTech, scikit-learn is used for hands-on sessions and home
    assignments in introductory and advanced machine learning courses. The classes
    are for undergrads and masters students. The great benefit of scikit-learn is
    its fast learning curve that allows students to quickly start working on
    interesting and motivating problems.

    .. rst-class:: annotation

      Alexandre Gramfort, Assistant Professor

  .. div:: image-box

    .. image:: images/telecomparistech.jpg
      :target: https://www.telecom-paristech.fr/

`Booking.com <https://www.booking.com>`_
----------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Booking.com, we use machine learning algorithms for many different
    applications, such as recommending hotels and destinations to our customers,
    detecting fraudulent reservations, or scheduling our customer service agents.
    Scikit-learn is one of the tools we use when implementing standard algorithms
    for prediction tasks. Its API and documentations are excellent and make it easy
    to use. The scikit-learn developers do a great job of incorporating state of
    the art implementations and new algorithms into the package. Thus, scikit-learn
    provides convenient access to a wide spectrum of algorithms, and allows us to
    readily find the right tool for the right job.

    .. rst-class:: annotation

      Melanie Mueller, Data Scientist

  .. div:: image-box

    .. image:: images/booking.png
      :target: https://www.booking.com

`AWeber <https://www.aweber.com/>`_
-----------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    The scikit-learn toolkit is indispensable for the Data Analysis and Management
    team at AWeber.  It allows us to do AWesome stuff we would not otherwise have
    the time or resources to accomplish. The documentation is excellent, allowing
    new engineers to quickly evaluate and apply many different algorithms to our
    data. The text feature extraction utilities are useful when working with the
    large volume of email content we have at AWeber. The RandomizedPCA
    implementation, along with Pipelining and FeatureUnions, allows us to develop
    complex machine learning algorithms efficiently and reliably.

    Anyone interested in learning more about how AWeber deploys scikit-learn in a
    production environment should check out talks from PyData Boston by AWeber's
    Michael Becker available at https://github.com/mdbecker/pydata_2013.

    .. rst-class:: annotation

      Michael Becker, Software Engineer, Data Analysis and Management Ninjas

  .. div:: image-box

    .. image:: images/aweber.png
      :target: https://www.aweber.com

`Yhat <https://www.yhat.com>`_
------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    The combination of consistent APIs, thorough documentation, and top notch
    implementation make scikit-learn our favorite machine learning package in
    Python. scikit-learn makes doing advanced analysis in Python accessible to
    anyone. At Yhat, we make it easy to integrate these models into your production
    applications. Thus eliminating the unnecessary dev time encountered
    productionizing analytical work.

    .. rst-class:: annotation

      Greg Lamp, Co-founder

  .. div:: image-box

    .. image:: images/yhat.png
      :target: https://www.yhat.com

`Rangespan <http://www.rangespan.com>`_
---------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    The Python scikit-learn toolkit is a core tool in the data science
    group at Rangespan. Its large collection of well documented models and
    algorithms allow our team of data scientists to prototype fast and
    quickly iterate to find the right solution to our learning problems.
    We find that scikit-learn is not only the right tool for prototyping,
    but its careful and well tested implementation give us the confidence
    to run scikit-learn models in production.

    .. rst-class:: annotation

      Jurgen Van Gael, Data Science Director

  .. div:: image-box

    .. image:: images/rangespan.png
      :target: http://www.rangespan.com

`Birchbox <https://www.birchbox.com>`_
--------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Birchbox, we face a range of machine learning problems typical to
    E-commerce: product recommendation, user clustering, inventory prediction,
    trends detection, etc. Scikit-learn lets us experiment with many models,
    especially in the exploration phase of a new project: the data can be passed
    around in a consistent way; models are easy to save and reuse; updates keep us
    informed of new developments from the pattern discovery research community.
    Scikit-learn is an important tool for our team, built the right way in the
    right language.

    .. rst-class:: annotation

      Thierry Bertin-Mahieux, Data Scientist

  .. div:: image-box

    .. image:: images/birchbox.jpg
      :target: https://www.birchbox.com

`Bestofmedia Group <http://www.bestofmedia.com>`_
-------------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-learn is our #1 toolkit for all things machine learning
    at Bestofmedia. We use it for a variety of tasks (e.g. spam fighting,
    ad click prediction, various ranking models) thanks to the varied,
    state-of-the-art algorithm implementations packaged into it.
    In the lab it accelerates prototyping of complex pipelines. In
    production I can say it has proven to be robust and efficient enough
    to be deployed for business critical components.

    .. rst-class:: annotation

      Eustache Diemert, Lead Scientist

  .. div:: image-box

    .. image:: images/bestofmedia-logo.png
      :target: http://www.bestofmedia.com

`Change.org <https://www.change.org>`_
--------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At change.org we automate the use of scikit-learn's RandomForestClassifier
    in our production systems to drive email targeting that reaches millions
    of users across the world each week. In the lab, scikit-learn's ease-of-use,
    performance, and overall variety of algorithms implemented has proved invaluable
    in giving us a single reliable source to turn to for our machine-learning needs.

    .. rst-class:: annotation

      Vijay Ramesh, Software Engineer in Data/science at Change.org

  .. div:: image-box

    .. image:: images/change-logo.png
      :target: https://www.change.org

`PHIMECA Engineering <https://www.phimeca.com/?lang=en>`_
---------------------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At PHIMECA Engineering, we use scikit-learn estimators as surrogates for
    expensive-to-evaluate numerical models (mostly but not exclusively
    finite-element mechanical models) for speeding up the intensive post-processing
    operations involved in our simulation-based decision making framework.
    Scikit-learn's fit/predict API together with its efficient cross-validation
    tools considerably eases the task of selecting the best-fit estimator. We are
    also using scikit-learn for illustrating concepts in our training sessions.
    Trainees are always impressed by the ease-of-use of scikit-learn despite the
    apparent theoretical complexity of machine learning.

    .. rst-class:: annotation

      Vincent Dubourg, PHIMECA Engineering, PhD Engineer

  .. div:: image-box

    .. image:: images/phimeca.png
      :target: https://www.phimeca.com/?lang=en

`HowAboutWe <http://www.howaboutwe.com/>`_
------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At HowAboutWe, scikit-learn lets us implement a wide array of machine learning
    techniques in analysis and in production, despite having a small team.  We use
    scikit-learn's classification algorithms to predict user behavior, enabling us
    to (for example) estimate the value of leads from a given traffic source early
    in the lead's tenure on our site. Also, our users' profiles consist of
    primarily unstructured data (answers to open-ended questions), so we use
    scikit-learn's feature extraction and dimensionality reduction tools to
    translate these unstructured data into inputs for our matchmaking system.

    .. rst-class:: annotation

      Daniel Weitzenfeld, Senior Data Scientist at HowAboutWe

  .. div:: image-box

    .. image:: images/howaboutwe.png
      :target: http://www.howaboutwe.com/

`PeerIndex <https://www.brandwatch.com/peerindex-and-brandwatch>`_
------------------------------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At PeerIndex we use scientific methodology to build the Influence Graph - a
    unique dataset that allows us to identify who's really influential and in which
    context. To do this, we have to tackle a range of machine learning and
    predictive modeling problems. Scikit-learn has emerged as our primary tool for
    developing prototypes and making quick progress. From predicting missing data
    and classifying tweets to clustering communities of social media users, scikit-
    learn proved useful in a variety of applications. Its very intuitive interface
    and excellent compatibility with other python tools makes it and indispensable
    tool in our daily research efforts.

    .. rst-class:: annotation

      Ferenc Huszar, Senior Data Scientist at Peerindex

  .. div:: image-box

    .. image:: images/peerindex.png
      :target: https://www.brandwatch.com/peerindex-and-brandwatch

`DataRobot <https://www.datarobot.com>`_
----------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    DataRobot is building next generation predictive analytics software to make data
    scientists more productive, and scikit-learn is an integral part of our system. The
    variety of machine learning techniques in combination with the solid implementations
    that scikit-learn offers makes it a one-stop-shopping library for machine learning
    in Python. Moreover, its consistent API, well-tested code and permissive licensing
    allow us to use it in a production environment. Scikit-learn has literally saved us
    years of work we would have had to do ourselves to bring our product to market.

    .. rst-class:: annotation

      Jeremy Achin, CEO & Co-founder DataRobot Inc.

  .. div:: image-box

    .. image:: images/datarobot.png
      :target: https://www.datarobot.com

`OkCupid <https://www.okcupid.com/>`_
-------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    We're using scikit-learn at OkCupid to evaluate and improve our matchmaking
    system. The range of features it has, especially preprocessing utilities, means
    we can use it for a wide variety of projects, and it's performant enough to
    handle the volume of data that we need to sort through. The documentation is
    really thorough, as well, which makes the library quite easy to use.

    .. rst-class:: annotation

      David Koh - Senior Data Scientist at OkCupid

  .. div:: image-box

    .. image:: images/okcupid.png
      :target: https://www.okcupid.com

`Lovely <https://livelovely.com/>`_
-----------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Lovely, we strive to deliver the best apartment marketplace, with respect to
    our users and our listings. From understanding user behavior, improving data
    quality, and detecting fraud, scikit-learn is a regular tool for gathering
    insights, predictive modeling and improving our product. The easy-to-read
    documentation and intuitive architecture of the API makes machine learning both
    explorable and accessible to a wide range of python developers. I'm constantly
    recommending that more developers and scientists try scikit-learn.

    .. rst-class:: annotation

      Simon Frid - Data Scientist, Lead at Lovely

  .. div:: image-box

    .. image:: images/lovely.png
      :target: https://livelovely.com

`Data Publica <http://www.data-publica.com/>`_
----------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Data Publica builds a new predictive sales tool for commercial and marketing teams
    called C-Radar. We extensively use scikit-learn to build segmentations of customers
    through clustering, and to predict future customers based on past partnerships
    success or failure. We also categorize companies using their website communication
    thanks to scikit-learn and its machine learning algorithm implementations.
    Eventually, machine learning makes it possible to detect weak signals that
    traditional tools cannot see. All these complex tasks are performed in an easy and
    straightforward way thanks to the great quality of the scikit-learn framework.

    .. rst-class:: annotation

      Guillaume Lebourgeois & Samuel Charron - Data Scientists at Data Publica

  .. div:: image-box

    .. image:: images/datapublica.png
      :target: http://www.data-publica.com/

`Machinalis <https://www.machinalis.com/>`_
-------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-learn is the cornerstone of all the machine learning projects carried at
    Machinalis. It has a consistent API, a wide selection of algorithms and lots of
    auxiliary tools to deal with the boilerplate. We have used it in production
    environments on a variety of projects including click-through rate prediction,
    `information extraction <https://github.com/machinalis/iepy>`_, and even counting
    sheep!

    In fact, we use it so much that we've started to freeze our common use cases
    into Python packages, some of them open-sourced, like `FeatureForge
    <https://github.com/machinalis/featureforge>`_. Scikit-learn in one word: Awesome.

    .. rst-class:: annotation

      Rafael Carrascosa, Lead developer

  .. div:: image-box

    .. image:: images/machinalis.png
      :target: https://www.machinalis.com/

`solido <https://www.solidodesign.com/>`_
-----------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-learn is helping to drive Moore's Law, via Solido. Solido creates
    computer-aided design tools used by the majority of top-20 semiconductor
    companies and fabs, to design the bleeding-edge chips inside smartphones,
    automobiles, and more. Scikit-learn helps to power Solido's algorithms for
    rare-event estimation, worst-case verification, optimization, and more. At
    Solido, we are particularly fond of scikit-learn's libraries for Gaussian
    Process models, large-scale regularized linear regression, and classification.
    Scikit-learn has increased our productivity, because for many ML problems we no
    longer need to “roll our own” code. `This PyData 2014 talk
    <https://www.youtube.com/watch?v=Jm-eBD9xR3w>`_ has details.

    .. rst-class:: annotation

      Trent McConaghy, founder, Solido Design Automation Inc.

  .. div:: image-box

    .. image:: images/solido_logo.png
      :target: https://www.solidodesign.com/

`INFONEA <http://www.infonea.com/en/>`_
---------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    We employ scikit-learn for rapid prototyping and custom-made Data Science
    solutions within our in-memory based Business Intelligence Software
    INFONEA®. As a well-documented and comprehensive collection of
    state-of-the-art algorithms and pipelining methods, scikit-learn enables
    us to provide flexible and scalable scientific analysis solutions. Thus,
    scikit-learn is immensely valuable in realizing a powerful integration of
    Data Science technology within self-service business analytics.

    .. rst-class:: annotation

      Thorsten Kranz, Data Scientist, Coma Soft AG.

  .. div:: image-box

    .. image:: images/infonea.jpg
      :target: http://www.infonea.com/en/

`Dataiku <https://www.dataiku.com/>`_
-------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Our software, Data Science Studio (DSS), enables users to create data services
    that combine `ETL <https://en.wikipedia.org/wiki/Extract,_transform,_load>`_ with
    Machine Learning. Our Machine Learning module integrates
    many scikit-learn algorithms. The scikit-learn library is a perfect integration
    with DSS because it offers algorithms for virtually all business cases. Our goal
    is to offer a transparent and flexible tool that makes it easier to optimize
    time consuming aspects of building a data service, preparing data, and training
    machine learning algorithms on all types of data.

    .. rst-class:: annotation

      Florian Douetteau, CEO, Dataiku

  .. div:: image-box

    .. image:: images/dataiku_logo.png
      :target: https://www.dataiku.com/

`Otto Group <https://ottogroup.com/>`_
--------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Here at Otto Group, one of global Big Five B2C online retailers, we are using
    scikit-learn in all aspects of our daily work from data exploration to development
    of machine learning application to the productive deployment of those services.
    It helps us to tackle machine learning problems ranging from e-commerce to logistics.
    It consistent APIs enabled us to build the `Palladium REST-API framework
    <https://github.com/ottogroup/palladium/>`_ around it and continuously deliver
    scikit-learn based services.

    .. rst-class:: annotation

      Christian Rammig, Head of Data Science, Otto Group

  .. div:: image-box

    .. image:: images/ottogroup_logo.png
      :target: https://ottogroup.com

`Zopa <https://zopa.com/>`_
---------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    At Zopa, the first ever Peer-to-Peer lending platform, we extensively use
    scikit-learn to run the business and optimize our users' experience. It powers our
    Machine Learning models involved in credit risk, fraud risk, marketing, and pricing,
    and has been used for originating at least 1 billion GBP worth of Zopa loans. It is
    very well documented, powerful, and simple to use. We are grateful for the
    capabilities it has provided, and for allowing us to deliver on our mission of
    making money simple and fair.

    .. rst-class:: annotation

      Vlasios Vasileiou, Head of Data Science, Zopa

  .. div:: image-box

    .. image:: images/zopa.png
      :target: https://zopa.com

`MARS <https://www.mars.com/global>`_
-------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    Scikit-Learn is integral to the Machine Learning Ecosystem at Mars. Whether
    we're designing better recipes for petfood or closely analysing our cocoa
    supply chain, Scikit-Learn is used as a tool for rapidly prototyping ideas
    and taking them to production. This allows us to better understand and meet
    the needs of our consumers worldwide. Scikit-Learn's feature-rich toolset is
    easy to use and equips our associates with the capabilities they need to
    solve the business challenges they face every day.

    .. rst-class:: annotation

      Michael Fitzke, Next Generation Technologies Sr Leader, Mars Inc.

  .. div:: image-box

    .. image:: images/mars.png
      :target: https://www.mars.com/global

`BNP Paribas Cardif <https://www.bnpparibascardif.com/>`_
---------------------------------------------------------

.. div:: sk-text-image-grid-large

  .. div:: text-box

    BNP Paribas Cardif uses scikit-learn for several of its machine learning models
    in production. Our internal community of developers and data scientists has
    been using scikit-learn since 2015, for several reasons: the quality of the
    developments, documentation and contribution governance, and the sheer size of
    the contributing community. We even explicitly mention the use of
    scikit-learn's pipelines in our internal model risk governance as one of our
    good practices to decrease operational risks and overfitting risk. As a way to
    support open source software development and in particular scikit-learn
    project, we decided to participate to scikit-learn's consortium at La Fondation
    Inria since its creation in 2018.

    .. rst-class:: annotation

      Sébastien Conort, Chief Data Scientist, BNP Paribas Cardif

  .. div:: image-box

    .. image:: images/bnp_paribas_cardif.png
      :target: https://www.bnpparibascardif.com/

orphan      title   Testimonials      testimonials                              Who is using scikit learn                               J P Morgan  https   www jpmorgan com                                                 div   sk text image grid large       div   text box      Scikit learn is an indispensable part of the Python machine learning     toolkit at JPMorgan  It is very widely used across all parts of the bank     for classification  predictive analytics  and very many other machine     learning tasks  Its straightforward API  its breadth of algorithms  and     the quality of its documentation combine to make scikit learn     simultaneously very approachable and very powerful          rst class   annotation        Stephen Simmons  VP  Athena Research  JPMorgan       div   image box         image   images jpmorgan png        target  https   www jpmorgan com    Spotify  https   www spotify com                                             div   sk text image grid large       div   text box      Scikit learn provides a toolbox with solid implementations of a bunch of     state of the art models and makes it easy to plug them into existing     applications  We ve been using it quite a lot for music recommendations at     Spotify and I think it s the most well designed ML package I ve seen so far          rst class   annotation        Erik Bernhardsson  Engineering Manager Music Discovery   Machine Learning  Spotify       div   image box         image   images spotify png        target  https   www spotify com    Inria  https   www inria fr                                          div   sk text image grid large       div   text box      At INRIA  we use scikit learn to support leading edge basic research in many     teams   Parietal  https   team inria fr parietal     for neuroimaging   Lear      https   lear inrialpes fr     for computer vision   Visages      https   team inria fr visages     for medical image analysis   Privatics      https   team inria fr privatics    for security  The project is a fantastic     tool to address difficult applications of machine learning in an academic     environment as it is performant and versatile  but all easy to use and well     documented  which makes it well suited to grad students          rst class   annotation        Ga l Varoquaux  research at Parietal       div   image box         image   images inria png        target  https   www inria fr     betaworks  https   betaworks com                                             div   sk text image grid large       div   text box      Betaworks is a NYC based startup studio that builds new products  grows     companies  and invests in others  Over the past 8 years we ve launched a     handful of social data analytics driven services  such as Bitly  Chartbeat      digg and Scale Model  Consistently the betaworks data science team uses     Scikit learn for a variety of tasks  From exploratory analysis  to product     development  it is an essential part of our toolkit  Recent uses are included     in  digg s new video recommender system      https   medium com i data the digg video recommender 2f9ade7c4ba3         and Poncho s  dynamic heuristic subspace clustering      https   medium com  DiggData scaling poncho using data ca24569d56fd             rst class   annotation        Gilad Lotan  Chief Data Scientist       div   image box         image   images betaworks png        target  https   betaworks com    Hugging Face  https   huggingface co                                                 div   sk text image grid large       div   text box      At Hugging Face we re using NLP and probabilistic models to generate     conversational Artificial intelligences that are fun to chat with  Despite using     deep neural nets for  a few  https   medium com huggingface understanding emotions from keras to pytorch 3ccb61d5a983        of our  NLP tasks  https   huggingface co coref      scikit learn is still the     bread and butter of our daily machine learning routine  The ease of use and     predictability of the interface  as well as the straightforward mathematical     explanations that are here when you need them  is the killer feature  We use a     variety of scikit learn models in production and they are also operationally very     pleasant to work with          rst class   annotation        Julien Chaumond  Chief Technology Officer       div   image box         image   images huggingface png        target  https   huggingface co    Evernote  https   evernote com                                           div   sk text image grid large       div   text box      Building a classifier is typically an iterative process of exploring     the data  selecting the features  the attributes of the data believed     to be predictive in some way   training the models  and finally     evaluating them  For many of these tasks  we relied on the excellent     scikit learn package for Python        Read more  http   blog evernote com tech 2013 01 22 stay classified             rst class   annotation        Mark Ayzenshtat  VP  Augmented Intelligence       div   image box         image   images evernote png        target  https   evernote com    T l com ParisTech  https   www telecom paristech fr                                                                  div   sk text image grid large       div   text box      At Telecom ParisTech  scikit learn is used for hands on sessions and home     assignments in introductory and advanced machine learning courses  The classes     are for undergrads and masters students  The great benefit of scikit learn is     its fast learning curve that allows students to quickly start working on     interesting and motivating problems          rst class   annotation        Alexandre Gramfort  Assistant Professor       div   image box         image   images telecomparistech jpg        target  https   www telecom paristech fr     Booking com  https   www booking com                                                 div   sk text image grid large       div   text box      At Booking com  we use machine learning algorithms for many different     applications  such as recommending hotels and destinations to our customers      detecting fraudulent reservations  or scheduling our customer service agents      Scikit learn is one of the tools we use when implementing standard algorithms     for prediction tasks  Its API and documentations are excellent and make it easy     to use  The scikit learn developers do a great job of incorporating state of     the art implementations and new algorithms into the package  Thus  scikit learn     provides convenient access to a wide spectrum of algorithms  and allows us to     readily find the right tool for the right job          rst class   annotation        Melanie Mueller  Data Scientist       div   image box         image   images booking png        target  https   www booking com    AWeber  https   www aweber com                                             div   sk text image grid large       div   text box      The scikit learn toolkit is indispensable for the Data Analysis and Management     team at AWeber   It allows us to do AWesome stuff we would not otherwise have     the time or resources to accomplish  The documentation is excellent  allowing     new engineers to quickly evaluate and apply many different algorithms to our     data  The text feature extraction utilities are useful when working with the     large volume of email content we have at AWeber  The RandomizedPCA     implementation  along with Pipelining and FeatureUnions  allows us to develop     complex machine learning algorithms efficiently and reliably       Anyone interested in learning more about how AWeber deploys scikit learn in a     production environment should check out talks from PyData Boston by AWeber s     Michael Becker available at https   github com mdbecker pydata 2013          rst class   annotation        Michael Becker  Software Engineer  Data Analysis and Management Ninjas       div   image box         image   images aweber png        target  https   www aweber com    Yhat  https   www yhat com                                       div   sk text image grid large       div   text box      The combination of consistent APIs  thorough documentation  and top notch     implementation make scikit learn our favorite machine learning package in     Python  scikit learn makes doing advanced analysis in Python accessible to     anyone  At Yhat  we make it easy to integrate these models into your production     applications  Thus eliminating the unnecessary dev time encountered     productionizing analytical work          rst class   annotation        Greg Lamp  Co founder       div   image box         image   images yhat png        target  https   www yhat com    Rangespan  http   www rangespan com                                                div   sk text image grid large       div   text box      The Python scikit learn toolkit is a core tool in the data science     group at Rangespan  Its large collection of well documented models and     algorithms allow our team of data scientists to prototype fast and     quickly iterate to find the right solution to our learning problems      We find that scikit learn is not only the right tool for prototyping      but its careful and well tested implementation give us the confidence     to run scikit learn models in production          rst class   annotation        Jurgen Van Gael  Data Science Director       div   image box         image   images rangespan png        target  http   www rangespan com    Birchbox  https   www birchbox com                                               div   sk text image grid large       div   text box      At Birchbox  we face a range of machine learning problems typical to     E commerce  product recommendation  user clustering  inventory prediction      trends detection  etc  Scikit learn lets us experiment with many models      especially in the exploration phase of a new project  the data can be passed     around in a consistent way  models are easy to save and reuse  updates keep us     informed of new developments from the pattern discovery research community      Scikit learn is an important tool for our team  built the right way in the     right language          rst class   annotation        Thierry Bertin Mahieux  Data Scientist       div   image box         image   images birchbox jpg        target  https   www birchbox com    Bestofmedia Group  http   www bestofmedia com                                                          div   sk text image grid large       div   text box      Scikit learn is our  1 toolkit for all things machine learning     at Bestofmedia  We use it for a variety of tasks  e g  spam fighting      ad click prediction  various ranking models  thanks to the varied      state of the art algorithm implementations packaged into it      In the lab it accelerates prototyping of complex pipelines  In     production I can say it has proven to be robust and efficient enough     to be deployed for business critical components          rst class   annotation        Eustache Diemert  Lead Scientist       div   image box         image   images bestofmedia logo png        target  http   www bestofmedia com    Change org  https   www change org                                               div   sk text image grid large       div   text box      At change org we automate the use of scikit learn s RandomForestClassifier     in our production systems to drive email targeting that reaches millions     of users across the world each week  In the lab  scikit learn s ease of use      performance  and overall variety of algorithms implemented has proved invaluable     in giving us a single reliable source to turn to for our machine learning needs          rst class   annotation        Vijay Ramesh  Software Engineer in Data science at Change org       div   image box         image   images change logo png        target  https   www change org    PHIMECA Engineering  https   www phimeca com  lang en                                                                  div   sk text image grid large       div   text box      At PHIMECA Engineering  we use scikit learn estimators as surrogates for     expensive to evaluate numerical models  mostly but not exclusively     finite element mechanical models  for speeding up the intensive post processing     operations involved in our simulation based decision making framework      Scikit learn s fit predict API together with its efficient cross validation     tools considerably eases the task of selecting the best fit estimator  We are     also using scikit learn for illustrating concepts in our training sessions      Trainees are always impressed by the ease of use of scikit learn despite the     apparent theoretical complexity of machine learning          rst class   annotation        Vincent Dubourg  PHIMECA Engineering  PhD Engineer       div   image box         image   images phimeca png        target  https   www phimeca com  lang en    HowAboutWe  http   www howaboutwe com                                                    div   sk text image grid large       div   text box      At HowAboutWe  scikit learn lets us implement a wide array of machine learning     techniques in analysis and in production  despite having a small team   We use     scikit learn s classification algorithms to predict user behavior  enabling us     to  for example  estimate the value of leads from a given traffic source early     in the lead s tenure on our site  Also  our users  profiles consist of     primarily unstructured data  answers to open ended questions   so we use     scikit learn s feature extraction and dimensionality reduction tools to     translate these unstructured data into inputs for our matchmaking system          rst class   annotation        Daniel Weitzenfeld  Senior Data Scientist at HowAboutWe       div   image box         image   images howaboutwe png        target  http   www howaboutwe com     PeerIndex  https   www brandwatch com peerindex and brandwatch                                                                           div   sk text image grid large       div   text box      At PeerIndex we use scientific methodology to build the Influence Graph   a     unique dataset that allows us to identify who s really influential and in which     context  To do this  we have to tackle a range of machine learning and     predictive modeling problems  Scikit learn has emerged as our primary tool for     developing prototypes and making quick progress  From predicting missing data     and classifying tweets to clustering communities of social media users  scikit      learn proved useful in a variety of applications  Its very intuitive interface     and excellent compatibility with other python tools makes it and indispensable     tool in our daily research efforts          rst class   annotation        Ferenc Huszar  Senior Data Scientist at Peerindex       div   image box         image   images peerindex png        target  https   www brandwatch com peerindex and brandwatch    DataRobot  https   www datarobot com                                                 div   sk text image grid large       div   text box      DataRobot is building next generation predictive analytics software to make data     scientists more productive  and scikit learn is an integral part of our system  The     variety of machine learning techniques in combination with the solid implementations     that scikit learn offers makes it a one stop shopping library for machine learning     in Python  Moreover  its consistent API  well tested code and permissive licensing     allow us to use it in a production environment  Scikit learn has literally saved us     years of work we would have had to do ourselves to bring our product to market          rst class   annotation        Jeremy Achin  CEO   Co founder DataRobot Inc        div   image box         image   images datarobot png        target  https   www datarobot com    OkCupid  https   www okcupid com                                               div   sk text image grid large       div   text box      We re using scikit learn at OkCupid to evaluate and improve our matchmaking     system  The range of features it has  especially preprocessing utilities  means     we can use it for a wide variety of projects  and it s performant enough to     handle the volume of data that we need to sort through  The documentation is     really thorough  as well  which makes the library quite easy to use          rst class   annotation        David Koh   Senior Data Scientist at OkCupid       div   image box         image   images okcupid png        target  https   www okcupid com    Lovely  https   livelovely com                                             div   sk text image grid large       div   text box      At Lovely  we strive to deliver the best apartment marketplace  with respect to     our users and our listings  From understanding user behavior  improving data     quality  and detecting fraud  scikit learn is a regular tool for gathering     insights  predictive modeling and improving our product  The easy to read     documentation and intuitive architecture of the API makes machine learning both     explorable and accessible to a wide range of python developers  I m constantly     recommending that more developers and scientists try scikit learn          rst class   annotation        Simon Frid   Data Scientist  Lead at Lovely       div   image box         image   images lovely png        target  https   livelovely com    Data Publica  http   www data publica com                                                        div   sk text image grid large       div   text box      Data Publica builds a new predictive sales tool for commercial and marketing teams     called C Radar  We extensively use scikit learn to build segmentations of customers     through clustering  and to predict future customers based on past partnerships     success or failure  We also categorize companies using their website communication     thanks to scikit learn and its machine learning algorithm implementations      Eventually  machine learning makes it possible to detect weak signals that     traditional tools cannot see  All these complex tasks are performed in an easy and     straightforward way thanks to the great quality of the scikit learn framework          rst class   annotation        Guillaume Lebourgeois   Samuel Charron   Data Scientists at Data Publica       div   image box         image   images datapublica png        target  http   www data publica com     Machinalis  https   www machinalis com                                                     div   sk text image grid large       div   text box      Scikit learn is the cornerstone of all the machine learning projects carried at     Machinalis  It has a consistent API  a wide selection of algorithms and lots of     auxiliary tools to deal with the boilerplate  We have used it in production     environments on a variety of projects including click through rate prediction       information extraction  https   github com machinalis iepy     and even counting     sheep       In fact  we use it so much that we ve started to freeze our common use cases     into Python packages  some of them open sourced  like  FeatureForge      https   github com machinalis featureforge     Scikit learn in one word  Awesome          rst class   annotation        Rafael Carrascosa  Lead developer       div   image box         image   images machinalis png        target  https   www machinalis com     solido  https   www solidodesign com                                                   div   sk text image grid large       div   text box      Scikit learn is helping to drive Moore s Law  via Solido  Solido creates     computer aided design tools used by the majority of top 20 semiconductor     companies and fabs  to design the bleeding edge chips inside smartphones      automobiles  and more  Scikit learn helps to power Solido s algorithms for     rare event estimation  worst case verification  optimization  and more  At     Solido  we are particularly fond of scikit learn s libraries for Gaussian     Process models  large scale regularized linear regression  and classification      Scikit learn has increased our productivity  because for many ML problems we no     longer need to  roll our own  code   This PyData 2014 talk      https   www youtube com watch v Jm eBD9xR3w    has details          rst class   annotation        Trent McConaghy  founder  Solido Design Automation Inc        div   image box         image   images solido logo png        target  https   www solidodesign com     INFONEA  http   www infonea com en                                                 div   sk text image grid large       div   text box      We employ scikit learn for rapid prototyping and custom made Data Science     solutions within our in memory based Business Intelligence Software     INFONEA   As a well documented and comprehensive collection of     state of the art algorithms and pipelining methods  scikit learn enables     us to provide flexible and scalable scientific analysis solutions  Thus      scikit learn is immensely valuable in realizing a powerful integration of     Data Science technology within self service business analytics          rst class   annotation        Thorsten Kranz  Data Scientist  Coma Soft AG        div   image box         image   images infonea jpg        target  http   www infonea com en     Dataiku  https   www dataiku com                                               div   sk text image grid large       div   text box      Our software  Data Science Studio  DSS   enables users to create data services     that combine  ETL  https   en wikipedia org wiki Extract  transform  load    with     Machine Learning  Our Machine Learning module integrates     many scikit learn algorithms  The scikit learn library is a perfect integration     with DSS because it offers algorithms for virtually all business cases  Our goal     is to offer a transparent and flexible tool that makes it easier to optimize     time consuming aspects of building a data service  preparing data  and training     machine learning algorithms on all types of data          rst class   annotation        Florian Douetteau  CEO  Dataiku       div   image box         image   images dataiku logo png        target  https   www dataiku com     Otto Group  https   ottogroup com                                                div   sk text image grid large       div   text box      Here at Otto Group  one of global Big Five B2C online retailers  we are using     scikit learn in all aspects of our daily work from data exploration to development     of machine learning application to the productive deployment of those services      It helps us to tackle machine learning problems ranging from e commerce to logistics      It consistent APIs enabled us to build the  Palladium REST API framework      https   github com ottogroup palladium     around it and continuously deliver     scikit learn based services          rst class   annotation        Christian Rammig  Head of Data Science  Otto Group       div   image box         image   images ottogroup logo png        target  https   ottogroup com    Zopa  https   zopa com                                     div   sk text image grid large       div   text box      At Zopa  the first ever Peer to Peer lending platform  we extensively use     scikit learn to run the business and optimize our users  experience  It powers our     Machine Learning models involved in credit risk  fraud risk  marketing  and pricing      and has been used for originating at least 1 billion GBP worth of Zopa loans  It is     very well documented  powerful  and simple to use  We are grateful for the     capabilities it has provided  and for allowing us to deliver on our mission of     making money simple and fair          rst class   annotation        Vlasios Vasileiou  Head of Data Science  Zopa       div   image box         image   images zopa png        target  https   zopa com    MARS  https   www mars com global                                              div   sk text image grid large       div   text box      Scikit Learn is integral to the Machine Learning Ecosystem at Mars  Whether     we re designing better recipes for petfood or closely analysing our cocoa     supply chain  Scikit Learn is used as a tool for rapidly prototyping ideas     and taking them to production  This allows us to better understand and meet     the needs of our consumers worldwide  Scikit Learn s feature rich toolset is     easy to use and equips our associates with the capabilities they need to     solve the business challenges they face every day          rst class   annotation        Michael Fitzke  Next Generation Technologies Sr Leader  Mars Inc        div   image box         image   images mars png        target  https   www mars com global    BNP Paribas Cardif  https   www bnpparibascardif com                                                                   div   sk text image grid large       div   text box      BNP Paribas Cardif uses scikit learn for several of its machine learning models     in production  Our internal community of developers and data scientists has     been using scikit learn since 2015  for several reasons  the quality of the     developments  documentation and contribution governance  and the sheer size of     the contributing community  We even explicitly mention the use of     scikit learn s pipelines in our internal model risk governance as one of our     good practices to decrease operational risks and overfitting risk  As a way to     support open source software development and in particular scikit learn     project  we decided to participate to scikit learn s consortium at La Fondation     Inria since its creation in 2018          rst class   annotation        S bastien Conort  Chief Data Scientist  BNP Paribas Cardif       div   image box         image   images bnp paribas cardif png        target  https   www bnpparibascardif com