6 Dimensionaalisuuden Vähennysalgoritmia Pythonilla

Posted on
Tweet Share Share

päivitetty viimeksi 17.elokuuta 2020

Dimensionaalisuuden vähentäminen on valvomaton oppimistekniikka.

sitä voidaan kuitenkin käyttää koneoppimisalgoritmien tiedon muuntamista edeltävänä prosessointivaiheena luokitus-ja regressioennakkomallinnusaineistoissa valvotuilla oppimisalgoritmeilla.

valittavana on monia dimensionaalisuuden vähennysalgoritmeja eikä yhtä parasta algoritmia kaikille tapauksille. Sen sijaan on hyvä tutkia erilaisia dimensionaalisuuden vähennysalgoritmeja ja erilaisia konfiguraatioita kullekin algoritmille.

tässä opetusohjelmassa opit sovittamaan ja arvioimaan Pythonin parhaita dimensionaalisuuden vähennysalgoritmeja.

tämän opetusohjelman suoritettuaan tietää:

  • Dimensionaalisuuden reduktio pyrkii numeerisen syöttötiedon alempiulotteiseen esitykseen, joka säilyttää tiedon keskeiset suhteet.
  • on olemassa monia erilaisia dimensionaalisuuden vähennysalgoritmeja, eikä kaikille tietojoukoille ole olemassa yhtä parasta menetelmää.
  • kuinka toteuttaa, sovittaa ja arvioida Pythonin huippudimensionaalisuuden vähentämistä scikit-learn machine learning-kirjastolla.

Kick-start your project with my new book Data Preparation for Machine Learning, including step-by-step tutorials and the Python source code files for all examples.

aloitetaan.

Dimensionality Reduction Algorithms with Python

Dimensionality Reduction Algorithms With Python
Photo by Bernard Spragg. NZ, jotkut oikeudet pidätetään.

opetusohjelma yleiskatsaus

