6 Dimensjonsreduksjonsalgoritmer med Python

Tweet Share Share

Sist Oppdatert 17. August 2020

Dimensjonsreduksjon er en uovervåket læringsteknikk.

likevel kan det brukes som en data transform pre-prosessering trinn for maskinlæring algoritmer på klassifisering og regresjon prediktiv modellering datasett med veiledet læring algoritmer.

det er mange dimensjonsreduksjonsalgoritmer å velge mellom og ingen enkelt beste algoritme for alle tilfeller. I stedet er det en god ide å utforske en rekke dimensjonalitetsreduksjonsalgoritmer og forskjellige konfigurasjoner for hver algoritme.

i denne opplæringen vil du oppdage hvordan du passer og evaluerer toppdimensjonalitetsreduksjonsalgoritmer i Python.

Etter å ha fullført denne opplæringen, vil du vite:

  • Dimensjonsreduksjon søker en lavere dimensjonal representasjon av numeriske inngangsdata som bevarer de fremtredende forholdene i dataene.
  • det er mange forskjellige dimensjonsreduksjonsalgoritmer og ingen enkelt beste metode for alle datasett.
  • hvordan implementere, tilpasse og evaluere top dimensionality reduction I Python med scikit-learn machine learning library.Kick-start prosjektet ditt med min nye bokdataforberedelse For Maskinlæring, inkludert trinnvise opplæringsprogrammer og Python-kildekodefilene for alle eksempler.

    La oss komme i gang.

    Dimensjonsreduksjonsalgoritmer med Python

    Dimensjonsreduksjonsalgoritmer Med Python
    Foto Av Bernard Spragg. NZ, noen rettigheter reservert.

    Tutorial Oversikt

    denne opplæringen er delt inn i tre deler; de er:

    1. Dimensjonsreduksjonsalgoritmer
    2. Eksempler på Dimensjonsreduksjonsalgoritmer
    3. Scikit-Lær Bibliotekinstallasjon
    4. Klassifiseringsdatasett
    5. Hovedkomponentanalyse
    6. Singulær Verdi Dekomponering
    7. Lineær Diskriminantanalyse
    8. Isomap Innebygging
    9. Lokalt Lineær Innebygging
    10. Modifisert Lokalt lineær embedding
  • Dimensjonsreduksjon

    Dimensjonsreduksjon refererer til teknikker for å redusere Antall Inngangsvariabler i Treningsdata.

    når det gjelder høydimensjonale data, er det ofte nyttig å redusere dimensjonaliteten ved å projisere dataene til et lavere dimensjonalt underrom som fanger» essensen » av dataene. Dette kalles dimensjonsreduksjon.

    — Side 11, Maskinlæring: Et Probabilistisk Perspektiv, 2012.

    høydimensjonalitet kan bety hundrevis, tusenvis eller til og med millioner av inngangsvariabler.

    Færre inngangsdimensjoner betyr ofte tilsvarende færre parametere eller en enklere struktur i maskinlæringsmodellen, referert til som frihetsgrader. En modell med for mange grader av frihet vil sannsynligvis overpasse treningsdatasettet og kan ikke fungere bra på nye data.

    det er ønskelig å ha enkle modeller som generaliserer godt, og i sin tur inngangsdata med få inngangsvariabler. Dette gjelder spesielt for lineære modeller hvor antall innganger og frihetsgrader for modellen ofte er nært beslektet.

    Dimensjonsreduksjon Er en dataforberedelsesteknikk utført på data før modellering. Det kan utføres etter datarensing og dataskalering og før du trener en prediktiv modell.

    … dimensjonsreduksjon gir en mer kompakt, lettere tolkbar representasjon av målkonseptet, og fokuserer brukerens oppmerksomhet på de mest relevante variablene.

    — Side 289, Data Mining: Praktiske Maskinlæringsverktøy og Teknikker, 4.utgave, 2016.

    som sådan må enhver dimensjonsreduksjon utført på treningsdata også utføres på nye data, for eksempel et testdatasett, valideringsdatasett og data når du gjør en prediksjon med den endelige modellen.

    Vil Du Komme i Gang med Data Forberedelse?

    Ta min gratis 7-dagers e-lynkurs nå (med eksempelkode).

    Klikk for å registrere deg og få også en GRATIS Pdf Ebook-versjon av kurset.

    Last Ned Gratis Minikurs

    Dimensjonsreduksjonsalgoritmer

    det er mange algoritmer som kan brukes til dimensjonsreduksjon.To hovedklasser av metoder er de som er trukket fra lineær algebra og de som er trukket fra manifold læring.

    Lineære Algebra-Metoder

    Matrisefaktoriseringsmetoder hentet fra feltet lineær algebra kan brukes til dimensjonalitet.

    for mer om matrisefaktorisering, se opplæringen:

    • En Mild Introduksjon Til Matrisefaktorisering for Maskinlæring

    Noen av de mer populære metodene inkluderer:

    • Hovedkomponentanalyse
    • Singular Verdi Dekomponering
    • Ikke-Negativ Matrisefaktorisering

    Manifold Læringsmetoder

    Manifold læringsmetoder søker en lavere dimensjonal projeksjon av høy dimensjonal inngang som fanger de fremtredende egenskapene til inngangsdataene.

    Noen av de mer populære metodene inkluderer:

    • Isomap Embedding
    • Lokalt Lineær Embedding
    • Flerdimensjonal Skalering
    • Spektral Embedding
    • t-distribuert Stokastisk Nabo Embedding

    hver algoritme tilbyr en annen tilnærming til utfordringen med å oppdage naturlige relasjoner i data ved lavere dimensjoner.

    det er ingen beste dimensjonsreduksjonsalgoritme, og ingen enkel måte å finne den beste algoritmen for dataene dine uten å bruke kontrollerte eksperimenter.

    i denne opplæringen vil vi gjennomgå hvordan du bruker hver delmengde av disse populære dimensjonsreduksjonsalgoritmene fra scikit-learn-biblioteket.

    eksemplene vil gi grunnlag for å kopiere-lime inn eksemplene og teste metodene på dine egne data.Vi vil ikke dykke inn i teorien bak hvordan algoritmene fungerer eller sammenligne dem direkte. For et godt utgangspunkt om dette emnet, se:

    • Dekomponerende signaler i komponenter, scikit-learn API.
    • Manifold Læring, scikit-lær API.

    La oss dykke inn.

    Eksempler på Dimensjonsreduksjon

    i denne delen vil vi se på hvordan du bruker populære dimensjonsreduksjonsalgoritmer i scikit-learn.

    dette inkluderer et eksempel på bruk av dimensjonalitetsreduksjonsteknikken som datatransformasjon i en modelleringsrørledning og evaluering av en modell som passer på dataene.

    eksemplene er laget for at du skal kopiere og lime inn i ditt eget prosjekt og bruke metodene på dine egne data. Det er noen algoritmer tilgjengelig i scikit-learn biblioteket som ikke er demonstrert fordi de ikke kan brukes som en data transform direkte gitt arten av algoritmen.

    som sådan vil vi bruke et syntetisk klassifiseringsdatasett i hvert eksempel.

    Scikit-Lær Bibliotek Installasjon

    først, la oss installere biblioteket.

    ikke hopp over dette trinnet, da du må sørge for at du har den nyeste versjonen installert.

    du kan installere scikit-learn-biblioteket ved hjelp av pip Python installer, 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

    Klassifiseringsdatasett

    vi vil bruke make_classification () – funksjonen Til å lage et test-binært klassifiseringsdatasett.

    datasettet vil ha 1000 eksempler med 20 inngangsfunksjoner, hvorav 10 er informative og 10 er overflødige. Dette gir en mulighet for hver teknikk for å identifisere og fjerne overflødige inngangsfunksjoner.

    det faste tilfeldige frøet for pseudorandom nummergeneratoren sikrer at vi genererer det samme syntetiske datasettet hver gang koden kjø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.x, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
    # oppsummere datasettet
    skriv ut(x. form, y.form)

    kjører eksemplet oppretter datasettet og rapporterer antall rader og kolonner som samsvarer med våre forventninger.

    1
    (1000, 20) (1000,)

    It is a binary classification task and we will evaluate a LogisticRegression model after each dimensionality reduction transform.

    modellen vil bli evaluert ved hjelp av gullstandarden for gjentatt stratifisert 10-fold kryssvalidering. Gjennomsnittlig og standardavvik klassifisering nøyaktighet på tvers av alle folder og repetisjoner vil bli rapportert.

    eksemplet nedenfor evaluerer modellen på rå datasettet som et sammenligningspunkt.

    # evaluer logistisk regresjonsmodell på rådata
    fra numpy import mean
    fra numpy importer std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer 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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    Kjører eksemplet evaluerer logistisk regresjon på rå datasettet med alle 20 kolonner, og oppnår en klassifiseringsnøyaktighet på omtrent 82,4 prosent.en vellykket dimensjonsreduksjonstransformasjon på disse dataene bør resultere i en modell som har bedre nøyaktighet enn denne baseline, selv om dette kanskje ikke er mulig med alle teknikker.

    Merk: vi prøver ikke å «løse» dette datasettet, bare gi arbeidseksempler som du kan bruke som utgangspunkt.

    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 dimensjonsreduksjonsmetode vil bli konfigurert til å redusere de 20 inngangskolonnene til 10 der det er mulig.

    Vi vil bruke En Rørledning for å kombinere data transform og modell til en atom enhet som kan evalueres ved hjelp av kryssvalideringsprosedyren; 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?
    Gi meg beskjed i kommentarfeltet nedenfor.

    Hovedkomponentanalyse

    Hovedkomponentanalyse, ELLER PCA, kan være den mest populære teknikken for dimensjonalitetsreduksjon med tette data (få nullverdier).

    for mer om HVORDAN PCA fungerer, se veiledningen:

    • Hvordan Beregne Hovedkomponentanalyse (PCA) fra Bunnen Av I Python

    scikit-learn-biblioteket gir PCA-klasseimplementeringen av Hovedkomponentanalyse som kan brukes som en dimensjonsreduksjonsdatatransformasjon. Argumentet» n_components » kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen.

    det komplette eksempelet på å evaluere en modell MED PCA dimensjonsreduksjon er oppført nedenfor.

    # evaluer pca med logistisk regresjonsalgoritme for klassifisering
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer RepeatedStratifiedKFold
    fra sklearn.pipeline import Pipeline
    fra sklearn.dekomponeringsimport 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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    I dette tilfellet ser vi ingen løft i modellytelse ved bruk AV PCA-transformasjonen.

    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 mer OM HVORDAN SVD fungerer, se veiledningen:

    • Hvordan Beregne SVD fra Bunnen Av Med Python

    scikit-learn-biblioteket gir Avkortetsvd – klasseimplementeringen Av Singular Verdi Dekomponering som kan brukes som en dimensjonsreduksjonsdatatransformasjon. Argumentet» n_components » kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen.

    det komplette eksempelet på å evaluere en modell MED SVD dimensjonsreduksjon er oppført nedenfor.

    # evaluer svd med logistisk regresjonsalgoritme for klassifisering
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer RepeatedStratifiedKFold
    fra sklearn.pipeline import Pipeline
    fra sklearn.dekomponeringsimport Avkortetsvd
    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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    I dette tilfellet ser vi ingen løft i modellytelse ved BRUK AV SVD-transformasjonen.

    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.

    antall dimensjoner for projeksjonen er begrenset til 1 Og C-1, Hvor C er antall klasser. I dette tilfellet er datasettet vårt et binært klassifiseringsproblem (to klasser), som begrenser antall dimensjoner til 1.

    For mer OM lda for dimensjonsreduksjon, se veiledningen:

    • Lineær Diskriminantanalyse for Dimensjonsreduksjonsreduksjon I Python

    scikit-learn-biblioteket gir Den Lineære Diskriminantanalyseklasseimplementeringen Av Lineær Diskriminantanalyse som kan brukes som en dimensjonsreduksjonsdatatransformasjon. Argumentet» n_components » kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen.

    det komplette eksempelet på å evaluere en modell MED lda dimensjonsreduksjon er oppført nedenfor.

    # evaluer lda med logistisk regresjonsalgoritme for klassifisering
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer RepeatedStratifiedKFold
    fra sklearn.pipeline import Pipeline
    fra sklearn.discriminant_analysis import LinearDiscriminantAnalysis
    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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    i dette tilfellet kan vi se en liten løft i ytelse i forhold til baseline-passformen 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 gir Isomap – klasseimplementeringen Av Isomap-Embedding som kan brukes som en dimensjonsreduksjonsdatatransformasjon. Argumentet» n_components » kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen.

    det komplette eksempelet på å evaluere en modell MED SVD dimensjonsreduksjon er oppført nedenfor.

    # evaluer isomap med logistisk regresjonsalgoritme for klassifisering
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer 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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    i dette tilfellet kan vi se et løft i ytelse Med Isomap data transform i forhold til baseline fit på rådata.

    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-lær biblioteket gir LocallyLinearEmbedding klasse implementering Av Lokalt Lineær Innebygging som kan brukes som en dimensjons reduksjon data transform. Argumentet» n_components » kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen

    det komplette eksempelet på å evaluere en modell med lle dimensjonsreduksjon er oppført nedenfor.

    # evaluer lle og logistiske regresjoner for taksonomi
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer RepeatedStratifiedKFold
    fra sklearn.pipeline import Pipeline
    fra sklearn.manifold import LocallyLinearEmbedding
    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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    i dette tilfellet kan vi se et løft i ytelse MED LLE data transform i forhold til baseline fit på rådata.

    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-lær biblioteket gir LocallyLinearEmbedding klasse implementering Av Modifisert Lokalt Lineær Innebygging som kan brukes som en dimensjons reduksjon data transform. Argumentet «metode» må settes til «modifisert» og argumentet «n_components» kan settes til å konfigurere antall ønskede dimensjoner i utgangen av transformasjonen som må være mindre enn argumentet «n_neighbors».

    det komplette eksempelet på å evaluere en modell Med Modifisert lle dimensjonsreduksjon er listet opp nedenfor.

    # evaluer modifiserte lle-og logistiske regresjoner for klassifisering
    fra numpy import betyr
    fra numpy import std
    fra sklearn.datasett import make_classification
    fra sklearn.model_selection importer cross_val_score
    fra sklearn.model_selection importer RepeatedStratifiedKFold
    fra sklearn.pipeline import Pipeline
    fra sklearn.manifold import LocallyLinearEmbedding
    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) ‘ % (gjennomsnitt(n_scores), std (n_scores)))
    1
    3
    4
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19/div>

    Kjører eksemplet evaluerer modelleringsrørledningen med dimensjonal reduksjon og en logistisk regresjon prediktiv modell.

    Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.

    i dette tilfellet kan vi se et løft i ytelse med den modifiserte lle data transform i forhold til baseline fit på rådata.

    1
    Accuracy: 0.846 (0.036)

    Further Reading

    This section provides more resources on the topic if you are looking to go deeper.

    Guider

    • Introduksjon Til Dimensjonsreduksjon For Maskinlæring
    • Hovedkomponentanalyse For Dimensjonsreduksjon I Python
    • Singular Verdi Dekomponering for Dimensjonsreduksjon I Python

