forked from scikit-learn/scikit-learn.github.io
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathglossary.html
1793 lines (1758 loc) · 177 KB
/
glossary.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Glossary of Common Terms and API Elements — scikit-learn 1.0.dev0 documentation</title>
<link rel="canonical" href="http://scikit-learn.org/stable/glossary.html" />
<link rel="shortcut icon" href="_static/favicon.ico"/>
<link rel="stylesheet" href="_static/css/vendor/bootstrap.min.css" type="text/css" />
<link rel="stylesheet" href="_static/gallery.css" type="text/css" />
<link rel="stylesheet" href="_static/gallery-binder.css" type="text/css" />
<link rel="stylesheet" href="_static/gallery-dataframe.css" type="text/css" />
<link rel="stylesheet" href="_static/gallery-rendered-html.css" type="text/css" />
<link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
<script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
<script src="_static/jquery.js"></script>
</head>
<body>
<nav id="navbar" class="sk-docs-navbar navbar navbar-expand-md navbar-light bg-light py-0">
<div class="container-fluid sk-docs-container px-0">
<a class="navbar-brand py-0" href="index.html">
<img
class="sk-brand-img"
src="_static/scikit-learn-logo-small.png"
alt="logo"/>
</a>
<button
id="sk-navbar-toggler"
class="navbar-toggler"
type="button"
data-toggle="collapse"
data-target="#navbarSupportedContent"
aria-controls="navbarSupportedContent"
aria-expanded="false"
aria-label="Toggle navigation"
>
<span class="navbar-toggler-icon"></span>
</button>
<div class="sk-navbar-collapse collapse navbar-collapse" id="navbarSupportedContent">
<ul class="navbar-nav mr-auto">
<li class="nav-item">
<a class="sk-nav-link nav-link" href="install.html">Install</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link" href="user_guide.html">User Guide</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link" href="modules/classes.html">API</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link" href="auto_examples/index.html">Examples</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="getting_started.html">Getting Started</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="tutorial/index.html">Tutorial</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="whats_new/v1.0.html">What's new</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="#">Glossary</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="developers/index.html">Development</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="faq.html">FAQ</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="support.html">Support</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="related_projects.html">Related packages</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="roadmap.html">Roadmap</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="about.html">About us</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="https://github.com/scikit-learn/scikit-learn">GitHub</a>
</li>
<li class="nav-item">
<a class="sk-nav-link nav-link nav-more-item-mobile-items" href="https://scikit-learn.org/dev/versions.html">Other Versions and Download</a>
</li>
<li class="nav-item dropdown nav-more-item-dropdown">
<a class="sk-nav-link nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">More</a>
<div class="dropdown-menu" aria-labelledby="navbarDropdown">
<a class="sk-nav-dropdown-item dropdown-item" href="getting_started.html">Getting Started</a>
<a class="sk-nav-dropdown-item dropdown-item" href="tutorial/index.html">Tutorial</a>
<a class="sk-nav-dropdown-item dropdown-item" href="whats_new/v1.0.html">What's new</a>
<a class="sk-nav-dropdown-item dropdown-item" href="#">Glossary</a>
<a class="sk-nav-dropdown-item dropdown-item" href="developers/index.html">Development</a>
<a class="sk-nav-dropdown-item dropdown-item" href="faq.html">FAQ</a>
<a class="sk-nav-dropdown-item dropdown-item" href="support.html">Support</a>
<a class="sk-nav-dropdown-item dropdown-item" href="related_projects.html">Related packages</a>
<a class="sk-nav-dropdown-item dropdown-item" href="roadmap.html">Roadmap</a>
<a class="sk-nav-dropdown-item dropdown-item" href="about.html">About us</a>
<a class="sk-nav-dropdown-item dropdown-item" href="https://github.com/scikit-learn/scikit-learn">GitHub</a>
<a class="sk-nav-dropdown-item dropdown-item" href="https://scikit-learn.org/dev/versions.html">Other Versions and Download</a>
</div>
</li>
</ul>
<div id="searchbox" role="search">
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input class="sk-search-text-input" type="text" name="q" aria-labelledby="searchlabel" />
<input class="sk-search-text-btn" type="submit" value="Go" />
</form>
</div>
</div>
</div>
</div>
</nav>
<div class="d-flex" id="sk-doc-wrapper">
<input type="checkbox" name="sk-toggle-checkbox" id="sk-toggle-checkbox">
<label id="sk-sidemenu-toggle" class="sk-btn-toggle-toc btn sk-btn-primary" for="sk-toggle-checkbox">Toggle Menu</label>
<div id="sk-sidebar-wrapper" class="border-right">
<div class="sk-sidebar-toc-wrapper">
<div class="sk-sidebar-toc-logo">
<a href="index.html">
<img
class="sk-brand-img"
src="_static/scikit-learn-logo-small.png"
alt="logo"/>
</a>
</div>
<div class="btn-group w-100 mb-2" role="group" aria-label="rellinks">
<a href="common_pitfalls.html" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="10. Common pitfalls and recommended practices">Prev</a>
<a href="#" role="button" class="btn sk-btn-rellink disabled py-1">Up</a>
<a href="auto_examples/index.html" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="Examples">Next</a>
</div>
<div class="alert alert-danger p-1 mb-2" role="alert">
<p class="text-center mb-0">
<strong>scikit-learn 1.0.dev0</strong><br/>
<a href="http://scikit-learn.org/dev/versions.html">Other versions</a>
</p>
</div>
<div class="alert alert-warning p-1 mb-2" role="alert">
<p class="text-center mb-0">
Please <a class="font-weight-bold" href="about.html#citing-scikit-learn"><string>cite us</string></a> if you use the software.
</p>
</div>
<div class="sk-sidebar-toc">
<ul>
<li><a class="reference internal" href="#">Glossary of Common Terms and API Elements</a><ul>
<li><a class="reference internal" href="#general-concepts">General Concepts</a></li>
<li><a class="reference internal" href="#class-apis-and-estimator-types">Class APIs and Estimator Types</a></li>
<li><a class="reference internal" href="#target-types">Target Types</a></li>
<li><a class="reference internal" href="#methods">Methods</a></li>
<li><a class="reference internal" href="#parameters">Parameters</a></li>
<li><a class="reference internal" href="#attributes">Attributes</a></li>
<li><a class="reference internal" href="#data-and-sample-properties">Data and sample properties</a></li>
</ul>
</li>
</ul>
</div>
</div>
</div>
<div id="sk-page-content-wrapper">
<div class="sk-page-content container-fluid body px-md-3" role="main">
<div class="section" id="glossary-of-common-terms-and-api-elements">
<span id="glossary"></span><h1>Glossary of Common Terms and API Elements<a class="headerlink" href="#glossary-of-common-terms-and-api-elements" title="Permalink to this headline">¶</a></h1>
<p>This glossary hopes to definitively represent the tacit and explicit
conventions applied in Scikit-learn and its API, while providing a reference
for users and contributors. It aims to describe the concepts and either detail
their corresponding API or link to other relevant parts of the documentation
which do so. By linking to glossary entries from the API Reference and User
Guide, we may minimize redundancy and inconsistency.</p>
<p>We begin by listing general concepts (and any that didn’t fit elsewhere), but
more specific sets of related terms are listed below:
<a class="reference internal" href="#glossary-estimator-types"><span class="std std-ref">Class APIs and Estimator Types</span></a>, <a class="reference internal" href="#glossary-target-types"><span class="std std-ref">Target Types</span></a>,
<a class="reference internal" href="#glossary-methods"><span class="std std-ref">Methods</span></a>, <a class="reference internal" href="#glossary-parameters"><span class="std std-ref">Parameters</span></a>,
<a class="reference internal" href="#glossary-attributes"><span class="std std-ref">Attributes</span></a>, <a class="reference internal" href="#glossary-sample-props"><span class="std std-ref">Data and sample properties</span></a>.</p>
<div class="section" id="general-concepts">
<h2>General Concepts<a class="headerlink" href="#general-concepts" title="Permalink to this headline">¶</a></h2>
<dl class="glossary">
<dt id="term-1d">1d</dt><dt id="term-1d-array">1d array</dt><dd><p>One-dimensional array. A NumPy array whose <code class="docutils literal notranslate"><span class="pre">.shape</span></code> has length 1.
A vector.</p>
</dd>
<dt id="term-2d">2d</dt><dt id="term-2d-array">2d array</dt><dd><p>Two-dimensional array. A NumPy array whose <code class="docutils literal notranslate"><span class="pre">.shape</span></code> has length 2.
Often represents a matrix.</p>
</dd>
<dt id="term-API">API</dt><dd><p>Refers to both the <em>specific</em> interfaces for estimators implemented in
Scikit-learn and the <em>generalized</em> conventions across types of
estimators as described in this glossary and <a class="reference internal" href="developers/develop.html#api-overview"><span class="std std-ref">overviewed in the
contributor documentation</span></a>.</p>
<p>The specific interfaces that constitute Scikit-learn’s public API are
largely documented in <a class="reference internal" href="modules/classes.html#api-ref"><span class="std std-ref">API Reference</span></a>. However, we less formally consider
anything as public API if none of the identifiers required to access it
begins with <code class="docutils literal notranslate"><span class="pre">_</span></code>. We generally try to maintain <a class="reference internal" href="#term-backwards-compatibility"><span class="xref std std-term">backwards
compatibility</span></a> for all objects in the public API.</p>
<p>Private API, including functions, modules and methods beginning <code class="docutils literal notranslate"><span class="pre">_</span></code>
are not assured to be stable.</p>
</dd>
<dt id="term-array-like">array-like</dt><dd><p>The most common data format for <em>input</em> to Scikit-learn estimators and
functions, array-like is any type object for which
<a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.asarray.html#numpy.asarray" title="(in NumPy v1.20)"><code class="xref py py-func docutils literal notranslate"><span class="pre">numpy.asarray</span></code></a> will produce an array of appropriate shape
(usually 1 or 2-dimensional) of appropriate dtype (usually numeric).</p>
<p>This includes:</p>
<ul class="simple">
<li><p>a numpy array</p></li>
<li><p>a list of numbers</p></li>
<li><p>a list of length-k lists of numbers for some fixed length k</p></li>
<li><p>a <a class="reference external" href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html#pandas.DataFrame" title="(in pandas v1.2.1)"><code class="xref py py-class docutils literal notranslate"><span class="pre">pandas.DataFrame</span></code></a> with all columns numeric</p></li>
<li><p>a numeric <a class="reference external" href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.html#pandas.Series" title="(in pandas v1.2.1)"><code class="xref py py-class docutils literal notranslate"><span class="pre">pandas.Series</span></code></a></p></li>
</ul>
<p>It excludes:</p>
<ul class="simple">
<li><p>a <a class="reference internal" href="#term-sparse-matrix"><span class="xref std std-term">sparse matrix</span></a></p></li>
<li><p>an iterator</p></li>
<li><p>a generator</p></li>
</ul>
<p>Note that <em>output</em> from scikit-learn estimators and functions (e.g.
predictions) should generally be arrays or sparse matrices, or lists
thereof (as in multi-output <a class="reference internal" href="modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier" title="sklearn.tree.DecisionTreeClassifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">tree.DecisionTreeClassifier</span></code></a>’s
<code class="docutils literal notranslate"><span class="pre">predict_proba</span></code>). An estimator where <code class="docutils literal notranslate"><span class="pre">predict()</span></code> returns a list or
a <code class="docutils literal notranslate"><span class="pre">pandas.Series</span></code> is not valid.</p>
</dd>
<dt id="term-attribute">attribute</dt><dt id="term-attributes">attributes</dt><dd><p>We mostly use attribute to refer to how model information is stored on
an estimator during fitting. Any public attribute stored on an
estimator instance is required to begin with an alphabetic character
and end in a single underscore if it is set in <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> or
<a class="reference internal" href="#term-partial_fit"><span class="xref std std-term">partial_fit</span></a>. These are what is documented under an estimator’s
<em>Attributes</em> documentation. The information stored in attributes is
usually either: sufficient statistics used for prediction or
transformation; <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a> outputs such as <a class="reference internal" href="#term-labels_"><span class="xref std std-term">labels_</span></a> or
<a class="reference internal" href="#term-embedding_"><span class="xref std std-term">embedding_</span></a>; or diagnostic data, such as
<a class="reference internal" href="#term-feature_importances_"><span class="xref std std-term">feature_importances_</span></a>.
Common attributes are listed <a class="reference internal" href="#glossary-attributes"><span class="std std-ref">below</span></a>.</p>
<p>A public attribute may have the same name as a constructor
<a class="reference internal" href="#term-parameter"><span class="xref std std-term">parameter</span></a>, with a <code class="docutils literal notranslate"><span class="pre">_</span></code> appended. This is used to store a
validated or estimated version of the user’s input. For example,
<a class="reference internal" href="modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA" title="sklearn.decomposition.PCA"><code class="xref py py-class docutils literal notranslate"><span class="pre">decomposition.PCA</span></code></a> is constructed with an <code class="docutils literal notranslate"><span class="pre">n_components</span></code>
parameter. From this, together with other parameters and the data,
PCA estimates the attribute <code class="docutils literal notranslate"><span class="pre">n_components_</span></code>.</p>
<p>Further private attributes used in prediction/transformation/etc. may
also be set when fitting. These begin with a single underscore and are
not assured to be stable for public access.</p>
<p>A public attribute on an estimator instance that does not end in an
underscore should be the stored, unmodified value of an <code class="docutils literal notranslate"><span class="pre">__init__</span></code>
<a class="reference internal" href="#term-parameter"><span class="xref std std-term">parameter</span></a> of the same name. Because of this equivalence, these
are documented under an estimator’s <em>Parameters</em> documentation.</p>
</dd>
<dt id="term-backwards-compatibility">backwards compatibility</dt><dd><p>We generally try to maintain backward compatibility (i.e. interfaces
and behaviors may be extended but not changed or removed) from release
to release but this comes with some exceptions:</p>
<dl class="simple">
<dt>Public API only</dt><dd><p>The behavior of objects accessed through private identifiers
(those beginning <code class="docutils literal notranslate"><span class="pre">_</span></code>) may be changed arbitrarily between
versions.</p>
</dd>
<dt>As documented</dt><dd><p>We will generally assume that the users have adhered to the
documented parameter types and ranges. If the documentation asks
for a list and the user gives a tuple, we do not assure consistent
behavior from version to version.</p>
</dd>
<dt>Deprecation</dt><dd><p>Behaviors may change following a <a class="reference internal" href="#term-deprecation"><span class="xref std std-term">deprecation</span></a> period
(usually two releases long). Warnings are issued using Python’s
<a class="reference external" href="https://docs.python.org/3/library/warnings.html#module-warnings" title="(in Python v3.9)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">warnings</span></code></a> module.</p>
</dd>
<dt>Keyword arguments</dt><dd><p>We may sometimes assume that all optional parameters (other than X
and y to <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> and similar methods) are passed as keyword
arguments only and may be positionally reordered.</p>
</dd>
<dt>Bug fixes and enhancements</dt><dd><p>Bug fixes and – less often – enhancements may change the behavior
of estimators, including the predictions of an estimator trained on
the same data and <a class="reference internal" href="#term-random_state"><span class="xref std std-term">random_state</span></a>. When this happens, we
attempt to note it clearly in the changelog.</p>
</dd>
<dt>Serialization</dt><dd><p>We make no assurances that pickling an estimator in one version
will allow it to be unpickled to an equivalent model in the
subsequent version. (For estimators in the sklearn package, we
issue a warning when this unpickling is attempted, even if it may
happen to work.) See <a class="reference internal" href="modules/model_persistence.html#persistence-limitations"><span class="std std-ref">Security & maintainability limitations</span></a>.</p>
</dd>
<dt><a class="reference internal" href="modules/generated/sklearn.utils.estimator_checks.check_estimator.html#sklearn.utils.estimator_checks.check_estimator" title="sklearn.utils.estimator_checks.check_estimator"><code class="xref py py-func docutils literal notranslate"><span class="pre">utils.estimator_checks.check_estimator</span></code></a></dt><dd><p>We provide limited backwards compatibility assurances for the
estimator checks: we may add extra requirements on estimators
tested with this function, usually when these were informally
assumed but not formally tested.</p>
</dd>
</dl>
<p>Despite this informal contract with our users, the software is provided
as is, as stated in the license. When a release inadvertently
introduces changes that are not backward compatible, these are known
as software regressions.</p>
</dd>
<dt id="term-callable">callable</dt><dd><p>A function, class or an object which implements the <code class="docutils literal notranslate"><span class="pre">__call__</span></code>
method; anything that returns True when the argument of <a class="reference external" href="https://docs.python.org/3/library/functions.html#callable">callable()</a>.</p>
</dd>
<dt id="term-categorical-feature">categorical feature</dt><dd><p>A categorical or nominal <a class="reference internal" href="#term-feature"><span class="xref std std-term">feature</span></a> is one that has a
finite set of discrete values across the population of data.
These are commonly represented as columns of integers or
strings. Strings will be rejected by most scikit-learn
estimators, and integers will be treated as ordinal or
count-valued. For the use with most estimators, categorical
variables should be one-hot encoded. Notable exceptions include
tree-based models such as random forests and gradient boosting
models that often work better and faster with integer-coded
categorical variables.
<a class="reference internal" href="modules/generated/sklearn.preprocessing.OrdinalEncoder.html#sklearn.preprocessing.OrdinalEncoder" title="sklearn.preprocessing.OrdinalEncoder"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrdinalEncoder</span></code></a> helps encoding
string-valued categorical features as ordinal integers, and
<a class="reference internal" href="modules/generated/sklearn.preprocessing.OneHotEncoder.html#sklearn.preprocessing.OneHotEncoder" title="sklearn.preprocessing.OneHotEncoder"><code class="xref py py-class docutils literal notranslate"><span class="pre">OneHotEncoder</span></code></a> can be used to
one-hot encode categorical features.
See also <a class="reference internal" href="modules/preprocessing.html#preprocessing-categorical-features"><span class="std std-ref">Encoding categorical features</span></a> and the
<a class="reference external" href="https://contrib.scikit-learn.org/categorical-encoding">categorical-encoding</a>
package for tools related to encoding categorical features.</p>
</dd>
<dt id="term-clone">clone</dt><dt id="term-cloned">cloned</dt><dd><p>To copy an <a class="reference internal" href="#term-estimator-instance"><span class="xref std std-term">estimator instance</span></a> and create a new one with
identical <a class="reference internal" href="#term-parameters"><span class="xref std std-term">parameters</span></a>, but without any fitted
<a class="reference internal" href="#term-attributes"><span class="xref std std-term">attributes</span></a>, using <a class="reference internal" href="modules/generated/sklearn.base.clone.html#sklearn.base.clone" title="sklearn.base.clone"><code class="xref py py-func docutils literal notranslate"><span class="pre">clone</span></code></a>.</p>
<p>When <code class="docutils literal notranslate"><span class="pre">fit</span></code> is called, a <a class="reference internal" href="#term-meta-estimator"><span class="xref std std-term">meta-estimator</span></a> usually clones
a wrapped estimator instance before fitting the cloned instance.
(Exceptions, for legacy reasons, include
<a class="reference internal" href="modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline" title="sklearn.pipeline.Pipeline"><code class="xref py py-class docutils literal notranslate"><span class="pre">Pipeline</span></code></a> and
<a class="reference internal" href="modules/generated/sklearn.pipeline.FeatureUnion.html#sklearn.pipeline.FeatureUnion" title="sklearn.pipeline.FeatureUnion"><code class="xref py py-class docutils literal notranslate"><span class="pre">FeatureUnion</span></code></a>.)</p>
<p>If the estimator’s <code class="docutils literal notranslate"><span class="pre">random_state</span></code> parameter is an integer (or if the
estimator doesn’t have a <code class="docutils literal notranslate"><span class="pre">random_state</span></code> parameter), an <em>exact clone</em>
is returned: the clone and the original estimator will give the exact
same results. Otherwise, <em>statistical clone</em> is returned: the clone
might yield different results from the original estimator. More
details can be found in <a class="reference internal" href="common_pitfalls.html#randomness"><span class="std std-ref">Controlling randomness</span></a>.</p>
</dd>
<dt id="term-common-tests">common tests</dt><dd><p>This refers to the tests run on almost every estimator class in
Scikit-learn to check they comply with basic API conventions. They are
available for external use through
<a class="reference internal" href="modules/generated/sklearn.utils.estimator_checks.check_estimator.html#sklearn.utils.estimator_checks.check_estimator" title="sklearn.utils.estimator_checks.check_estimator"><code class="xref py py-func docutils literal notranslate"><span class="pre">utils.estimator_checks.check_estimator</span></code></a>, with most of the
implementation in <code class="docutils literal notranslate"><span class="pre">sklearn/utils/estimator_checks.py</span></code>.</p>
<p>Note: Some exceptions to the common testing regime are currently
hard-coded into the library, but we hope to replace this by marking
exceptional behaviours on the estimator using semantic <a class="reference internal" href="#term-estimator-tags"><span class="xref std std-term">estimator
tags</span></a>.</p>
</dd>
<dt id="term-deprecation">deprecation</dt><dd><p>We use deprecation to slowly violate our <a class="reference internal" href="#term-backwards-compatibility"><span class="xref std std-term">backwards
compatibility</span></a> assurances, usually to to:</p>
<ul class="simple">
<li><p>change the default value of a parameter; or</p></li>
<li><p>remove a parameter, attribute, method, class, etc.</p></li>
</ul>
<p>We will ordinarily issue a warning when a deprecated element is used,
although there may be limitations to this. For instance, we will raise
a warning when someone sets a parameter that has been deprecated, but
may not when they access that parameter’s attribute on the estimator
instance.</p>
<p>See the <a class="reference internal" href="developers/contributing.html#contributing-deprecation"><span class="std std-ref">Contributors’ Guide</span></a>.</p>
</dd>
<dt id="term-dimensionality">dimensionality</dt><dd><p>May be used to refer to the number of <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a> (i.e.
<a class="reference internal" href="#term-n_features"><span class="xref std std-term">n_features</span></a>), or columns in a 2d feature matrix.
Dimensions are, however, also used to refer to the length of a NumPy
array’s shape, distinguishing a 1d array from a 2d matrix.</p>
</dd>
<dt id="term-docstring">docstring</dt><dd><p>The embedded documentation for a module, class, function, etc., usually
in code as a string at the beginning of the object’s definition, and
accessible as the object’s <code class="docutils literal notranslate"><span class="pre">__doc__</span></code> attribute.</p>
<p>We try to adhere to <a class="reference external" href="https://www.python.org/dev/peps/pep-0257/">PEP257</a>, and follow <a class="reference external" href="https://numpydoc.readthedocs.io/en/latest/format.html">NumpyDoc
conventions</a>.</p>
</dd>
<dt id="term-double-underscore">double underscore</dt><dt id="term-double-underscore-notation">double underscore notation</dt><dd><p>When specifying parameter names for nested estimators, <code class="docutils literal notranslate"><span class="pre">__</span></code> may be
used to separate between parent and child in some contexts. The most
common use is when setting parameters through a meta-estimator with
<a class="reference internal" href="#term-set_params"><span class="xref std std-term">set_params</span></a> and hence in specifying a search grid in
<a class="reference internal" href="modules/grid_search.html#grid-search"><span class="std std-ref">parameter search</span></a>. See <a class="reference internal" href="#term-parameter"><span class="xref std std-term">parameter</span></a>.
It is also used in <a class="reference internal" href="modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline.fit" title="sklearn.pipeline.Pipeline.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">pipeline.Pipeline.fit</span></code></a> for passing
<a class="reference internal" href="#term-sample-properties"><span class="xref std std-term">sample properties</span></a> to the <code class="docutils literal notranslate"><span class="pre">fit</span></code> methods of estimators in
the pipeline.</p>
</dd>
<dt id="term-dtype">dtype</dt><dt id="term-data-type">data type</dt><dd><p>NumPy arrays assume a homogeneous data type throughout, available in
the <code class="docutils literal notranslate"><span class="pre">.dtype</span></code> attribute of an array (or sparse matrix). We generally
assume simple data types for scikit-learn data: float or integer.
We may support object or string data types for arrays before encoding
or vectorizing. Our estimators do not work with struct arrays, for
instance.</p>
<p>Our documentation can sometimes give information about the dtype
precision, e.g. <code class="docutils literal notranslate"><span class="pre">np.int32</span></code>, <code class="docutils literal notranslate"><span class="pre">np.int64</span></code>, etc. When the precision is
provided, it refers to the NumPy dtype. If an arbitrary precision is
used, the documentation will refer to dtype <code class="docutils literal notranslate"><span class="pre">integer</span></code> or <code class="docutils literal notranslate"><span class="pre">floating</span></code>.
Note that in this case, the precision can be platform dependent.
The <code class="docutils literal notranslate"><span class="pre">numeric</span></code> dtype refers to accepting both <code class="docutils literal notranslate"><span class="pre">integer</span></code> and <code class="docutils literal notranslate"><span class="pre">floating</span></code>.</p>
<p>TODO: Mention efficiency and precision issues; casting policy.</p>
</dd>
<dt id="term-duck-typing">duck typing</dt><dd><p>We try to apply <a class="reference external" href="https://en.wikipedia.org/wiki/Duck_typing">duck typing</a> to determine how to
handle some input values (e.g. checking whether a given estimator is
a classifier). That is, we avoid using <code class="docutils literal notranslate"><span class="pre">isinstance</span></code> where possible,
and rely on the presence or absence of attributes to determine an
object’s behaviour. Some nuance is required when following this
approach:</p>
<ul>
<li><p>For some estimators, an attribute may only be available once it is
<a class="reference internal" href="#term-fitted"><span class="xref std std-term">fitted</span></a>. For instance, we cannot a priori determine if
<a class="reference internal" href="#term-predict_proba"><span class="xref std std-term">predict_proba</span></a> is available in a grid search where the grid
includes alternating between a probabilistic and a non-probabilistic
predictor in the final step of the pipeline. In the following, we
can only determine if <code class="docutils literal notranslate"><span class="pre">clf</span></code> is probabilistic after fitting it on
some data:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">sklearn.model_selection</span> <span class="kn">import</span> <span class="n">GridSearchCV</span>
<span class="gp">>>> </span><span class="kn">from</span> <span class="nn">sklearn.linear_model</span> <span class="kn">import</span> <span class="n">SGDClassifier</span>
<span class="gp">>>> </span><span class="n">clf</span> <span class="o">=</span> <span class="n">GridSearchCV</span><span class="p">(</span><span class="n">SGDClassifier</span><span class="p">(),</span>
<span class="gp">... </span> <span class="n">param_grid</span><span class="o">=</span><span class="p">{</span><span class="s1">'loss'</span><span class="p">:</span> <span class="p">[</span><span class="s1">'log'</span><span class="p">,</span> <span class="s1">'hinge'</span><span class="p">]})</span>
</pre></div>
</div>
<p>This means that we can only check for duck-typed attributes after
fitting, and that we must be careful to make <a class="reference internal" href="#term-meta-estimators"><span class="xref std std-term">meta-estimators</span></a>
only present attributes according to the state of the underlying
estimator after fitting.</p>
</li>
<li><p>Checking if an attribute is present (using <code class="docutils literal notranslate"><span class="pre">hasattr</span></code>) is in general
just as expensive as getting the attribute (<code class="docutils literal notranslate"><span class="pre">getattr</span></code> or dot
notation). In some cases, getting the attribute may indeed be
expensive (e.g. for some implementations of
<a class="reference internal" href="#term-feature_importances_"><span class="xref std std-term">feature_importances_</span></a>, which may suggest this is an API design
flaw). So code which does <code class="docutils literal notranslate"><span class="pre">hasattr</span></code> followed by <code class="docutils literal notranslate"><span class="pre">getattr</span></code> should
be avoided; <code class="docutils literal notranslate"><span class="pre">getattr</span></code> within a try-except block is preferred.</p></li>
<li><p>For determining some aspects of an estimator’s expectations or
support for some feature, we use <a class="reference internal" href="#term-estimator-tags"><span class="xref std std-term">estimator tags</span></a> instead of
duck typing.</p></li>
</ul>
</dd>
<dt id="term-early-stopping">early stopping</dt><dd><p>This consists in stopping an iterative optimization method before the
convergence of the training loss, to avoid over-fitting. This is
generally done by monitoring the generalization score on a validation
set. When available, it is activated through the parameter
<code class="docutils literal notranslate"><span class="pre">early_stopping</span></code> or by setting a positive <a class="reference internal" href="#term-n_iter_no_change"><span class="xref std std-term">n_iter_no_change</span></a>.</p>
</dd>
<dt id="term-estimator-instance">estimator instance</dt><dd><p>We sometimes use this terminology to distinguish an <a class="reference internal" href="#term-estimator"><span class="xref std std-term">estimator</span></a>
class from a constructed instance. For example, in the following,
<code class="docutils literal notranslate"><span class="pre">cls</span></code> is an estimator class, while <code class="docutils literal notranslate"><span class="pre">est1</span></code> and <code class="docutils literal notranslate"><span class="pre">est2</span></code> are
instances:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="bp">cls</span> <span class="o">=</span> <span class="n">RandomForestClassifier</span>
<span class="n">est1</span> <span class="o">=</span> <span class="bp">cls</span><span class="p">()</span>
<span class="n">est2</span> <span class="o">=</span> <span class="n">RandomForestClassifier</span><span class="p">()</span>
</pre></div>
</div>
</dd>
<dt id="term-examples">examples</dt><dd><p>We try to give examples of basic usage for most functions and
classes in the API:</p>
<ul class="simple">
<li><p>as doctests in their docstrings (i.e. within the <code class="docutils literal notranslate"><span class="pre">sklearn/</span></code> library
code itself).</p></li>
<li><p>as examples in the <a class="reference internal" href="auto_examples/index.html#general-examples"><span class="std std-ref">example gallery</span></a>
rendered (using <a class="reference external" href="https://sphinx-gallery.readthedocs.io/">sphinx-gallery</a>) from scripts in the
<code class="docutils literal notranslate"><span class="pre">examples/</span></code> directory, exemplifying key features or parameters
of the estimator/function. These should also be referenced from the
User Guide.</p></li>
<li><p>sometimes in the <a class="reference internal" href="user_guide.html#user-guide"><span class="std std-ref">User Guide</span></a> (built from <code class="docutils literal notranslate"><span class="pre">doc/</span></code>)
alongside a technical description of the estimator.</p></li>
</ul>
</dd>
<dt id="term-experimental">experimental</dt><dd><p>An experimental tool is already usable but its public API, such as
default parameter values or fitted attributes, is still subject to
change in future versions without the usual <a class="reference internal" href="#term-deprecation"><span class="xref std std-term">deprecation</span></a>
warning policy.</p>
</dd>
<dt id="term-evaluation-metric">evaluation metric</dt><dt id="term-evaluation-metrics">evaluation metrics</dt><dd><p>Evaluation metrics give a measure of how well a model performs. We may
use this term specifically to refer to the functions in <code class="xref py py-mod docutils literal notranslate"><span class="pre">metrics</span></code>
(disregarding <code class="xref py py-mod docutils literal notranslate"><span class="pre">metrics.pairwise</span></code>), as distinct from the
<a class="reference internal" href="#term-score"><span class="xref std std-term">score</span></a> method and the <a class="reference internal" href="#term-scoring"><span class="xref std std-term">scoring</span></a> API used in cross
validation. See <a class="reference internal" href="modules/model_evaluation.html#model-evaluation"><span class="std std-ref">Metrics and scoring: quantifying the quality of predictions</span></a>.</p>
<p>These functions usually accept a ground truth (or the raw data
where the metric evaluates clustering without a ground truth) and a
prediction, be it the output of <a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a> (<code class="docutils literal notranslate"><span class="pre">y_pred</span></code>),
of <a class="reference internal" href="#term-predict_proba"><span class="xref std std-term">predict_proba</span></a> (<code class="docutils literal notranslate"><span class="pre">y_proba</span></code>), or of an arbitrary score
function including <a class="reference internal" href="#term-decision_function"><span class="xref std std-term">decision_function</span></a> (<code class="docutils literal notranslate"><span class="pre">y_score</span></code>).
Functions are usually named to end with <code class="docutils literal notranslate"><span class="pre">_score</span></code> if a greater
score indicates a better model, and <code class="docutils literal notranslate"><span class="pre">_loss</span></code> if a lesser score
indicates a better model. This diversity of interface motivates
the scoring API.</p>
<p>Note that some estimators can calculate metrics that are not included
in <code class="xref py py-mod docutils literal notranslate"><span class="pre">metrics</span></code> and are estimator-specific, notably model
likelihoods.</p>
</dd>
<dt id="term-estimator-tags">estimator tags</dt><dd><p>A proposed feature (e.g. <a class="reference external" href="https://github.com/scikit-learn/scikit-learn/issues/8022">#8022</a>) by which the capabilities of an
estimator are described through a set of semantic tags. This would
enable some runtime behaviors based on estimator inspection, but it
also allows each estimator to be tested for appropriate invariances
while being excepted from other <a class="reference internal" href="#term-common-tests"><span class="xref std std-term">common tests</span></a>.</p>
<p>Some aspects of estimator tags are currently determined through
the <a class="reference internal" href="#term-duck-typing"><span class="xref std std-term">duck typing</span></a> of methods like <code class="docutils literal notranslate"><span class="pre">predict_proba</span></code> and through
some special attributes on estimator objects:</p>
<dl class="glossary">
<dt id="term-_estimator_type"><code class="docutils literal notranslate"><span class="pre">_estimator_type</span></code></dt><dd><p>This string-valued attribute identifies an estimator as being a
classifier, regressor, etc. It is set by mixins such as
<a class="reference internal" href="modules/generated/sklearn.base.ClassifierMixin.html#sklearn.base.ClassifierMixin" title="sklearn.base.ClassifierMixin"><code class="xref py py-class docutils literal notranslate"><span class="pre">base.ClassifierMixin</span></code></a>, but needs to be more explicitly
adopted on a <a class="reference internal" href="#term-meta-estimator"><span class="xref std std-term">meta-estimator</span></a>. Its value should usually be
checked by way of a helper such as <a class="reference internal" href="modules/generated/sklearn.base.is_classifier.html#sklearn.base.is_classifier" title="sklearn.base.is_classifier"><code class="xref py py-func docutils literal notranslate"><span class="pre">base.is_classifier</span></code></a>.</p>
</dd>
<dt id="term-_pairwise"><code class="docutils literal notranslate"><span class="pre">_pairwise</span></code></dt><dd><p>This boolean attribute indicates whether the data (<code class="docutils literal notranslate"><span class="pre">X</span></code>) passed to
<code class="xref py py-func docutils literal notranslate"><span class="pre">fit</span></code> and similar methods consists of pairwise measures over
samples rather than a feature representation for each sample. It
is usually <code class="docutils literal notranslate"><span class="pre">True</span></code> where an estimator has a <code class="docutils literal notranslate"><span class="pre">metric</span></code> or
<code class="docutils literal notranslate"><span class="pre">affinity</span></code> or <code class="docutils literal notranslate"><span class="pre">kernel</span></code> parameter with value ‘precomputed’.
Its primary purpose is that when a <a class="reference internal" href="#term-meta-estimator"><span class="xref std std-term">meta-estimator</span></a>
extracts a sub-sample of data intended for a pairwise estimator,
the data needs to be indexed on both axes, while other data is
indexed only on the first axis.</p>
<div class="deprecated">
<p><span class="versionmodified deprecated">Deprecated since version 0.24: </span>The _pairwise attribute is deprecated in 0.24. From 1.1
(renaming of 0.26) onward, the <code class="docutils literal notranslate"><span class="pre">pairwise</span></code> estimator tag
should be used instead.</p>
</div>
</dd>
</dl>
<p>For more detailed info, see <a class="reference internal" href="developers/develop.html#estimator-tags"><span class="std std-ref">Estimator Tags</span></a>.</p>
</dd>
<dt id="term-feature">feature</dt><dt id="term-features">features</dt><dt id="term-feature-vector">feature vector</dt><dd><p>In the abstract, a feature is a function (in its mathematical sense)
mapping a sampled object to a numeric or categorical quantity.
“Feature” is also commonly used to refer to these quantities, being the
individual elements of a vector representing a sample. In a data
matrix, features are represented as columns: each column contains the
result of applying a feature function to a set of samples.</p>
<p>Elsewhere features are known as attributes, predictors, regressors, or
independent variables.</p>
<p>Nearly all estimators in scikit-learn assume that features are numeric,
finite and not missing, even when they have semantically distinct
domains and distributions (categorical, ordinal, count-valued,
real-valued, interval). See also <a class="reference internal" href="#term-categorical-feature"><span class="xref std std-term">categorical feature</span></a> and
<a class="reference internal" href="#term-missing-values"><span class="xref std std-term">missing values</span></a>.</p>
<p><code class="docutils literal notranslate"><span class="pre">n_features</span></code> indicates the number of features in a dataset.</p>
</dd>
<dt id="term-fitting">fitting</dt><dd><p>Calling <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> (or <a class="reference internal" href="#term-fit_transform"><span class="xref std std-term">fit_transform</span></a>, <a class="reference internal" href="#term-fit_predict"><span class="xref std std-term">fit_predict</span></a>,
etc.) on an estimator.</p>
</dd>
<dt id="term-fitted">fitted</dt><dd><p>The state of an estimator after <a class="reference internal" href="#term-fitting"><span class="xref std std-term">fitting</span></a>.</p>
<p>There is no conventional procedure for checking if an estimator
is fitted. However, an estimator that is not fitted:</p>
<ul class="simple">
<li><p>should raise <a class="reference internal" href="modules/generated/sklearn.exceptions.NotFittedError.html#sklearn.exceptions.NotFittedError" title="sklearn.exceptions.NotFittedError"><code class="xref py py-class docutils literal notranslate"><span class="pre">exceptions.NotFittedError</span></code></a> when a prediction
method (<a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a>, <a class="reference internal" href="#term-transform"><span class="xref std std-term">transform</span></a>, etc.) is called.
(<a class="reference internal" href="modules/generated/sklearn.utils.validation.check_is_fitted.html#sklearn.utils.validation.check_is_fitted" title="sklearn.utils.validation.check_is_fitted"><code class="xref py py-func docutils literal notranslate"><span class="pre">utils.validation.check_is_fitted</span></code></a> is used internally
for this purpose.)</p></li>
<li><p>should not have any <a class="reference internal" href="#term-attributes"><span class="xref std std-term">attributes</span></a> beginning with an alphabetic
character and ending with an underscore. (Note that a descriptor for
the attribute may still be present on the class, but hasattr should
return False)</p></li>
</ul>
</dd>
<dt id="term-function">function</dt><dd><p>We provide ad hoc function interfaces for many algorithms, while
<a class="reference internal" href="#term-estimator"><span class="xref std std-term">estimator</span></a> classes provide a more consistent interface.</p>
<p>In particular, Scikit-learn may provide a function interface that fits
a model to some data and returns the learnt model parameters, as in
<a class="reference internal" href="modules/generated/sklearn.linear_model.enet_path.html#sklearn.linear_model.enet_path" title="sklearn.linear_model.enet_path"><code class="xref py py-func docutils literal notranslate"><span class="pre">linear_model.enet_path</span></code></a>. For transductive models, this also
returns the embedding or cluster labels, as in
<a class="reference internal" href="modules/generated/sklearn.manifold.spectral_embedding.html#sklearn.manifold.spectral_embedding" title="sklearn.manifold.spectral_embedding"><code class="xref py py-func docutils literal notranslate"><span class="pre">manifold.spectral_embedding</span></code></a> or <a class="reference internal" href="modules/generated/dbscan-function.html#sklearn.cluster.dbscan" title="sklearn.cluster.dbscan"><code class="xref py py-func docutils literal notranslate"><span class="pre">cluster.dbscan</span></code></a>. Many
preprocessing transformers also provide a function interface, akin to
calling <a class="reference internal" href="#term-fit_transform"><span class="xref std std-term">fit_transform</span></a>, as in
<a class="reference internal" href="modules/generated/sklearn.preprocessing.maxabs_scale.html#sklearn.preprocessing.maxabs_scale" title="sklearn.preprocessing.maxabs_scale"><code class="xref py py-func docutils literal notranslate"><span class="pre">preprocessing.maxabs_scale</span></code></a>. Users should be careful to avoid
<a class="reference internal" href="#term-data-leakage"><span class="xref std std-term">data leakage</span></a> when making use of these
<code class="docutils literal notranslate"><span class="pre">fit_transform</span></code>-equivalent functions.</p>
<p>We do not have a strict policy about when to or when not to provide
function forms of estimators, but maintainers should consider
consistency with existing interfaces, and whether providing a function
would lead users astray from best practices (as regards data leakage,
etc.)</p>
</dd>
<dt id="term-gallery">gallery</dt><dd><p>See <a class="reference internal" href="#term-examples"><span class="xref std std-term">examples</span></a>.</p>
</dd>
<dt id="term-hyperparameter">hyperparameter</dt><dt id="term-hyper-parameter">hyper-parameter</dt><dd><p>See <a class="reference internal" href="#term-parameter"><span class="xref std std-term">parameter</span></a>.</p>
</dd>
<dt id="term-impute">impute</dt><dt id="term-imputation">imputation</dt><dd><p>Most machine learning algorithms require that their inputs have no
<a class="reference internal" href="#term-missing-values"><span class="xref std std-term">missing values</span></a>, and will not work if this requirement is
violated. Algorithms that attempt to fill in (or impute) missing values
are referred to as imputation algorithms.</p>
</dd>
<dt id="term-indexable">indexable</dt><dd><p>An <a class="reference internal" href="#term-array-like"><span class="xref std std-term">array-like</span></a>, <a class="reference internal" href="#term-sparse-matrix"><span class="xref std std-term">sparse matrix</span></a>, pandas DataFrame or
sequence (usually a list).</p>
</dd>
<dt id="term-induction">induction</dt><dt id="term-inductive">inductive</dt><dd><p>Inductive (contrasted with <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a>) machine learning
builds a model of some data that can then be applied to new instances.
Most estimators in Scikit-learn are inductive, having <a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a>
and/or <a class="reference internal" href="#term-transform"><span class="xref std std-term">transform</span></a> methods.</p>
</dd>
<dt id="term-joblib">joblib</dt><dd><p>A Python library (<a class="reference external" href="https://joblib.readthedocs.io">https://joblib.readthedocs.io</a>) used in Scikit-learn to
facilite simple parallelism and caching. Joblib is oriented towards
efficiently working with numpy arrays, such as through use of
<a class="reference internal" href="#term-memory-mapping"><span class="xref std std-term">memory mapping</span></a>. See <a class="reference internal" href="computing/parallelism.html#parallelism"><span class="std std-ref">Parallelism</span></a> for more
information.</p>
</dd>
<dt id="term-label-indicator-matrix">label indicator matrix</dt><dt id="term-multilabel-indicator-matrix">multilabel indicator matrix</dt><dt id="term-multilabel-indicator-matrices">multilabel indicator matrices</dt><dd><p>The format used to represent multilabel data, where each row of a 2d
array or sparse matrix corresponds to a sample, each column
corresponds to a class, and each element is 1 if the sample is labeled
with the class and 0 if not.</p>
</dd>
<dt id="term-leakage">leakage</dt><dt id="term-data-leakage">data leakage</dt><dd><p>A problem in cross validation where generalization performance can be
over-estimated since knowledge of the test data was inadvertently
included in training a model. This is a risk, for instance, when
applying a <a class="reference internal" href="#term-transformer"><span class="xref std std-term">transformer</span></a> to the entirety of a dataset rather
than each training portion in a cross validation split.</p>
<p>We aim to provide interfaces (such as <code class="xref py py-mod docutils literal notranslate"><span class="pre">pipeline</span></code> and
<code class="xref py py-mod docutils literal notranslate"><span class="pre">model_selection</span></code>) that shield the user from data leakage.</p>
</dd>
<dt id="term-memmapping">memmapping</dt><dt id="term-memory-map">memory map</dt><dt id="term-memory-mapping">memory mapping</dt><dd><p>A memory efficiency strategy that keeps data on disk rather than
copying it into main memory. Memory maps can be created for arrays
that can be read, written, or both, using <a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.memmap.html#numpy.memmap" title="(in NumPy v1.20)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">numpy.memmap</span></code></a>. When
using <a class="reference internal" href="#term-joblib"><span class="xref std std-term">joblib</span></a> to parallelize operations in Scikit-learn, it
may automatically memmap large arrays to reduce memory duplication
overhead in multiprocessing.</p>
</dd>
<dt id="term-missing-values">missing values</dt><dd><p>Most Scikit-learn estimators do not work with missing values. When they
do (e.g. in <a class="reference internal" href="modules/generated/sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer" title="sklearn.impute.SimpleImputer"><code class="xref py py-class docutils literal notranslate"><span class="pre">impute.SimpleImputer</span></code></a>), NaN is the preferred
representation of missing values in float arrays. If the array has
integer dtype, NaN cannot be represented. For this reason, we support
specifying another <code class="docutils literal notranslate"><span class="pre">missing_values</span></code> value when <a class="reference internal" href="#term-imputation"><span class="xref std std-term">imputation</span></a> or
learning can be performed in integer space.
<a class="reference internal" href="#term-unlabeled-data"><span class="xref std std-term">Unlabeled data</span></a> is a special case of missing
values in the <a class="reference internal" href="#term-target"><span class="xref std std-term">target</span></a>.</p>
</dd>
<dt id="term-n_features"><code class="docutils literal notranslate"><span class="pre">n_features</span></code></dt><dd><p>The number of <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a>.</p>
</dd>
<dt id="term-n_outputs"><code class="docutils literal notranslate"><span class="pre">n_outputs</span></code></dt><dd><p>The number of <a class="reference internal" href="#term-outputs"><span class="xref std std-term">outputs</span></a> in the <a class="reference internal" href="#term-target"><span class="xref std std-term">target</span></a>.</p>
</dd>
<dt id="term-n_samples"><code class="docutils literal notranslate"><span class="pre">n_samples</span></code></dt><dd><p>The number of <a class="reference internal" href="#term-samples"><span class="xref std std-term">samples</span></a>.</p>
</dd>
<dt id="term-n_targets"><code class="docutils literal notranslate"><span class="pre">n_targets</span></code></dt><dd><p>Synonym for <a class="reference internal" href="#term-n_outputs"><span class="xref std std-term">n_outputs</span></a>.</p>
</dd>
<dt id="term-narrative-docs">narrative docs</dt><dt id="term-narrative-documentation">narrative documentation</dt><dd><p>An alias for <a class="reference internal" href="user_guide.html#user-guide"><span class="std std-ref">User Guide</span></a>, i.e. documentation written
in <code class="docutils literal notranslate"><span class="pre">doc/modules/</span></code>. Unlike the <a class="reference internal" href="modules/classes.html#api-ref"><span class="std std-ref">API reference</span></a> provided
through docstrings, the User Guide aims to:</p>
<ul class="simple">
<li><p>group tools provided by Scikit-learn together thematically or in
terms of usage;</p></li>
<li><p>motivate why someone would use each particular tool, often through
comparison;</p></li>
<li><p>provide both intuitive and technical descriptions of tools;</p></li>
<li><p>provide or link to <a class="reference internal" href="#term-examples"><span class="xref std std-term">examples</span></a> of using key features of a
tool.</p></li>
</ul>
</dd>
<dt id="term-np">np</dt><dd><p>A shorthand for Numpy due to the conventional import statement:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
</pre></div>
</div>
</dd>
<dt id="term-online-learning">online learning</dt><dd><p>Where a model is iteratively updated by receiving each batch of ground
truth <a class="reference internal" href="#term-targets"><span class="xref std std-term">targets</span></a> soon after making predictions on corresponding
batch of data. Intrinsically, the model must be usable for prediction
after each batch. See <a class="reference internal" href="#term-partial_fit"><span class="xref std std-term">partial_fit</span></a>.</p>
</dd>
<dt id="term-out-of-core">out-of-core</dt><dd><p>An efficiency strategy where not all the data is stored in main memory
at once, usually by performing learning on batches of data. See
<a class="reference internal" href="#term-partial_fit"><span class="xref std std-term">partial_fit</span></a>.</p>
</dd>
<dt id="term-outputs">outputs</dt><dd><p>Individual scalar/categorical variables per sample in the
<a class="reference internal" href="#term-target"><span class="xref std std-term">target</span></a>. For example, in multilabel classification each
possible label corresponds to a binary output. Also called <em>responses</em>,
<em>tasks</em> or <em>targets</em>.
See <a class="reference internal" href="#term-multiclass-multioutput"><span class="xref std std-term">multiclass multioutput</span></a> and <a class="reference internal" href="#term-continuous-multioutput"><span class="xref std std-term">continuous multioutput</span></a>.</p>
</dd>
<dt id="term-pair">pair</dt><dd><p>A tuple of length two.</p>
</dd>
<dt id="term-parameter">parameter</dt><dt id="term-parameters">parameters</dt><dt id="term-param">param</dt><dt id="term-params">params</dt><dd><p>We mostly use <em>parameter</em> to refer to the aspects of an estimator that
can be specified in its construction. For example, <code class="docutils literal notranslate"><span class="pre">max_depth</span></code> and
<code class="docutils literal notranslate"><span class="pre">random_state</span></code> are parameters of <code class="xref py py-class docutils literal notranslate"><span class="pre">RandomForestClassifier</span></code>.
Parameters to an estimator’s constructor are stored unmodified as
attributes on the estimator instance, and conventionally start with an
alphabetic character and end with an alphanumeric character. Each
estimator’s constructor parameters are described in the estimator’s
docstring.</p>
<p>We do not use parameters in the statistical sense, where parameters are
values that specify a model and can be estimated from data. What we
call parameters might be what statisticians call hyperparameters to the
model: aspects for configuring model structure that are often not
directly learnt from data. However, our parameters are also used to
prescribe modeling operations that do not affect the learnt model, such
as <a class="reference internal" href="#term-n_jobs"><span class="xref std std-term">n_jobs</span></a> for controlling parallelism.</p>
<p>When talking about the parameters of a <a class="reference internal" href="#term-meta-estimator"><span class="xref std std-term">meta-estimator</span></a>, we may
also be including the parameters of the estimators wrapped by the
meta-estimator. Ordinarily, these nested parameters are denoted by
using a <a class="reference internal" href="#term-double-underscore"><span class="xref std std-term">double underscore</span></a> (<code class="docutils literal notranslate"><span class="pre">__</span></code>) to separate between the
estimator-as-parameter and its parameter. Thus <code class="docutils literal notranslate"><span class="pre">clf</span> <span class="pre">=</span>
<span class="pre">BaggingClassifier(base_estimator=DecisionTreeClassifier(max_depth=3))</span></code>
has a deep parameter <code class="docutils literal notranslate"><span class="pre">base_estimator__max_depth</span></code> with value <code class="docutils literal notranslate"><span class="pre">3</span></code>,
which is accessible with <code class="docutils literal notranslate"><span class="pre">clf.base_estimator.max_depth</span></code> or
<code class="docutils literal notranslate"><span class="pre">clf.get_params()['base_estimator__max_depth']</span></code>.</p>
<p>The list of parameters and their current values can be retrieved from
an <a class="reference internal" href="#term-estimator-instance"><span class="xref std std-term">estimator instance</span></a> using its <a class="reference internal" href="#term-get_params"><span class="xref std std-term">get_params</span></a> method.</p>
<p>Between construction and fitting, parameters may be modified using
<a class="reference internal" href="#term-set_params"><span class="xref std std-term">set_params</span></a>. To enable this, parameters are not ordinarily
validated or altered when the estimator is constructed, or when each
parameter is set. Parameter validation is performed when <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> is
called.</p>
<p>Common parameters are listed <a class="reference internal" href="#glossary-parameters"><span class="std std-ref">below</span></a>.</p>
</dd>
<dt id="term-pairwise-metric">pairwise metric</dt><dt id="term-pairwise-metrics">pairwise metrics</dt><dd><p>In its broad sense, a pairwise metric defines a function for measuring
similarity or dissimilarity between two samples (with each ordinarily
represented as a <a class="reference internal" href="#term-feature-vector"><span class="xref std std-term">feature vector</span></a>). We particularly provide
implementations of distance metrics (as well as improper metrics like
Cosine Distance) through <a class="reference internal" href="modules/generated/sklearn.metrics.pairwise_distances.html#sklearn.metrics.pairwise_distances" title="sklearn.metrics.pairwise_distances"><code class="xref py py-func docutils literal notranslate"><span class="pre">metrics.pairwise_distances</span></code></a>, and of
kernel functions (a constrained class of similarity functions) in
<code class="xref py py-func docutils literal notranslate"><span class="pre">metrics.pairwise_kernels</span></code>. These can compute pairwise distance
matrices that are symmetric and hence store data redundantly.</p>
<p>See also <a class="reference internal" href="#term-precomputed"><span class="xref std std-term">precomputed</span></a> and <a class="reference internal" href="#term-metric"><span class="xref std std-term">metric</span></a>.</p>
<p>Note that for most distance metrics, we rely on implementations from
<a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/spatial.distance.html#module-scipy.spatial.distance" title="(in SciPy v1.6.0)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">scipy.spatial.distance</span></code></a>, but may reimplement for efficiency in
our context. The <code class="xref py py-mod docutils literal notranslate"><span class="pre">neighbors</span></code> module also duplicates some metric
implementations for integration with efficient binary tree search data
structures.</p>
</dd>
<dt id="term-pd">pd</dt><dd><p>A shorthand for <a class="reference external" href="https://pandas.pydata.org">Pandas</a> due to the
conventional import statement:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
</pre></div>
</div>
</dd>
<dt id="term-precomputed">precomputed</dt><dd><p>Where algorithms rely on <a class="reference internal" href="#term-pairwise-metrics"><span class="xref std std-term">pairwise metrics</span></a>, and can be computed
from pairwise metrics alone, we often allow the user to specify that
the <a class="reference internal" href="#term-X"><span class="xref std std-term">X</span></a> provided is already in the pairwise (dis)similarity
space, rather than in a feature space. That is, when passed to
<a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a>, it is a square, symmetric matrix, with each vector
indicating (dis)similarity to every sample, and when passed to
prediction/transformation methods, each row corresponds to a testing
sample and each column to a training sample.</p>
<p>Use of precomputed X is usually indicated by setting a <code class="docutils literal notranslate"><span class="pre">metric</span></code>,
<code class="docutils literal notranslate"><span class="pre">affinity</span></code> or <code class="docutils literal notranslate"><span class="pre">kernel</span></code> parameter to the string ‘precomputed’. If
this is the case, then the estimator should set the <code class="docutils literal notranslate"><span class="pre">pairwise</span></code>
estimator tag as True.</p>
</dd>
<dt id="term-rectangular">rectangular</dt><dd><p>Data that can be represented as a matrix with <a class="reference internal" href="#term-samples"><span class="xref std std-term">samples</span></a> on the
first axis and a fixed, finite set of <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a> on the second
is called rectangular.</p>
<p>This term excludes samples with non-vectorial structures, such as text,
an image of arbitrary size, a time series of arbitrary length, a set of
vectors, etc. The purpose of a <a class="reference internal" href="#term-vectorizer"><span class="xref std std-term">vectorizer</span></a> is to produce
rectangular forms of such data.</p>
</dd>
<dt id="term-sample">sample</dt><dt id="term-samples">samples</dt><dd><p>We usually use this term as a noun to indicate a single feature vector.
Elsewhere a sample is called an instance, data point, or observation.
<code class="docutils literal notranslate"><span class="pre">n_samples</span></code> indicates the number of samples in a dataset, being the
number of rows in a data array <a class="reference internal" href="#term-X"><span class="xref std std-term">X</span></a>.</p>
</dd>
<dt id="term-sample-property">sample property</dt><dt id="term-sample-properties">sample properties</dt><dd><p>A sample property is data for each sample (e.g. an array of length
n_samples) passed to an estimator method or a similar function,
alongside but distinct from the <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a> (<code class="docutils literal notranslate"><span class="pre">X</span></code>) and
<a class="reference internal" href="#term-target"><span class="xref std std-term">target</span></a> (<code class="docutils literal notranslate"><span class="pre">y</span></code>). The most prominent example is
<a class="reference internal" href="#term-sample_weight"><span class="xref std std-term">sample_weight</span></a>; see others at <a class="reference internal" href="#glossary-sample-props"><span class="std std-ref">Data and sample properties</span></a>.</p>
<p>As of version 0.19 we do not have a consistent approach to handling
sample properties and their routing in <a class="reference internal" href="#term-meta-estimators"><span class="xref std std-term">meta-estimators</span></a>, though
a <code class="docutils literal notranslate"><span class="pre">fit_params</span></code> parameter is often used.</p>
</dd>
<dt id="term-scikit-learn-contrib">scikit-learn-contrib</dt><dd><p>A venue for publishing Scikit-learn-compatible libraries that are
broadly authorized by the core developers and the contrib community,
but not maintained by the core developer team.
See <a class="reference external" href="https://scikit-learn-contrib.github.io">https://scikit-learn-contrib.github.io</a>.</p>
</dd>
<dt id="term-scikit-learn-enhancement-proposals">scikit-learn enhancement proposals</dt><dt id="term-SLEP">SLEP</dt><dt id="term-SLEPs">SLEPs</dt><dd><p>Changes to the API principles and changes to dependencies or supported
versions happen via a <a class="reference internal" href="governance.html#slep"><span class="std std-ref">SLEP</span></a> and follows the
decision-making process outlined in <a class="reference internal" href="governance.html#governance"><span class="std std-ref">Scikit-learn governance and decision-making</span></a>.
For all votes, a proposal must have been made public and discussed before the
vote. Such a proposal must be a consolidated document, in the form of a
‘Scikit-Learn Enhancement Proposal’ (SLEP), rather than a long discussion on an
issue. A SLEP must be submitted as a pull-request to
<a class="reference external" href="https://scikit-learn-enhancement-proposals.readthedocs.io">enhancement proposals</a> using the
<a class="reference external" href="https://scikit-learn-enhancement-proposals.readthedocs.io/en/latest/slep_template.html">SLEP template</a>.</p>
</dd>
<dt id="term-semi-supervised">semi-supervised</dt><dt id="term-semi-supervised-learning">semi-supervised learning</dt><dt id="term-semisupervised">semisupervised</dt><dd><p>Learning where the expected prediction (label or ground truth) is only
available for some samples provided as training data when
<a class="reference internal" href="#term-fitting"><span class="xref std std-term">fitting</span></a> the model. We conventionally apply the label <code class="docutils literal notranslate"><span class="pre">-1</span></code>
to <a class="reference internal" href="#term-unlabeled"><span class="xref std std-term">unlabeled</span></a> samples in semi-supervised classification.</p>
</dd>
<dt id="term-sparse-matrix">sparse matrix</dt><dt id="term-sparse-graph">sparse graph</dt><dd><p>A representation of two-dimensional numeric data that is more memory
efficient the corresponding dense numpy array where almost all elements
are zero. We use the <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse" title="(in SciPy v1.6.0)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">scipy.sparse</span></code></a> framework, which provides
several underlying sparse data representations, or <em>formats</em>.
Some formats are more efficient than others for particular tasks, and
when a particular format provides especial benefit, we try to document
this fact in Scikit-learn parameter descriptions.</p>
<p>Some sparse matrix formats (notably CSR, CSC, COO and LIL) distinguish
between <em>implicit</em> and <em>explicit</em> zeros. Explicit zeros are stored
(i.e. they consume memory in a <code class="docutils literal notranslate"><span class="pre">data</span></code> array) in the data structure,
while implicit zeros correspond to every element not otherwise defined
in explicit storage.</p>
<p>Two semantics for sparse matrices are used in Scikit-learn:</p>
<dl class="simple">
<dt>matrix semantics</dt><dd><p>The sparse matrix is interpreted as an array with implicit and
explicit zeros being interpreted as the number 0. This is the
interpretation most often adopted, e.g. when sparse matrices
are used for feature matrices or <a class="reference internal" href="#term-multilabel-indicator-matrices"><span class="xref std std-term">multilabel indicator
matrices</span></a>.</p>
</dd>
<dt>graph semantics</dt><dd><p>As with <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/sparse.csgraph.html#module-scipy.sparse.csgraph" title="(in SciPy v1.6.0)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">scipy.sparse.csgraph</span></code></a>, explicit zeros are
interpreted as the number 0, but implicit zeros indicate a masked
or absent value, such as the absence of an edge between two
vertices of a graph, where an explicit value indicates an edge’s
weight. This interpretation is adopted to represent connectivity
in clustering, in representations of nearest neighborhoods
(e.g. <a class="reference internal" href="modules/generated/sklearn.neighbors.kneighbors_graph.html#sklearn.neighbors.kneighbors_graph" title="sklearn.neighbors.kneighbors_graph"><code class="xref py py-func docutils literal notranslate"><span class="pre">neighbors.kneighbors_graph</span></code></a>), and for precomputed
distance representation where only distances in the neighborhood
of each point are required.</p>
</dd>
</dl>
<p>When working with sparse matrices, we assume that it is sparse for a
good reason, and avoid writing code that densifies a user-provided
sparse matrix, instead maintaining sparsity or raising an error if not
possible (i.e. if an estimator does not / cannot support sparse
matrices).</p>
</dd>
<dt id="term-supervised">supervised</dt><dt id="term-supervised-learning">supervised learning</dt><dd><p>Learning where the expected prediction (label or ground truth) is
available for each sample when <a class="reference internal" href="#term-fitting"><span class="xref std std-term">fitting</span></a> the model, provided as
<a class="reference internal" href="#term-y"><span class="xref std std-term">y</span></a>. This is the approach taken in a <a class="reference internal" href="#term-classifier"><span class="xref std std-term">classifier</span></a> or
<a class="reference internal" href="#term-regressor"><span class="xref std std-term">regressor</span></a> among other estimators.</p>
</dd>
<dt id="term-target">target</dt><dt id="term-targets">targets</dt><dd><p>The <em>dependent variable</em> in <a class="reference internal" href="#term-supervised"><span class="xref std std-term">supervised</span></a> (and
<a class="reference internal" href="#term-semisupervised"><span class="xref std std-term">semisupervised</span></a>) learning, passed as <a class="reference internal" href="#term-y"><span class="xref std std-term">y</span></a> to an estimator’s
<a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> method. Also known as <em>dependent variable</em>, <em>outcome
variable</em>, <em>response variable</em>, <em>ground truth</em> or <em>label</em>. Scikit-learn
works with targets that have minimal structure: a class from a finite
set, a finite real-valued number, multiple classes, or multiple
numbers. See <a class="reference internal" href="#glossary-target-types"><span class="std std-ref">Target Types</span></a>.</p>
</dd>
<dt id="term-transduction">transduction</dt><dt id="term-transductive">transductive</dt><dd><p>A transductive (contrasted with <a class="reference internal" href="#term-inductive"><span class="xref std std-term">inductive</span></a>) machine learning
method is designed to model a specific dataset, but not to apply that
model to unseen data. Examples include <a class="reference internal" href="modules/generated/sklearn.manifold.TSNE.html#sklearn.manifold.TSNE" title="sklearn.manifold.TSNE"><code class="xref py py-class docutils literal notranslate"><span class="pre">manifold.TSNE</span></code></a>,
<a class="reference internal" href="modules/generated/sklearn.cluster.AgglomerativeClustering.html#sklearn.cluster.AgglomerativeClustering" title="sklearn.cluster.AgglomerativeClustering"><code class="xref py py-class docutils literal notranslate"><span class="pre">cluster.AgglomerativeClustering</span></code></a> and
<a class="reference internal" href="modules/generated/sklearn.neighbors.LocalOutlierFactor.html#sklearn.neighbors.LocalOutlierFactor" title="sklearn.neighbors.LocalOutlierFactor"><code class="xref py py-class docutils literal notranslate"><span class="pre">neighbors.LocalOutlierFactor</span></code></a>.</p>
</dd>
<dt id="term-unlabeled">unlabeled</dt><dt id="term-unlabeled-data">unlabeled data</dt><dd><p>Samples with an unknown ground truth when fitting; equivalently,
<a class="reference internal" href="#term-missing-values"><span class="xref std std-term">missing values</span></a> in the <a class="reference internal" href="#term-target"><span class="xref std std-term">target</span></a>. See also
<a class="reference internal" href="#term-semisupervised"><span class="xref std std-term">semisupervised</span></a> and <a class="reference internal" href="#term-unsupervised"><span class="xref std std-term">unsupervised</span></a> learning.</p>
</dd>
<dt id="term-unsupervised">unsupervised</dt><dt id="term-unsupervised-learning">unsupervised learning</dt><dd><p>Learning where the expected prediction (label or ground truth) is not
available for each sample when <a class="reference internal" href="#term-fitting"><span class="xref std std-term">fitting</span></a> the model, as in
<a class="reference internal" href="#term-clusterers"><span class="xref std std-term">clusterers</span></a> and <a class="reference internal" href="#term-outlier-detectors"><span class="xref std std-term">outlier detectors</span></a>. Unsupervised
estimators ignore any <a class="reference internal" href="#term-y"><span class="xref std std-term">y</span></a> passed to <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a>.</p>
</dd>
</dl>
</div>
<div class="section" id="class-apis-and-estimator-types">
<span id="glossary-estimator-types"></span><h2>Class APIs and Estimator Types<a class="headerlink" href="#class-apis-and-estimator-types" title="Permalink to this headline">¶</a></h2>
<dl class="glossary">
<dt id="term-classifier">classifier</dt><dt id="term-classifiers">classifiers</dt><dd><p>A <a class="reference internal" href="#term-supervised"><span class="xref std std-term">supervised</span></a> (or <a class="reference internal" href="#term-semi-supervised"><span class="xref std std-term">semi-supervised</span></a>) <a class="reference internal" href="#term-predictor"><span class="xref std std-term">predictor</span></a>
with a finite set of discrete possible output values.</p>
<p>A classifier supports modeling some of <a class="reference internal" href="#term-binary"><span class="xref std std-term">binary</span></a>,
<a class="reference internal" href="#term-multiclass"><span class="xref std std-term">multiclass</span></a>, <a class="reference internal" href="#term-multilabel"><span class="xref std std-term">multilabel</span></a>, or <a class="reference internal" href="#term-multiclass-multioutput"><span class="xref std std-term">multiclass
multioutput</span></a> targets. Within scikit-learn, all classifiers support
multi-class classification, defaulting to using a one-vs-rest
strategy over the binary classification problem.</p>
<p>Classifiers must store a <a class="reference internal" href="#term-classes_"><span class="xref std std-term">classes_</span></a> attribute after fitting,
and usually inherit from <a class="reference internal" href="modules/generated/sklearn.base.ClassifierMixin.html#sklearn.base.ClassifierMixin" title="sklearn.base.ClassifierMixin"><code class="xref py py-class docutils literal notranslate"><span class="pre">base.ClassifierMixin</span></code></a>, which sets
their <a class="reference internal" href="#term-_estimator_type"><span class="xref std std-term">_estimator_type</span></a> attribute.</p>
<p>A classifier can be distinguished from other estimators with
<a class="reference internal" href="modules/generated/sklearn.base.is_classifier.html#sklearn.base.is_classifier" title="sklearn.base.is_classifier"><code class="xref py py-func docutils literal notranslate"><span class="pre">is_classifier</span></code></a>.</p>
<p>A classifier must implement:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a></p></li>
<li><p><a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a></p></li>
<li><p><a class="reference internal" href="#term-score"><span class="xref std std-term">score</span></a></p></li>
</ul>
<p>It may also be appropriate to implement <a class="reference internal" href="#term-decision_function"><span class="xref std std-term">decision_function</span></a>,
<a class="reference internal" href="#term-predict_proba"><span class="xref std std-term">predict_proba</span></a> and <a class="reference internal" href="#term-predict_log_proba"><span class="xref std std-term">predict_log_proba</span></a>.</p>
</dd>
<dt id="term-clusterer">clusterer</dt><dt id="term-clusterers">clusterers</dt><dd><p>A <a class="reference internal" href="#term-unsupervised"><span class="xref std std-term">unsupervised</span></a> <a class="reference internal" href="#term-predictor"><span class="xref std std-term">predictor</span></a> with a finite set of discrete
output values.</p>
<p>A clusterer usually stores <a class="reference internal" href="#term-labels_"><span class="xref std std-term">labels_</span></a> after fitting, and must do
so if it is <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a>.</p>
<p>A clusterer must implement:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a></p></li>
<li><p><a class="reference internal" href="#term-fit_predict"><span class="xref std std-term">fit_predict</span></a> if <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a></p></li>
<li><p><a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a> if <a class="reference internal" href="#term-inductive"><span class="xref std std-term">inductive</span></a></p></li>
</ul>
</dd>
<dt id="term-density-estimator">density estimator</dt><dd><p>TODO</p>
</dd>
<dt id="term-estimator">estimator</dt><dt id="term-estimators">estimators</dt><dd><p>An object which manages the estimation and decoding of a model. The
model is estimated as a deterministic function of:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-parameters"><span class="xref std std-term">parameters</span></a> provided in object construction or with
<a class="reference internal" href="#term-set_params"><span class="xref std std-term">set_params</span></a>;</p></li>
<li><p>the global <a class="reference external" href="https://numpy.org/doc/stable/reference/random/index.html#module-numpy.random" title="(in NumPy v1.20)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">numpy.random</span></code></a> random state if the estimator’s
<a class="reference internal" href="#term-random_state"><span class="xref std std-term">random_state</span></a> parameter is set to None; and</p></li>
<li><p>any data or <a class="reference internal" href="#term-sample-properties"><span class="xref std std-term">sample properties</span></a> passed to the most recent
call to <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a>, <a class="reference internal" href="#term-fit_transform"><span class="xref std std-term">fit_transform</span></a> or <a class="reference internal" href="#term-fit_predict"><span class="xref std std-term">fit_predict</span></a>,
or data similarly passed in a sequence of calls to
<a class="reference internal" href="#term-partial_fit"><span class="xref std std-term">partial_fit</span></a>.</p></li>
</ul>
<p>The estimated model is stored in public and private <a class="reference internal" href="#term-attributes"><span class="xref std std-term">attributes</span></a>
on the estimator instance, facilitating decoding through prediction
and transformation methods.</p>
<p>Estimators must provide a <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> method, and should provide
<a class="reference internal" href="#term-set_params"><span class="xref std std-term">set_params</span></a> and <a class="reference internal" href="#term-get_params"><span class="xref std std-term">get_params</span></a>, although these are usually
provided by inheritance from <a class="reference internal" href="modules/generated/sklearn.base.BaseEstimator.html#sklearn.base.BaseEstimator" title="sklearn.base.BaseEstimator"><code class="xref py py-class docutils literal notranslate"><span class="pre">base.BaseEstimator</span></code></a>.</p>
<p>The core functionality of some estimators may also be available as a
<a class="reference internal" href="#term-function"><span class="xref std std-term">function</span></a>.</p>
</dd>
<dt id="term-feature-extractor">feature extractor</dt><dt id="term-feature-extractors">feature extractors</dt><dd><p>A <a class="reference internal" href="#term-transformer"><span class="xref std std-term">transformer</span></a> which takes input where each sample is not
represented as an <a class="reference internal" href="#term-array-like"><span class="xref std std-term">array-like</span></a> object of fixed length, and
produces an <a class="reference internal" href="#term-array-like"><span class="xref std std-term">array-like</span></a> object of <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a> for each
sample (and thus a 2-dimensional array-like for a set of samples). In
other words, it (lossily) maps a non-rectangular data representation
into <a class="reference internal" href="#term-rectangular"><span class="xref std std-term">rectangular</span></a> data.</p>
<p>Feature extractors must implement at least:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a></p></li>
<li><p><a class="reference internal" href="#term-transform"><span class="xref std std-term">transform</span></a></p></li>
<li><p><a class="reference internal" href="#term-get_feature_names"><span class="xref std std-term">get_feature_names</span></a></p></li>
</ul>
</dd>
<dt id="term-meta-estimator">meta-estimator</dt><dt id="term-meta-estimators">meta-estimators</dt><dt id="term-metaestimator">metaestimator</dt><dt id="term-metaestimators">metaestimators</dt><dd><p>An <a class="reference internal" href="#term-estimator"><span class="xref std std-term">estimator</span></a> which takes another estimator as a parameter.
Examples include <a class="reference internal" href="modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline" title="sklearn.pipeline.Pipeline"><code class="xref py py-class docutils literal notranslate"><span class="pre">pipeline.Pipeline</span></code></a>,
<a class="reference internal" href="modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV" title="sklearn.model_selection.GridSearchCV"><code class="xref py py-class docutils literal notranslate"><span class="pre">model_selection.GridSearchCV</span></code></a>,
<a class="reference internal" href="modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModel" title="sklearn.feature_selection.SelectFromModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">feature_selection.SelectFromModel</span></code></a> and
<a class="reference internal" href="modules/generated/sklearn.ensemble.BaggingClassifier.html#sklearn.ensemble.BaggingClassifier" title="sklearn.ensemble.BaggingClassifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">ensemble.BaggingClassifier</span></code></a>.</p>
<p>In a meta-estimator’s <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> method, any contained estimators
should be <a class="reference internal" href="#term-cloned"><span class="xref std std-term">cloned</span></a> before they are fit (although FIXME: Pipeline
and FeatureUnion do not do this currently). An exception to this is
that an estimator may explicitly document that it accepts a pre-fitted
estimator (e.g. using <code class="docutils literal notranslate"><span class="pre">prefit=True</span></code> in
<a class="reference internal" href="modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModel" title="sklearn.feature_selection.SelectFromModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">feature_selection.SelectFromModel</span></code></a>). One known issue with this
is that the pre-fitted estimator will lose its model if the
meta-estimator is cloned. A meta-estimator should have <code class="docutils literal notranslate"><span class="pre">fit</span></code> called
before prediction, even if all contained estimators are pre-fitted.</p>
<p>In cases where a meta-estimator’s primary behaviors (e.g.
<a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a> or <a class="reference internal" href="#term-transform"><span class="xref std std-term">transform</span></a> implementation) are functions of
prediction/transformation methods of the provided <em>base estimator</em> (or
multiple base estimators), a meta-estimator should provide at least the
standard methods provided by the base estimator. It may not be
possible to identify which methods are provided by the underlying
estimator until the meta-estimator has been <a class="reference internal" href="#term-fitted"><span class="xref std std-term">fitted</span></a> (see also
<a class="reference internal" href="#term-duck-typing"><span class="xref std std-term">duck typing</span></a>), for which
<a class="reference internal" href="modules/generated/sklearn.utils.metaestimators.if_delegate_has_method.html#sklearn.utils.metaestimators.if_delegate_has_method" title="sklearn.utils.metaestimators.if_delegate_has_method"><code class="xref py py-func docutils literal notranslate"><span class="pre">utils.metaestimators.if_delegate_has_method</span></code></a> may help. It
should also provide (or modify) the <a class="reference internal" href="#term-estimator-tags"><span class="xref std std-term">estimator tags</span></a> and
<a class="reference internal" href="#term-classes_"><span class="xref std std-term">classes_</span></a> attribute provided by the base estimator.</p>
<p>Meta-estimators should be careful to validate data as minimally as
possible before passing it to an underlying estimator. This saves
computation time, and may, for instance, allow the underlying
estimator to easily work with data that is not <a class="reference internal" href="#term-rectangular"><span class="xref std std-term">rectangular</span></a>.</p>
</dd>
<dt id="term-outlier-detector">outlier detector</dt><dt id="term-outlier-detectors">outlier detectors</dt><dd><p>An <a class="reference internal" href="#term-unsupervised"><span class="xref std std-term">unsupervised</span></a> binary <a class="reference internal" href="#term-predictor"><span class="xref std std-term">predictor</span></a> which models the
distinction between core and outlying samples.</p>
<p>Outlier detectors must implement:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a></p></li>
<li><p><a class="reference internal" href="#term-fit_predict"><span class="xref std std-term">fit_predict</span></a> if <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a></p></li>
<li><p><a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a> if <a class="reference internal" href="#term-inductive"><span class="xref std std-term">inductive</span></a></p></li>
</ul>
<p>Inductive outlier detectors may also implement
<a class="reference internal" href="#term-decision_function"><span class="xref std std-term">decision_function</span></a> to give a normalized inlier score where
outliers have score below 0. <a class="reference internal" href="#term-score_samples"><span class="xref std std-term">score_samples</span></a> may provide an
unnormalized score per sample.</p>
</dd>
<dt id="term-predictor">predictor</dt><dt id="term-predictors">predictors</dt><dd><p>An <a class="reference internal" href="#term-estimator"><span class="xref std std-term">estimator</span></a> supporting <a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a> and/or
<a class="reference internal" href="#term-fit_predict"><span class="xref std std-term">fit_predict</span></a>. This encompasses <a class="reference internal" href="#term-classifier"><span class="xref std std-term">classifier</span></a>,
<a class="reference internal" href="#term-regressor"><span class="xref std std-term">regressor</span></a>, <a class="reference internal" href="#term-outlier-detector"><span class="xref std std-term">outlier detector</span></a> and <a class="reference internal" href="#term-clusterer"><span class="xref std std-term">clusterer</span></a>.</p>
<p>In statistics, “predictors” refers to <a class="reference internal" href="#term-features"><span class="xref std std-term">features</span></a>.</p>
</dd>
<dt id="term-regressor">regressor</dt><dt id="term-regressors">regressors</dt><dd><p>A <a class="reference internal" href="#term-supervised"><span class="xref std std-term">supervised</span></a> (or <a class="reference internal" href="#term-semi-supervised"><span class="xref std std-term">semi-supervised</span></a>) <a class="reference internal" href="#term-predictor"><span class="xref std std-term">predictor</span></a>
with <a class="reference internal" href="#term-continuous"><span class="xref std std-term">continuous</span></a> output values.</p>
<p>Regressors usually inherit from <a class="reference internal" href="modules/generated/sklearn.base.RegressorMixin.html#sklearn.base.RegressorMixin" title="sklearn.base.RegressorMixin"><code class="xref py py-class docutils literal notranslate"><span class="pre">base.RegressorMixin</span></code></a>, which
sets their <a class="reference internal" href="#term-_estimator_type"><span class="xref std std-term">_estimator_type</span></a> attribute.</p>
<p>A regressor can be distinguished from other estimators with
<a class="reference internal" href="modules/generated/sklearn.base.is_regressor.html#sklearn.base.is_regressor" title="sklearn.base.is_regressor"><code class="xref py py-func docutils literal notranslate"><span class="pre">is_regressor</span></code></a>.</p>
<p>A regressor must implement:</p>
<ul class="simple">
<li><p><a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a></p></li>
<li><p><a class="reference internal" href="#term-predict"><span class="xref std std-term">predict</span></a></p></li>
<li><p><a class="reference internal" href="#term-score"><span class="xref std std-term">score</span></a></p></li>
</ul>
</dd>
<dt id="term-transformer">transformer</dt><dt id="term-transformers">transformers</dt><dd><p>An estimator supporting <a class="reference internal" href="#term-transform"><span class="xref std std-term">transform</span></a> and/or <a class="reference internal" href="#term-fit_transform"><span class="xref std std-term">fit_transform</span></a>.
A purely <a class="reference internal" href="#term-transductive"><span class="xref std std-term">transductive</span></a> transformer, such as
<a class="reference internal" href="modules/generated/sklearn.manifold.TSNE.html#sklearn.manifold.TSNE" title="sklearn.manifold.TSNE"><code class="xref py py-class docutils literal notranslate"><span class="pre">manifold.TSNE</span></code></a>, may not implement <code class="docutils literal notranslate"><span class="pre">transform</span></code>.</p>
</dd>
<dt id="term-vectorizer">vectorizer</dt><dt id="term-vectorizers">vectorizers</dt><dd><p>See <a class="reference internal" href="#term-feature-extractor"><span class="xref std std-term">feature extractor</span></a>.</p>
</dd>
</dl>
<p>There are further APIs specifically related to a small family of estimators,
such as:</p>
<dl class="glossary simple">
<dt id="term-cross-validation-splitter">cross-validation splitter</dt><dt id="term-CV-splitter">CV splitter</dt><dt id="term-cross-validation-generator">cross-validation generator</dt><dd><p>A non-estimator family of classes used to split a dataset into a
sequence of train and test portions (see <a class="reference internal" href="modules/cross_validation.html#cross-validation"><span class="std std-ref">Cross-validation: evaluating estimator performance</span></a>),
by providing <a class="reference internal" href="#term-split"><span class="xref std std-term">split</span></a> and <a class="reference internal" href="#term-get_n_splits"><span class="xref std std-term">get_n_splits</span></a> methods.
Note that unlike estimators, these do not have <a class="reference internal" href="#term-fit"><span class="xref std std-term">fit</span></a> methods
and do not provide <a class="reference internal" href="#term-set_params"><span class="xref std std-term">set_params</span></a> or <a class="reference internal" href="#term-get_params"><span class="xref std std-term">get_params</span></a>.
Parameter validation may be performed in <code class="docutils literal notranslate"><span class="pre">__init__</span></code>.</p>
</dd>
<dt id="term-cross-validation-estimator">cross-validation estimator</dt><dd><p>An estimator that has built-in cross-validation capabilities to
automatically select the best hyper-parameters (see the <a class="reference internal" href="modules/grid_search.html#grid-search"><span class="std std-ref">User
Guide</span></a>). Some example of cross-validation estimators
are <a class="reference internal" href="modules/generated/sklearn.linear_model.ElasticNetCV.html#sklearn.linear_model.ElasticNetCV" title="sklearn.linear_model.ElasticNetCV"><code class="xref py py-class docutils literal notranslate"><span class="pre">ElasticNetCV</span></code></a> and
<a class="reference internal" href="modules/generated/sklearn.linear_model.LogisticRegressionCV.html#sklearn.linear_model.LogisticRegressionCV" title="sklearn.linear_model.LogisticRegressionCV"><code class="xref py py-class docutils literal notranslate"><span class="pre">LogisticRegressionCV</span></code></a>.
Cross-validation estimators are named <code class="docutils literal notranslate"><span class="pre">EstimatorCV</span></code> and tend to be
roughly equivalent to <code class="docutils literal notranslate"><span class="pre">GridSearchCV(Estimator(),</span> <span class="pre">...)</span></code>. The
advantage of using a cross-validation estimator over the canonical
<a class="reference internal" href="#term-estimator"><span class="xref std std-term">estimator</span></a> class along with <a class="reference internal" href="modules/grid_search.html#grid-search"><span class="std std-ref">grid search</span></a> is
that they can take advantage of warm-starting by reusing precomputed