laatst bijgewerkt op 17 augustus 2020
Dimensionaliteitsreductie is een leertechniek zonder toezicht.
Niettemin kan het worden gebruikt als een data transform pre-processing stap voor machine learning algoritmen op classificatie en regressie voorspellende modellering datasets met begeleid leren algoritmen.
Er zijn veel dimensionaliteitsreductiealgoritmen om uit te kiezen en er is geen enkel beste algoritme voor alle gevallen. In plaats daarvan is het een goed idee om een reeks dimensionaliteitsreductiealgoritmen en verschillende configuraties voor elk algoritme te verkennen.
in deze tutorial zult u ontdekken hoe u topdimensionaliteitsreductiealgoritmen in Python kunt aanpassen en evalueren.
na het voltooien van deze tutorial, zult u weten:
- Dimensionaliteitsreductie Zoekt Een lagere-dimensionale weergave van numerieke invoergegevens die de opvallende relaties in de gegevens behoudt.
- Er zijn veel verschillende dimensionaliteitsreductiealgoritmen en er is geen enkele beste methode voor alle datasets.
- Hoe topdimensionaliteitsreductie in Python te implementeren, passen en evalueren met de sikit-learn machine learning library.
start uw project met mijn nieuwe boek Data voorbereiding voor Machine Learning, inclusief stap-voor-stap tutorials en de Python broncode bestanden voor alle voorbeelden.
laten we beginnen.
Dimensionaliteitsreductiealgoritmen met Python
Foto door Bernard Spragg. NZ, sommige rechten voorbehouden.
- Tutorial Overview
- Dimensionaliteit Vermindering
- wilt u aan de slag met gegevensvoorbereiding?
- Dimensionaliteitsreductiealgoritmen
- Lineaire Algebramethoden
- Manifold Learning Methods
- voorbeelden van Dimensionaliteitsreductie
- sikit-Learn Library Installation
- Classificatiedataset
- Principal Component Analysis
- Singular Value Decomposition
- Linear Discriminant Analysis
- Isomap Embedding
- Locally Linear Embedding
- Modified Locally Linear Embedding
- Further Reading
- Tutorials
- API ‘ s
- samenvatting
- Krijg grip op moderne gegevensvoorbereiding!
- Bereid uw gegevens voor in minuten
- breng moderne technieken voor gegevensvoorbereiding naar uw Machine Learning-projecten
Tutorial Overview
Deze tutorial is verdeeld in drie delen; ze zijn:
- Dimensionaliteit Vermindering
- Dimensionaliteit Reductie Algoritmen
- Voorbeelden van de Dimensionaliteit Vermindering
- Scikit-Leren Bibliotheek Installatie
- Classificatie Dataset
- Principal Component Analyse
- Singuliere waarden Ontbinding
- Lineaire Discriminant Analyse
- Isomap Verankering
- Lokaal Lineaire Verankering
- Lokaal Gewijzigd Lineaire Verankering
Dimensionaliteit Vermindering
Dimensionaliteit vermindering verwijst naar technieken voor het verminderen van het aantal input variabelen in de training data.
bij het omgaan met hoogdimensionale gegevens is het vaak nuttig om de dimensionaliteit te verminderen door de gegevens te projecteren naar een lagere dimensionale subruimte die de” essentie ” van de gegevens vastlegt. Dit wordt dimensionaliteitsreductie genoemd.
– Page 11, Machine Learning: A Probabilistic Perspective, 2012.
hoge dimensionaliteit kan honderden, duizenden of zelfs miljoenen invoervariabelen betekenen.
minder invoerdimensies betekent vaak dienovereenkomstig minder parameters of een eenvoudigere structuur in het machine learning model, aangeduid als vrijheidsgraden. Een model met te veel vrijheidsgraden zal waarschijnlijk de trainingsdataset overstijgen en zal mogelijk niet goed presteren op nieuwe data.
Het is wenselijk om eenvoudige modellen te hebben die goed generaliseren en op hun beurt invoergegevens met weinig invoervariabelen. Dit geldt met name voor lineaire modellen waarbij het aantal ingangen en de vrijheidsgraden van het model vaak nauw met elkaar samenhangen.
Dimensionaliteitsreductie is een techniek voor gegevensvoorbereiding die wordt uitgevoerd op gegevens voorafgaand aan het modelleren. Het kan worden uitgevoerd na het opschonen en schalen van gegevens en voor het trainen van een voorspellend model.
… dimensionaliteitsreductie levert een compactere, gemakkelijker te interpreteren weergave van het doelconcept op, waarbij de aandacht van de gebruiker wordt gericht op de meest relevante variabelen.
— Page 289, Data Mining: Practical Machine Learning Tools and Techniques, 4th edition, 2016.
als zodanig moet elke dimensionaliteitsreductie op trainingsgegevens ook worden uitgevoerd op nieuwe gegevens, zoals een testgegevensreeks, validatiegegevensreeks en gegevens bij het maken van een voorspelling met het uiteindelijke model.
wilt u aan de slag met gegevensvoorbereiding?
neem nu mijn gratis 7-daagse e-mail spoedcursus (met voorbeeldcode).
Klik om u aan te melden en ontvang ook een gratis PDF Ebook versie van de cursus.
download uw gratis minicursus
Dimensionaliteitsreductiealgoritmen
Er zijn veel algoritmen die kunnen worden gebruikt voor dimensionaliteitsreductie.
twee hoofdklassen van methoden zijn die ontleend aan lineaire algebra en die getrokken uit veelvoudig leren.
Lineaire Algebramethoden
Matrixdectorisatiemethoden uit het veld van de lineaire algebra kunnen worden gebruikt voor dimensionaliteit.
voor meer informatie over Matrix factorisatie, zie de tutorial:
- Een Zachte Inleiding tot Matrixfactorisatie voor Machine Learning
enkele van de meer populaire methoden zijn:
- Hoofdcomponentenanalyse
- enkelvoudige waarde decompositie
- niet-negatieve Matrixfactorisatie
Manifold Learning Methods
opvallende eigenschappen van de invoergegevens.
enkele van de meer populaire methoden omvatten:
- Isomap-inbedding
- lokaal Lineaire inbedding
- multidimensionale schaling
- spectrale inbedding
- t-gedistribueerde stochastische buur-inbedding
elk algoritme biedt een andere benadering van de uitdaging om natuurlijke relaties in data op lagere dimensies te ontdekken.
er is geen beste dimensionaliteitsreductiealgoritme en geen gemakkelijke manier om het beste algoritme voor uw gegevens te vinden zonder gecontroleerde experimenten te gebruiken.
in deze tutorial zullen we bekijken hoe elke subset van deze populaire dimensionaliteitsreductiealgoritmen uit de scikit-learn bibliotheek gebruikt kan worden.
De voorbeelden geven u de basis om de voorbeelden te kopiëren en te plakken en de methoden op uw eigen gegevens te testen.
We zullen niet ingaan op de theorie achter hoe de algoritmen werken of ze direct vergelijken. Voor een goed beginpunt over dit onderwerp, zie:
- ontbindende signalen in componenten, sikit-learn API.
- Manifold Learning, sikit-learn API.
laten we erin duiken.
voorbeelden van Dimensionaliteitsreductie
in deze sectie zullen we bekijken hoe populaire dimensionaliteitsreductiealgoritmen gebruikt kunnen worden in scikit-learn.
Dit omvat een voorbeeld van het gebruik van de dimensionaliteitsreductietechniek als een gegevenstransformatie in een modelleringspijplijn en het evalueren van een model dat op de gegevens Past.
De voorbeelden zijn ontworpen voor u om te kopiëren-plakken in uw eigen project en de methoden toe te passen op uw eigen gegevens. Er zijn een aantal algoritmen beschikbaar in de scikit-learn bibliotheek die niet worden gedemonstreerd omdat ze niet kunnen worden gebruikt als een data-transformatie direct gezien de aard van het algoritme.
als zodanig zullen we in elk voorbeeld een synthetische classificatiedataset gebruiken.
sikit-Learn Library Installation
laten we eerst de library installeren.
sla deze stap niet over, omdat u ervoor moet zorgen dat u de laatste versie hebt geïnstalleerd.
u kunt de scikit-learn bibliotheek installeren met behulp van het PIP Python installatieprogramma, als volgt:
|
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
|
Classificatiedataset
We zullen de functie make_classification() gebruiken om een test binaire classificatiedataset te maken.
de dataset heeft 1.000 voorbeelden met 20 invoerfuncties, waarvan 10 informatief en 10 redundant zijn. Dit biedt een mogelijkheid voor elke techniek om redundante invoerfuncties te identificeren en te verwijderen.
de vaste random seed voor de pseudorandom number generator zorgt ervoor dat we dezelfde synthetische dataset genereren elke keer dat de code draait.
An example of creating and summarizing the synthetic classification dataset is listed below.
|
1
2
3
4
5
6
|
# synthetic classification dataset
from sklearn.datasets importeren make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# samenvatting van de dataset
print(X. vorm, y.vorm)
|
het Uitvoeren van het voorbeeld wordt de dataset en rapporten het aantal rijen en kolommen die overeenkomen met onze verwachtingen.
|
1
|
(1000, 20) (1000,)
|
It is a binary classification task and we will evaluate a LogisticRegression model after each dimensionality reduction transform.
het model zal worden geëvalueerd met behulp van de gouden standaard van herhaalde gestratificeerde 10-voudige kruisvalidatie. De gemiddelde en standaarddeviatie classificatienauwkeurigheid voor alle vouwen en herhalingen wordt gerapporteerd.
het voorbeeld hieronder evalueert het model op de ruwe dataset als vergelijkingspunt.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# evalueren logistische regressie model op ruwe data
van numpy importeren gemiddelde
van numpy importeer std
vanuit sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de logistische regressie op de ruwe dataset met alle 20 kolommen, met een classificatienauwkeurigheid van ongeveer 82,4 procent.
een succesvolle dimensionaliteitsreductietransformatie op deze gegevens moet resulteren in een model dat een betere nauwkeurigheid heeft dan deze baseline, hoewel dit mogelijk niet met alle technieken mogelijk is.
opmerking: We proberen deze dataset niet op te lossen, geef alleen werkvoorbeelden die u als startpunt kunt gebruiken.
|
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. Elke dimensionaliteitsreductiemethode zal worden geconfigureerd om de 20 invoerkolommen waar mogelijk te verminderen tot 10.
We zullen een pijplijn gebruiken om de gegevenstransformatie en het model te combineren tot een atomaire eenheid die kan worden geëvalueerd met behulp van de cross-validatieprocedure; bijvoorbeeld:
|
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?
Laat het me weten in de commentaren hieronder.
Principal Component Analysis
Principal Component Analysis, of PCA, kan de meest populaire techniek zijn voor dimensionaliteitsreductie met dichte gegevens (weinig nulwaarden).
voor meer informatie over hoe PCA werkt, zie de tutorial:
- Hoe Principal Component Analysis (PCA) vanuit het niets te berekenen in Python
De scikit-learn library biedt de PCA-klasse implementatie van Principal Component Analysis die kan worden gebruikt als een dimensionaliteitsreductie data transform. Het argument “n_components” kan worden ingesteld om het aantal gewenste afmetingen in de uitvoer van de transformatie in te stellen.
het volledige voorbeeld van de evaluatie van een model met PCA-dimensionaliteitsreductie wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren pca met logistische regressie algoritme voor classificatie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.decompositie importeer PCA
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval zien we geen lift in modelprestaties bij het gebruik van de PCA-transformatie.
|
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).
voor meer informatie over hoe SVD werkt, zie de tutorial:
- Hoe de SVD vanuit het niets te berekenen met Python
De sikit-learn-bibliotheek biedt de verkorte versie van de groepswaarde-decompositie die kan worden gebruikt als een gegevenstransformatietransformatie voor dimensionaliteitsreductie. Het argument “n_components” kan worden ingesteld om het aantal gewenste afmetingen in de uitvoer van de transformatie in te stellen.
het volledige voorbeeld van het evalueren van een model met SVD-dimensionaliteitsreductie wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren svd met logistische regressie algoritme voor classificatie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.decompositie importeren van Afgeknottesvd
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval zien we geen lift in modelprestaties bij het gebruik van de SVD-transformatie.
|
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.
het aantal dimensies voor de projectie is beperkt tot 1 en C-1, waarbij C het aantal klassen is. In dit geval is onze dataset een binair classificatieprobleem (twee klassen), waarbij het aantal dimensies wordt beperkt tot 1.
voor meer informatie over Lda voor dimensionaliteitsreductie, zie de tutorial:
- Lineaire Discriminant analyse voor Dimensionaliteitsreductie in Python
De sikit-learn library biedt de Lineairdiscriminantanalysis class implementatie van lineaire Discriminant analyse die kan worden gebruikt als een dimensionaliteitsreductiegegevens transformatie. Het argument “n_components” kan worden ingesteld om het aantal gewenste afmetingen in de uitvoer van de transformatie in te stellen.
het volledige voorbeeld van de evaluatie van een model met Lda-dimensionaliteitsreductie wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren lda met logistische regressie algoritme voor classificatie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.discriminant_analysis invoer Lineairdiscriminantanalysis
van 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval kunnen we een lichte verbetering zien in de prestaties in vergelijking met de baseline fit op de ruwe data.
|
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.
De scikit-learn-bibliotheek biedt de Isomap-klasse-implementatie van Isomap-inbedding die kan worden gebruikt als een gegevenstransformatietransformatie voor dimensionaliteitsreductie. Het argument “n_components” kan worden ingesteld om het aantal gewenste afmetingen in de uitvoer van de transformatie in te stellen.
het volledige voorbeeld van het evalueren van een model met SVD-dimensionaliteitsreductie wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren isomap met logistische regressie algoritme voor classificatie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.manifold importeert Isomap
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval kunnen we een lift in prestaties zien met de isomap-gegevenstransformatie vergeleken met de baseline fit op de ruwe gegevens.
|
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.
De scikit-learn bibliotheek biedt de locallylinearemedding class implementatie van lokaal Lineaire inbedding die kan worden gebruikt als een dimensionaliteitsreductiedata-transformatie. Het argument “n_components” kan worden ingesteld om het aantal gewenste afmetingen in de uitvoer van de transform
te configureren het volledige voorbeeld van het evalueren van een model met lle dimensionaliteitsreductie wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren lle en logistische regressies voor de taxonomie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.spruitstuk importeren Locallyline is bedding
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval kunnen we een verhoging van de prestaties zien met de lle-gegevenstransformatie in vergelijking met de baseline fit op de ruwe gegevens.
|
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.
De scikit-learn bibliotheek biedt de locallylinearemedding class implementatie van gewijzigde lokaal Lineaire inbedding die kan worden gebruikt als een dimensionaliteitsreductiedata-transformatie. Het “method” argument moet worden ingesteld op’ modified ‘ en het “n_components” argument kan worden ingesteld om het aantal gewenste dimensies in de uitvoer van de transformatie te configureren dat kleiner moet zijn dan het “n_neighbors” argument.
het volledige voorbeeld van de evaluatie van een model met gewijzigde dimensionaliteitsreductie van LLE wordt hieronder weergegeven.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# evalueren gewijzigd lle en logistieke regressies voor classificatie
van numpy import mean
van numpy import std
van sklearn.datasets importeren make_classificatie
vanuit sklearn.model_selection cross_val_score
importeren vanuit sklearn.model_selection Importeer RepeatedStratifiedKFold
vanuit sklearn.pijplijn Importeer pijplijn
vanuit sklearn.spruitstuk importeren Locallyline is bedding
vanuit 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) ‘ % (mean(n_scores), std(n_scores))
|
het uitvoeren van het voorbeeld evalueert de modelleringspijplijn met dimensionaliteitsreductie en een logistisch regressievoorspellend model.
Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.
in dit geval kunnen we een lift in prestaties zien met de gewijzigde lle-gegevenstransformatie in vergelijking met de baseline fit op de ruwe gegevens.
|
1
|
Accuracy: 0.846 (0.036)
|
Further Reading
This section provides more resources on the topic if you are looking to go deeper.
Tutorials
- Introduction to Dimensionality Reduction for Machine Learning
- Principal Component Analysis for Dimensionality Reduction in Python
- Singular Value Decomposition for Dimensionality Reduction in Python
- Lineaire Discriminant Analysis for Dimensionality Reduction in Python
API ‘ s
- Ontbindingssignalen in componenten, scikit-leer API.
- Manifold Learning, sikit-learn API.
samenvatting
In deze tutorial hebt u ontdekt hoe u topdimensionaliteitsreductiealgoritmen in Python kunt aanpassen en evalueren.
specifiek leerde u:
- Dimensionaliteitsreductie Zoekt Een lagere dimensionale weergave van numerieke invoergegevens die de opvallende relaties in de gegevens behoudt.
- Er zijn veel verschillende dimensionaliteitsreductiealgoritmen en er is geen enkele beste methode voor alle datasets.
- Hoe topdimensionaliteitsreductie in Python te implementeren, passen en evalueren met de sikit-learn machine learning library.
heeft u vragen?
Stel uw vragen in de opmerkingen hieronder en Ik zal mijn best doen om te beantwoorden.
Krijg grip op moderne gegevensvoorbereiding!
Bereid uw gegevens voor in minuten
…met slechts een paar regels python code
ontdek hoe in mijn nieuwe Ebook:
Data Preparation for Machine Learning
Het zelfstudie tutorials biedt met volledige werkende code op:
Feature Selection, RFE, data Cleaning, data Transforms, Scaling, Dimensionality Reduction, en nog veel meer…
breng moderne technieken voor gegevensvoorbereiding naar
uw Machine Learning-projecten
bekijk wat er in