Apier

  • Dekomponerende signaler i komponenter, scikit-lær API.
  • Manifold Læring, scikit-lær API.

Sammendrag

i denne opplæringen oppdaget du hvordan du skal passe og evaluere toppdimensjonalitetsreduksjonsalgoritmer i Python.

Spesifikt lærte du:

  • Dimensjonsreduksjon søker en lavere dimensjonal representasjon av numeriske inngangsdata som bevarer de fremtredende relasjonene i dataene.
  • det er mange forskjellige dimensjonsreduksjonsalgoritmer og ingen enkelt beste metode for alle datasett.
  • hvordan implementere, tilpasse og evaluere top dimensionality reduction I Python med scikit-learn machine learning library.

har du noen spørsmål?
Still dine spørsmål i kommentarfeltet nedenfor, og jeg vil gjøre mitt beste for å svare.

Få Et Håndtak På Moderne Data Forberedelse!

Klargjøring av Data for Maskinlæring

Forbered Maskinlæringsdataene dine på Få Minutter

…Med bare noen få linjer med python-kode

Oppdag hvordan i min nye Ebok: Data Forberedelse For Maskinlæring

det gir selvstudium tutorials med full arbeids kode på:..

Ta Med Moderne Data Forberedelse Teknikker til
Din Maskin Læring Prosjekter

Se Hva Som Er Inni

Tweet Share Share

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.