sidst opdateret den 17.August 2020
Dimensionalitetsreduktion er en uovervåget læringsteknik.
ikke desto mindre kan det bruges som et datatransformationsforarbejdningstrin til maskinlæringsalgoritmer om klassificering og regressionsforudsigende modelleringsdatasæt med overvågede læringsalgoritmer.
der er mange dimensionalitetsreduktionsalgoritmer at vælge imellem og ingen enkelt bedste algoritme til alle tilfælde. I stedet er det en god ide at udforske en række dimensionalitetsreduktionsalgoritmer og forskellige konfigurationer for hver algoritme.
i denne tutorial vil du opdage, hvordan du passer og evaluerer topdimensionalitetsreduktionsalgoritmer i Python.
Når du har gennemført denne tutorial, vil du vide:
- Dimensionalitetsreduktion Søger en lavere dimensionel repræsentation af numeriske inputdata, der bevarer de fremtrædende forhold i dataene.
- der er mange forskellige dimensionalitetsreduktionsalgoritmer og ingen enkelt bedste metode til alle datasæt.
- Sådan implementeres, tilpasses og evalueres topdimensionalitetsreduktion i Python med scikit-learn machine learning library.
kickstart dit projekt med min nye bog Data forberedelse til Machine Learning, herunder trin-for-trin tutorials og Python kildekode filer for alle eksempler.
lad os komme i gang.
Dimensionalitetsreduktionsalgoritmer med Python
foto af Bernard Spragg. Nogle rettigheder forbeholdes.
- Tutorial Oversigt
- Dimensionalitetsreduktion
- vil du komme i gang med data forberedelse?
- Dimensionalitetsreduktionsalgoritmer
- lineære Algebrametoder
- Manifold læringsmetoder
- eksempler på Dimensionalitetsreduktion
- Scikit-Lær Biblioteksinstallation
- Klassificeringsdatasæt
- Principal Component Analysis
- Singular Value Decomposition
- Linear Discriminant Analysis
- Isomap Embedding
- Locally Linear Embedding
- Modified Locally Linear Embedding
- Further Reading
- Tutorials
- API ‘ er
- oversigt
- få styr på moderne data forberedelse!
- Forbered dine Maskinindlæringsdata i minutter
- Bring moderne data forberedelse teknikker tildine Machine Learning projekter
Tutorial Oversigt
denne tutorial er opdelt i tre dele; de er:
- Dimensionalitetsreduktion
- Dimensionalitetsreduktionsalgoritmer
- eksempler på Dimensionalitetsreduktion
- Scikit-Lær Biblioteksinstallation
- Klassificeringsdatasæt
- Hovedkomponentanalyse
- ental værdi nedbrydning
- lineær diskriminerende analyse
- Isomap-indlejring
- lokalt lineær indlejring
- modificeret lokalt lineær indlejring
- indlejring
Dimensionalitetsreduktion
dimensionalitetsreduktion henviser til teknikker til reduktion af antallet af inputvariabler i træningsdata.
når man beskæftiger sig med højdimensionelle data, er det ofte nyttigt at reducere dimensionaliteten ved at projicere dataene til et lavere dimensionelt underrum, der fanger “essensen” af dataene. Dette kaldes dimensionalitetsreduktion.
— side 11, maskinlæring: et probabilistisk perspektiv, 2012.
højdimensionalitet kan betyde hundreder, tusinder eller endda millioner af inputvariabler.
færre inputdimensioner betyder ofte tilsvarende færre parametre eller en enklere struktur i maskinindlæringsmodellen, kaldet frihedsgrader. En model med for mange frihedsgrader vil sandsynligvis overpasser træningsdatasættet og fungerer muligvis ikke godt på nye data.
det er ønskeligt at have enkle modeller, der generaliserer godt, og til gengæld inputdata med få inputvariabler. Dette gælder især for lineære modeller, hvor antallet af input og frihedsgraderne for modellen ofte er tæt forbundet.
Dimensionalitetsreduktion er en dataforberedelsesteknik udført på data før modellering. Det kan udføres efter data rengøring og data skalering og før uddannelse en prædiktiv model.
… dimensionalitetsreduktion giver en mere kompakt, lettere fortolkelig repræsentation af målkonceptet og fokuserer brugerens opmærksomhed på de mest relevante variabler.
— side 289, Data Mining: praktiske Machine Learning værktøjer og teknikker, 4.udgave, 2016.
som sådan skal enhver dimensionalitetsreduktion udført på træningsdata også udføres på nye data, såsom et testdatasæt, valideringsdatasæt og data, når der foretages en forudsigelse med den endelige model.
vil du komme i gang med data forberedelse?
Tag mit gratis 7-dages e-mail-crashkursus nu (med prøvekode).
Klik for at tilmelde dig og også få en gratis PDF Ebook version af kurset.
Hent dit gratis minikursus
Dimensionalitetsreduktionsalgoritmer
der er mange algoritmer, der kan bruges til dimensionalitetsreduktion.
to hovedklasser af metoder er dem, der er hentet fra lineær algebra, og dem, der er hentet fra mangfoldig læring.
lineære Algebrametoder
matriksfaktoriseringsmetoder trukket fra feltet lineær algebra kan bruges til dimensionalitet.
For mere om faktorisering af matricen, se vejledningen:
- en blid introduktion til Matriksfaktorisering til maskinindlæring
nogle af de mere populære metoder inkluderer:
- Principal Components Analysis
- ental værdi nedbrydning
- ikke-negativ Matriksfaktorisering
Manifold læringsmetoder
Manifold læringsmetoder Søger en lavere dimensionel projektion af højdimensionel input, der fanger de fremtrædende egenskaber ved input data.
nogle af de mere populære metoder omfatter:
- Isomap-indlejring
- lokalt lineær indlejring
- multidimensionel skalering
- spektral indlejring
- t-distribueret stokastisk Naboindlejring
hver algoritme tilbyder en anden tilgang til udfordringen med at opdage naturlige forhold i data ved lavere dimensioner.
der er ingen bedste dimensionalitetsreduktionsalgoritme og ingen nem måde at finde den bedste algoritme til dine data uden at bruge kontrollerede eksperimenter.
i denne vejledning gennemgår vi, hvordan du bruger hver delmængde af disse populære dimensionalitetsreduktionsalgoritmer fra scikit-learn-biblioteket.
eksemplerne vil danne grundlag for dig at kopiere-indsætte eksemplerne og teste metoderne på dine egne data.
Vi vil ikke dykke ned i teorien bag, hvordan algoritmerne fungerer, eller sammenligne dem direkte. For et godt udgangspunkt om dette emne, se:
- nedbrydning af signaler i komponenter, scikit-learn API.
- Manifold læring, scikit-Lær API.
lad os dykke ind.
eksempler på Dimensionalitetsreduktion
i dette afsnit vil vi gennemgå, hvordan man bruger populære dimensionalitetsreduktionsalgoritmer i scikit-learn.
Dette inkluderer et eksempel på at bruge dimensionalitetsreduktionsteknikken som en datatransformation i en modelleringsrørledning og evaluere en modelpasning på dataene.
eksemplerne er designet til at kopiere ind i dit eget projekt og anvende metoderne til dine egne data. Der er nogle algoritmer tilgængelige i scikit-learn-biblioteket, der ikke demonstreres, fordi de ikke kan bruges som en datatransformation direkte i betragtning af algoritmens Art.
som sådan bruger vi et syntetisk klassificeringsdatasæt i hvert eksempel.
Scikit-Lær Biblioteksinstallation
lad os først installere biblioteket.
spring ikke dette trin over, da du bliver nødt til at sikre, at du har den nyeste version installeret.
Du kan installere scikit-learn-biblioteket ved hjælp af PIP Python-installationsprogrammet som følger:
|
1
|
sudo pip install scikit-learn
|
For additional installation instructions specific to your platform, see:
- Installing scikit-learn
Next, let’s confirm that the library is installed and you are using a modern version.
Run the following script to print the library version number.
|
1
2
3
|
# check scikit-learn version
import sklearn
print(sklearn.__version__)
|
Running the example, you should see the following version number or higher.
|
1
|
0.23.0
|
Klassificeringsdatasæt
Vi bruger make_classification () – funktionen til at oprette et test binært klassificeringsdatasæt.
datasættet vil have 1.000 eksempler med 20 inputfunktioner, hvoraf 10 er informative og 10 er overflødige. Dette giver en mulighed for hver teknik til at identificere og fjerne overflødige inputfunktioner.
det faste tilfældige frø til pseudorandom-talgeneratoren sikrer, at vi genererer det samme syntetiske datasæt hver gang koden kører.
An example of creating and summarizing the synthetic classification dataset is listed below.
|
1
2
3
4
5
6
|
# synthetic classification dataset
from sklearn.datasæt import make_classification
# Definer datasæt
s, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# opsummer datasættet
print(S. shape, y.shape)
|
kørsel af eksemplet opretter datasættet og rapporterer antallet af rækker og kolonner, der matcher vores forventninger.
|
1
|
(1000, 20) (1000,)
|
It is a binary classification task and we will evaluate a LogisticRegression model after each dimensionality reduction transform.
modellen evalueres ved hjælp af guldstandarden for gentagen stratificeret 10 gange krydsvalidering. Klassificeringsnøjagtigheden for middel-og standardafvigelse på tværs af alle folder og gentagelser vil blive rapporteret.
eksemplet nedenfor evaluerer modellen på det rå datasæt som et sammenligningspunkt.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# Evaluer logistisk regressionsmodel på rådata
fra numpy import middel
fra numpy Importer std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the model
model = LogisticRegression()
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer den logistiske regression på det rå datasæt med alle 20 kolonner og opnår en klassificeringsnøjagtighed på omkring 82,4 procent.
en vellykket dimensionalitetsreduktionstransformation på disse data skal resultere i en model, der har bedre nøjagtighed end denne basislinje, selvom dette muligvis ikke er muligt med alle teknikker.
Bemærk: Vi forsøger ikke at “løse” dette datasæt, bare give arbejdseksempler, som du kan bruge som udgangspunkt.
|
1
|
Accuracy: 0.824 (0.034)
|
Next, we can start looking at examples of dimensionality reduction algorithms applied to this dataset.
I have made some minimal attempts to tune each method to the dataset. Hver dimensionalitetsreduktionsmetode konfigureres til at reducere de 20 inputkolonner til 10, hvor det er muligt.
vi vil bruge en rørledning til at kombinere datatransformationen og modellen til en atomenhed, der kan evalueres ved hjælp af krydsvalideringsproceduren; for eksempel:
|
1
2
3
4
|
…
# define the pipeline
steps =
model = Pipeline(steps=steps)
|
Let’s get started.
Can you get a better result for one of the algorithms?
Lad mig vide i kommentarerne nedenfor.
Principal Component Analysis
Principal Component Analysis, eller PCA, kan være den mest populære teknik til dimensionalitetsreduktion med tætte data (få nulværdier).
For mere om, hvordan PCA fungerer, se tutorial:
- Sådan beregnes Principal Component Analysis (PCA) fra bunden i Python
scikit-learn-biblioteket giver PCA-klasseimplementering af Principal Component Analysis, der kan bruges som en dimensionalitetsreduktionsdatatransformation. Argumentet” n_components ” kan indstilles til at konfigurere antallet af ønskede dimensioner i transformationens output.
det komplette eksempel på evaluering af en model med PCA-dimensionalitetsreduktion er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer PCA med logistisk regressionsalgoritme til klassificering
fra numpy import middel
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.nedbrydning import PCA
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde ser vi ikke nogen løft i modelydelsen ved brug af PCA-transformationen.
|
1
|
Accuracy: 0.824 (0.034)
|
Singular Value Decomposition
Singular Value Decomposition, or SVD, is one of the most popular techniques for dimensionality reduction for sparse data (data with many zero values).
For mere om, hvordan SVD fungerer, se tutorial:
- Sådan beregnes SVD fra bunden med Python
scikit-learn-biblioteket giver TruncatedSVD-klasseimplementering af Entalværdi nedbrydning, der kan bruges som en dimensionalitetsreduktionsdatatransformation. Argumentet” n_components ” kan indstilles til at konfigurere antallet af ønskede dimensioner i transformationens output.
det komplette eksempel på evaluering af en model med SVD-dimensionalitetsreduktion er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer SVD med logistisk regressionsalgoritme til klassificering
fra numpy import middel
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.nedbrydning import TruncatedSVD
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde ser vi ikke nogen løft i modelydelsen ved brug af SVD-transformationen.
|
1
|
Accuracy: 0.824 (0.034)
|
Linear Discriminant Analysis
Linear Discriminant Analysis, or LDA, is a multi-class classification algorithm that can be used for dimensionality reduction.
antallet af dimensioner for projektionen er begrænset til 1 og C-1, hvor C er antallet af klasser. I dette tilfælde er vores datasæt et binært klassificeringsproblem (to klasser), der begrænser antallet af dimensioner til 1.
For mere om Lda til dimensionalitetsreduktion, se vejledningen:
- lineær Diskriminantanalyse til Dimensionalitetsreduktion i Python
scikit-learn-biblioteket giver lineardiskriminantanalyseklasse implementering af lineær Diskriminantanalyse, der kan bruges som en dimensionalitetsreduktionsdatatransformation. Argumentet” n_components ” kan indstilles til at konfigurere antallet af ønskede dimensioner i transformationens output.
det komplette eksempel på evaluering af en model med Lda-dimensionalitetsreduktion er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer Lda med logistisk regressionsalgoritme til klassificering
fra numpy import middel
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.discriminant_analyse import Lineardiskriminantanalyse
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde kan vi se en lille stigning i ydeevne sammenlignet med baseline-tilpasningen på rådataene.
|
1
|
Accuracy: 0.825 (0.034)
|
Isomap Embedding
Isomap Embedding, or Isomap, creates an embedding of the dataset and attempts to preserve the relationships in the dataset.scikit-learn-biblioteket giver isomap-klasseimplementering af Isomap-indlejring, der kan bruges som en dimensionalitetsreduktionsdatatransformation. Argumentet” n_components ” kan indstilles til at konfigurere antallet af ønskede dimensioner i transformationens output.
det komplette eksempel på evaluering af en model med SVD-dimensionalitetsreduktion er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer isomap med logistisk regressionsalgoritme til klassificering
fra numpy import middel
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.manifold import Isomap
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde kan vi se et løft i ydeevne med Isomap-datatransformationen sammenlignet med baseline-tilpasningen på rådataene.
|
1
|
Accuracy: 0.888 (0.029)
|
Locally Linear Embedding
Locally Linear Embedding, or LLE, creates an embedding of the dataset and attempts to preserve the relationships between neighborhoods in the dataset.
scikit-learn-biblioteket giver den Locallylinearebedding-klasseimplementering af lokalt lineær indlejring, der kan bruges som en dimensionalitetsreduktionsdatatransformation. Argumentet” n_components ” kan indstilles til at konfigurere antallet af ønskede dimensioner i output af transformationen
det komplette eksempel på evaluering af en model med reduktion af lle-dimensionalitet er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer lle og logistiske regressioner for taksonomi
fra numpy import betyder
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.manifold import Locallylinearebedding
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde kan vi se et løft i ydeevne med LLE-datatransformationen sammenlignet med baseline-tilpasningen på rådataene.
|
1
|
Accuracy: 0.886 (0.028)
|
Modified Locally Linear Embedding
Modified Locally Linear Embedding, or Modified LLE, is an extension of Locally Linear Embedding that creates multiple weighting vectors for each neighborhood.scikit-learn biblioteket giver den Locallylinearebedding klasse implementering af modificeret lokalt lineær indlejring, der kan bruges som en dimensionalitet reduktion data transform. Argumentet ” metode “skal indstilles til ‘modificeret’, og argumentet” n_components “kan indstilles til at konfigurere antallet af ønskede dimensioner i output fra transformationen, som skal være mindre end argumentet” n_neighbors”.
det komplette eksempel på evaluering af en model med modificeret lle-dimensionalitetsreduktion er angivet nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# Evaluer modificerede lle og logistiske regressioner for klassificering
fra numpy import middel
fra numpy import std
fra sklearn.datasæt import make_classification
fra sklearn.model_selection import cross_val_score
fra sklearn.model_selection import RepeatedStratifiedKFold
fra sklearn.pipeline import Pipeline
fra sklearn.manifold import Locallylinearebedding
fra sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps =
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1)
# report performance
print(‘Accuracy: %.3f (%.3f) ‘ % (middel(n_scores), std(n_scores)))
|
kørsel af eksemplet evaluerer modelleringsrørledningen med dimensionalitetsreduktion og en logistisk regressionsforudsigende model.
Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.
i dette tilfælde kan vi se et løft i ydeevne med den modificerede lle-datatransformation sammenlignet med baseline-tilpasningen på rådataene.
|
1
|
Accuracy: 0.846 (0.036)
|
Further Reading
This section provides more resources on the topic if you are looking to go deeper.
Tutorials
- Introduktion til Dimensionalitetsreduktion til maskinindlæring
- Hovedkomponentanalyse til Dimensionalitetsreduktion i Python
- ental værdi nedbrydning til Dimensionalitetsreduktion i Python
- lineær diskriminerende analyse til Dimensionalitetsreduktion i Python
API ‘ er
- nedbrydning af signaler i komponenter, scikit-learn API.
- Manifold læring, scikit-Lær API.
oversigt
i denne vejledning opdagede du, hvordan du passer og evaluerer topdimensionalitetsreduktionsalgoritmer i Python.
specifikt lærte du:
- Dimensionalitetsreduktion Søger en lavere dimensionel repræsentation af numeriske inputdata, der bevarer de fremtrædende relationer i dataene.
- der er mange forskellige dimensionalitetsreduktionsalgoritmer og ingen enkelt bedste metode til alle datasæt.
- Sådan implementeres, tilpasses og evalueres topdimensionalitetsreduktion i Python med scikit-learn machine learning library.
har du spørgsmål?
stil dine spørgsmål i kommentarerne nedenfor, og jeg vil gøre mit bedste for at svare.
få styr på moderne data forberedelse!
Forbered dine Maskinindlæringsdata i minutter
…med blot et par linjer af python kode
opdage, hvordan i min nye Ebook:
data forberedelse til Machine Learning
det giver selvstudie tutorials med fuld arbejdsgruppe kode på:
funktion udvælgelse, RFE, Data Rengøring, data transformationer, skalering, dimensionalitet reduktion, og meget mere…
Bring moderne data forberedelse teknikker til
dine Machine Learning projekter
Se hvad der er inde