Tämä opetusohjelma on jaettu kolmeen osaan; ne ovat:

  • Dimensionality Reduction
  • Examples of Dimensionality Reduction
  • Examples of Dimensionality Reduction
  • Classification Dataset
  • pääkomponenttianalyysi
  • Lineaarinen Diskriminanttianalyysi
  • Paikallisesti Lineaarinen Embedding

    • modified locally linear embedding

    dimensionality reduction

    Dimensionality reduction viittaa tekniikoihin, joilla vähennetään koulutustietojen Syöttömuuttujien määrää.

    suuriulotteista dataa käsiteltäessä on usein hyödyllistä pienentää dimensionaliteettia projisoimalla data alempaan dimensiolliseen aliavaruuteen, joka kaappaa datan ”olemuksen”. Tätä kutsutaan dimensionaalisuuden vähentämiseksi.

    — Page 11, Machine Learning: A Probabilistic Perspective, 2012.

    Suuridimensionaalisuus voi tarkoittaa satoja, tuhansia tai jopa miljoonia panosmuuttujia.

    vähemmän tulomittoja tarkoittaa usein vastaavasti vähemmän parametreja tai koneoppimismallissa yksinkertaisempaa rakennetta, jota kutsutaan vapausasteiksi. Malli, jossa on liian monta vapausastetta, on omiaan ylittämään koulutustietokannan, eikä se välttämättä pärjää hyvin uusilla tiedoilla.

    on toivottavaa, että käytössä on yksinkertaisia malleja, jotka yleistävät hyvin, ja vastaavasti syöttötietoja, joissa on vain vähän syöttömuuttujia. Tämä pätee erityisesti lineaarisiin malleihin, joissa mallin syöttömäärät ja vapausasteet liittyvät usein läheisesti toisiinsa.

    Dimensionality reduction on aineistolle ennen mallintamista tehty tiedonvalmistelutekniikka. Se voidaan suorittaa tietojen puhdistuksen ja tietojen skaalauksen jälkeen ja ennen ennakoivan mallin kouluttamista.

    … dimensionality reduction tuottaa kompaktimman, helpommin tulkittavan esityksen kohdekäsitteestä, kiinnittäen käyttäjän huomion olennaisimpiin muuttujiin.

    — Page 289, Data Mining: Practical Machine Learning Tools and Techniques, 4th edition, 2016.

    sinänsä kaikki koulutustietojen dimensionalennukset on tehtävä myös uusille tiedoille, kuten testiaineistolle, validointitiedoille ja tiedoille, kun tehdään ennustetta lopullisella mallilla.

    haluatko aloittaa tietojen valmistelun?

    ota ilmainen 7 päivän sähköpostin pikakurssi nyt (näytekoodilla).

    klikkaa ilmoittautuaksesi ja saat myös ilmaisen PDF Ebook-version kurssista.

    lataa ilmainen Minikurssi

    Dimensionality Reduction Algorithms

    on olemassa monia algoritmeja, joita voidaan käyttää dimensionality reduction.

    menetelmien kaksi pääluokkaa ovat lineaarialgebrasta ammennetut ja moninaisesta oppimisesta ammennetut.

    lineaarialgebran menetelmiä

    lineaarialgebran kentästä piirrettyjä matriisifaktorointimenetelmiä voidaan käyttää dimensionaalisuuteen.

    Lisää matriisifaktoroinnista, katso opetusohjelma:

    • a gently Introduction to Matrix Factorization for Machine Learning

    joitakin suositumpia menetelmiä ovat:

    • pääkomponenttianalyysi
    • yksikköarvon hajoaminen
    • ei-negatiivinen matriisi Factorization

    moninaiset oppimismenetelmät

    moninaiset oppimismenetelmät pyrkivät suuriulotteiseen projektioon, joka kaappaa syöttöaineiston keskeiset ominaisuudet.

    joitakin suositumpia menetelmiä ovat:

    • Isomap-Embedding
    • lokaalisti Lineaarinen Embedding
    • moniulotteinen skaalaus
    • spektrinen Embedding
    • t-hajautettu Stokastinen naapuri-Embedding

    jokainen algoritmi tarjoaa erilaisen lähestymistavan haasteeseen löytää luonnollisia suhteita datasta alemmissa ulottuvuuksissa.

    ei ole olemassa parasta dimensionaalisuuden vähennysalgoritmia, eikä helppoa tapaa löytää parasta algoritmia datallesi ilman kontrolloituja kokeita.

    tässä opetusohjelmassa käydään läpi, miten näitä scikit-learn-kirjaston suosittujen dimensionalgoritmien jokaista osajoukkoa käytetään.

    esimerkkien avulla voit kopioida esimerkit ja testata menetelmiä omilla tiedoillasi.

    emme sukella algoritmien toiminnan taustalla olevaan teoriaan tai vertaile niitä suoraan. Hyvä lähtökohta aiheesta, katso:

    • hajoavat signaalit komponenteissa, scikit-learn API.
    • moninainen oppiminen, scikit-learn API.

    sukelletaan.

    esimerkkejä Dimensionaalisuuden vähentämisestä

    tässä osiossa käydään läpi, miten suosittuja dimensionaalisuuden vähentämisalgoritmeja käytetään scikit-learnissa.

    Tähän sisältyy esimerkki dimensionaalisuuden vähentämistekniikan käyttämisestä datan muuntona mallintamisputkessa ja datan päälle sopivan mallin arvioimisesta.

    esimerkit on suunniteltu niin, että voit kopioida-liittää omaan projektiisi ja soveltaa menetelmiä omiin tietoihisi. Scikit-learn-kirjastossa on joitakin algoritmeja, joita ei ole osoitettu, koska niitä ei voida käyttää datamuunnoksena suoraan algoritmin luonteen vuoksi.

    sellaisenaan käytämme kussakin esimerkissä synteettistä luokitteluaineistoa.

    Skikit-Opi kirjasto-asennus

    ensin asennetaan kirjasto.

    älä ohita tätä vaihetta, sillä sinun on varmistettava, että sinulla on uusin versio asennettuna.

    voit asentaa scikit-Opi-kirjaston PIP Python-asennusohjelmalla seuraavasti:

    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

    Luokitustietokanta

    käytämme make_luokitusfunktiota() luodaksemme testibinaariluokitusaineiston.

    aineistossa on 1 000 esimerkkiä, joissa on 20 syöttöominaisuutta, joista 10 on informatiivisia ja 10 turhia. Tämä tarjoaa mahdollisuuden jokaiselle tekniikalle tunnistaa ja poistaa tarpeettomat syöttöominaisuudet.

    pseudorandomin lukugeneraattorin kiinteä satunnaissiemen varmistaa, että tuotamme saman synteettisen aineiston joka kerta, kun koodi toimii.

    An example of creating and summarizing the synthetic classification dataset is listed below.

    1
    2
    3
    4
    5
    6
    # synthetic classification dataset
    from sklearn.tietokokonaisuudet tuo make_luokitus
    # define tietokokonaisuus
    X, y = make_luokitus(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
    # summarize tietokokonaisuus
    print(X. shape, y.shape)

    esimerkin suorittaminen luo aineiston ja ilmoittaa odotuksiamme vastaavien rivien ja sarakkeiden määrän.

    1
    (1000, 20) (1000,)

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

    malli arvioidaan kultaisella standardilla toistuvasta ositetusta 10-kertaisesta ristiintarkistuksesta. Kaikkien taitosten ja toistojen keskimääräinen ja keskihajonnan luokitustarkkuus ilmoitetaan.

    alla oleva esimerkki arvioi raakadatan mallin vertailukohdaksi.

    # evaluate logistic regression model on raw data
    from numpy import Mean
    from numpy tuo std
    sklearnista.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.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) ’ % (keskiarvo(n_scores), std (n_scores))

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    esimerkin suorittaminen arvioi logistista regressiota raakatietokannassa kaikilla 20 sarakkeella, jolloin luokitustarkkuus on noin 82,4 prosenttia.

    onnistuneella dimensionaalisuuden vähentämismuunnoksella saadaan aikaan malli, jonka tarkkuus on tätä perustasoa parempi, vaikka tämä ei välttämättä ole mahdollista kaikilla tekniikoilla.

    Huomautus: emme yritä ”ratkaista” tätä aineistoa, vain tarjota toimivia esimerkkejä, joita voit käyttää lähtökohtana.

    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. Jokainen dimensionaalisuuden vähennysmenetelmä määritetään siten, että 20 tulosaraketta vähennetään mahdollisuuksien mukaan 10: een.

    käytämme putkilinjaa yhdistääksemme datan muuntamisen ja mallin atomiyksiköksi, joka voidaan arvioida ristivalidointimenettelyllä; esimerkiksi:

    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?
    kerro kommenteissa alla.

    pääkomponenttianalyysi

    pääkomponenttianalyysi eli PCA saattaa olla suosituin menetelmä dimensionaalisuuden vähentämiseen tiheällä aineistolla (muutama nolla-arvo).

    lisätietoja PCA: n toiminnasta on opetusohjelmassa:

    • miten pääkomponenttianalyysi (PCA) lasketaan tyhjästä Pythonissa

    scikit-learn-kirjasto tarjoaa Pääkomponenttianalyysin PCA-luokan toteutuksen, jota voidaan käyttää dimensionaalisuuden vähentämiseen datamuunnoksena. ”N_components” – argumentti voidaan asettaa määrittämään haluttujen mittojen määrä muunnoksen ulostulossa.

    alla on täydellinen esimerkki mallin arvioinnista, jossa PCA-mitoitusta on vähennetty.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # evaluate PCA with logistic regression algorithm for luokittelu
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.hajoaminen tuo PCA
    sklearnista.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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa emme näe PCA-muunnoksen käytössä mitään nostetta mallin suorituskyvyssä.

    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).

    lisätietoja SVD: n toiminnasta on opetusohjelmassa:

    • miten SVD lasketaan tyhjästä Pythonilla

    scikit-learn-kirjasto tarjoaa typistetyn SVD-luokan toteutuksen yksikköarvon hajoamisesta, jota voidaan käyttää dimensionaalisuuden vähentämiseen datamuunnoksena. ”N_components” – argumentti voidaan asettaa määrittämään haluttujen mittojen määrä muunnoksen ulostulossa.

    alla on täydellinen esimerkki mallin arvioinnista, jossa SVD: n dimensionaliteettia on vähennetty.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # evaluate SVD with logistic regression algorithm for luokittelu
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.hajoaminen tuonti typistetty SVD
    alkaen 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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa emme näe mitään nostetta mallin suorituskyvyssä SVD-muunnoksen käytössä.

    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.

    projektion dimensioiden lukumäärä on rajoitettu 1: een ja C-1: een, missä C on luokkien lukumäärä. Tässä tapauksessa tietojoukkomme on binäärinen luokitteluongelma (kaksi luokkaa), rajoittaen dimensioiden määrän 1: een.

    lisätietoja dimensionaalisuuden vähentämiseen tarkoitetusta Lda: sta on opetusohjelmassa:

    • Dimensionaalisuuden vähentämiseen tähtäävä Lineaarinen Diskriminanttianalyysi pythonissa

    scikit-learn-kirjasto tarjoaa Lineaarisekriminanttianalyysiluokan toteutuksen lineaarisesta Diskriminanttianalyysistä, jota voidaan käyttää dimensionaalisuuden vähentämisen datamuunnoksena. ”N_components” – argumentti voidaan asettaa määrittämään haluttujen mittojen määrä muunnoksen ulostulossa.

    alla on täydellinen esimerkki mallin arvioinnista, jossa LDA-mitoitus pienenee.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # arvioi Lda logistisella regressioalgoritmilla luokittelu
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
    from 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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa voidaan nähdä pientä nousua suorituskyvyssä verrattuna lähtötasoon raakadatan perusteella.

    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-kirjasto tarjoaa isomap-upotuksen isomap-luokkatoteutuksen, jota voidaan käyttää dimensionaalisuuden vähennystiedon muuntona. ”N_components” – argumentti voidaan asettaa määrittämään haluttujen mittojen määrä muunnoksen ulostulossa.

    alla on täydellinen esimerkki mallin arvioinnista, jossa SVD: n dimensionaliteettia on vähennetty.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # arvioi isomap logistisella regressioalgoritmilla luokittelu
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.manifold import isomap
    from 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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa voimme nähdä isomap-datamuunnoksen suorituskyvyn kohonneen verrattuna raakadatan perustasoon.

    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-kirjasto tarjoaa Lokaalilinearembedding-luokan toteutuksen Lokaalisesta lineaarisesta upotuksesta, jota voidaan käyttää dimensionaalisuuden vähentämistiedon muunnoksena. ”N_components” – argumentti voidaan asettaa määrittelemään haluttujen dimensioiden määrä muunnoksen ulostulossa

    täydellinen esimerkki mallin arvioinnista LLE-dimensionaalisuuden vähennyksellä on alla.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # evaluate lle and logistic regressions for taxonomy
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.manifold import LocallyLinearEmbedding
    from 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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa voimme nähdä, että LLE-datamuunnoksen suorituskyky kohoaa verrattuna lähtötasoon raakadatassa.

    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-kirjasto tarjoaa muunnellun Paikallisesti lineaarisen upotuksen LocallyLinearEmbedding-luokan toteutuksen, jota voidaan käyttää dimensionaalisuuden vähennystiedon muuntona. ”Method” – argumentiksi on asetettava” modified ”ja” n_components ”- argumentiksi voidaan määrittää muunnoksen ulostulossa haluttujen mittojen määrä, jonka on oltava pienempi kuin ”n_neighbors” – argumentti.

    alla on täydellinen esimerkki mallin arvioinnista, jossa on muutettu LLE-mitoitusta.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # evaluate modified lle and logistic regressions for luokittelu
    from numpy import mean
    from numpy import std
    from sklearn.tietojoukot tuovat make_luokituksen
    sklearnista.model_ selection import cross_val_score
    from sklearn.model_ selection tuo toistettua Stratifiedfoldia
    sklearnista.pipeline import Pipeline
    from sklearn.manifold import LocallyLinearEmbedding
    from 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) ’ % (keskiarvo(n_scores), std(n_scores))

    esimerkin avulla arvioidaan mallintamisputkea dimensionaalisuuden vähentämisellä ja logistisen regression ennustavalla mallilla.

    huomaa: tuloksesi voivat vaihdella algoritmin tai arviointimenettelyn stokastisen luonteen tai numeerisen tarkkuuden erojen vuoksi. Harkitse esimerkin ajamista muutaman kerran ja vertaa keskimääräistä lopputulosta.

    tässä tapauksessa voimme nähdä nosteen suorituskyvyssä muokatulla LLE-datamuunnoksella verrattuna lähtötasoon, joka sopii raakadataan.

    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
    • Linear Discriminant Analysis for Dimensionality Reduction in Python

    APIs

    • Decomposing signals in components, scikit-learn API.
    • moninainen oppiminen, scikit-learn API.

    Yhteenveto

    tässä opetusohjelmassa keksit, miten Pythonin dimensionaalisuuden vähentämisalgoritmeja voi sovittaa ja arvioida.

    erityisesti opit:

    • Dimensionaalisuuden reduktio pyrkii numeerisen syöttötiedon alempiulotteiseen esitykseen, joka säilyttää tiedon keskeiset suhteet.
    • on olemassa monia erilaisia dimensionaalisuuden vähennysalgoritmeja, eikä kaikille tietojoukoille ole olemassa yhtä parasta menetelmää.
    • kuinka toteuttaa, sovittaa ja arvioida Pythonin huippudimensionaalisuuden vähentämistä scikit-learn machine learning-kirjastolla.

    onko sinulla kysyttävää?
    kysy kysymyksesi alla olevissa kommenteissa ja teen parhaani vastatakseni.

    Get a Handle on Modern Data Preparation!

    tietojen valmistelu koneoppimiseen

    valmista koneoppimisen tiedot minuuteissa

    …vain muutamalla rivillä python-koodia

    Discover how in my new Ebook:
    data Preparation for Machine Learning

    It provides self-study tutorials with full working code on:
    Feature Selection, RFE, Data Cleaning, Data Transforms, Scaling, Dimensionality Reduction, and much more…

    tuo nykyaikaiset Tiedonvalmistustekniikat
    Koneoppimisprojekteihisi

    See What ’ s Inside

    Tweet Share Share

    Vastaa

    Sähköpostiosoitettasi ei julkaista.