Tämän lukemisen päätavoitteena on ymmärtää tarpeeksi tilastollista metodologiaa voidakseen hyödyntää kirjastossa olevia koneoppimisalgoritmeja scikit-oppia Python ja soveltaa sitten tätä tietoa ratkaistaksemme klassisen koneoppimisongelman.

Matkan ensimmäinen pysäkki vie meidät läpi lyhyen koneoppimisen historian. Sitten sukelamme erilaisiin algoritmeihin. Viimeisessä pysähdyksessä käytämme oppimiamme ratkaisemaan Titanicin eloonjäämisnopeuden ennustusongelma .

Jotkut vastuuvapauslausekkeet:

• Olen ohjelmistoinsinööri täysi pino , ei koneoppimisalgoritmien asiantuntija.
• Luulen, että tiedät jotain perusasiat Python .
• Tämä on tutkiva, joten kaikkia yksityiskohtia ei selitetä, miten se olisi opetusohjelma .

Kun sanotaan, aloitetaan!

Pika esittely koneoppimisalgoritmeista

Heti kun lähdet tälle kentälle, huomaat sen koneoppiminen se on vähemmän romanttista kuin luulet. Alun perin olin täynnä toiveita siitä, että oppimiseni jälkeen voisin rakentaa oman AI Jarvisini, että vietän koko päivän ohjelmistojen koodaamiseen ja rahan ansaitsemiseen itselleni, jotta voisin viettää kokonaisia ​​päiviä ulkona lukemalla kirjoja, ajaessani moottoripyörällä ja nauttiminen holtittomasta elämäntavasta, kun henkilökohtainen Jarvis saa taskuni syvemmälle. Pian kuitenkin tajusin, että koneoppimisalgoritmien perusta on tilasto, jonka pidän henkilökohtaisesti tylsänä ja mielenkiintoisena. Onneksi kävi ilmi, että 'tylsillä' tilastoilla on erittäin kiehtovia sovelluksia.

Pian huomaat, että päästäksesi kiehtoviin sovelluksiin, sinun on ymmärrettävä tilastot hyvin. Yksi koneoppimisalgoritmien tavoitteista on löytää tilastolliset riippuvuudet toimitetuista tiedoista.

Toimitetut tiedot voivat vaihdella verenpaineen tarkistamisesta iän suhteen käsinkirjoitetun tekstin löytämiseen eri pikselien värin perusteella.

Tämän sanottuani olin utelias näkemään, voisinko käyttää koneoppimisalgoritmeja löytääksesi riippuvuuksia salauksen hash-funktioista (SHA, MD5 jne.) - et kuitenkaan voi tehdä sitä, koska asianmukaiset salauksen primitiivit on rakennettu tällä tavalla että ne eliminoivat riippuvuudet ja tuottavat tuloksia, joita on huomattavasti vaikea ennustaa. Luulen, että äärettömän ajan kuluttua koneoppimisalgoritmit voisivat murtaa minkä tahansa salausmallin.

Valitettavasti meillä ei ole niin paljon aikaa, joten meidän on löydettävä toinen tapa kryptovaluutan tehokkaaseen louhintaan. Kuinka pitkälle olemme tulleet niin pitkälle?

Lyhyt historia koneoppimisalgoritmeista

Koneoppimisalgoritmien juuret ovat peräisin Thomas Bayesilta, joka oli englantilainen tilastotieteilijä ja asui 1700-luvulla. Hänen artikkelinsa Essee mahdollisuuksien opin ongelman ratkaisemiseksi taustalla Bayesin lause , jota käytetään laajasti tilastojen alalla.

1800-luvulla Pierre-Simon Laplace julkaisi Analyyttinen todennäköisyysteoria , laajentamalla Bayesin työtä ja määrittelemällä nykyisen Bayesin lauseeksi. Pian ennen Adrien-Marie Legendre kuvaili 'pienimmän neliösumman' menetelmää, jota käytetään nykyään myös laajasti valvotussa oppimisessa.

1900-luku on aika, jolloin suurin osa julkisesti tunnetuista löydöistä on tehty tällä alalla. Andrey Markov keksi Markov-ketjut, joita hän analysoi runoja. Alan Turing ehdotti oppimiskonetta, josta voisi tulla keinotekoisesti älykäs, pohjimmiltaan ennakoiden geneettisiä algoritmeja. Frank Rosenblatt keksi Perceptron , joka herätti suurta jännitystä ja suurta medianäkyvyyttä.

Mutta sitten, 1970-luvulla, tekoälyn ajatuksen ympärillä oli paljon pessimismiä ja siten rahoituksen vähenemistä, minkä vuoksi tätä aikaa kutsutaan talveksi. Takaisinlevityksen uudelleen löytäminen 1980-luvulla herätti koneoppimisen tutkimuksen elpymistä. Ja tänään, se on jälleen kuuma aihe.

Edesmennyt Leo Breiman erotti kaksi tilastollista paradigman mallia. 'Algoritminen mallinnus', joka tarkoittaa enemmän tai vähemmän koneoppimisalgoritmeja, samanlaisia ​​kuin satunnainen metsä .

Koneoppiminen ja tilastot liittyvät toisiinsa. Michael I.Jordanin mukaan Koneoppimisideoilla metodologisista periaatteista teoreettisiin välineisiin on ollut pitkä esihistoria tilastoissa. Se ehdotti myös dating tiede vakaana terminä yleiseen ongelmaan, jossa koneoppimisen asiantuntijat ja valtionmiehet ovat työskennelleet.

Koneoppimisalgoritmien luokat

Koneoppimisen ala on perustettu kahteen pääpylvääseen, joita kutsutaan ohjattu oppiminen Y valvomaton oppiminen . Jotkut ihmiset harkitsevat myös uutta tutkimusaluetta, kuten syvä oppiminen —Se on erillään valvotun tai valvomattoman oppimisen yleisestä kysymyksestä.

Ohjattu oppiminen tapahtuu, kun tietokoneelle esitetään esimerkkejä tuloista ja niiden haluttuista lähdöistä. Tavoitteena on oppia yleisistä kaavoista, jotka kartoittavat panokset tuotoksiin. Tämä voidaan jakaa seuraavasti:

• Puoliohjattu oppiminen , tapahtuu, kun tietokoneelle annetaan keskeneräinen koulutus ja puuttuvat lähdöt
• Aktiivinen oppiminen , tapahtuu, kun tietokone voi hankkia oppimistunnisteita vain rajoitetulle joukolle esiintymiä. Vuorovaikutteisesti käytettynä harjoittelupaketit voidaan näyttää käyttäjälle tunnisteella
• Vahvistusoppiminen , tapahtuu, kun harjoitustiedot annetaan vain palautteena ohjelman toiminnoille dynaamisessa ympäristössä, kuten ajoneuvon ajaminen tai pelaaminen vastustajaa vastaan

Sen sijaan valvomaton oppiminen Se tapahtuu, kun tarroja ei myönnetä, ja algoritmin tehtävänä on löytää rakenne syötteestään. Valvomaton oppiminen voi olla tavoite sinänsä, kun meidän on vain löydettävä piilotettuja malleja.

Syvä oppiminen Se on uusi tutkimusala, joka on innoittamana ihmisen aivojen rakenteesta ja toiminnasta, samalla tavalla kuin se perustuu keinotekoisiin hermoverkkoihin pelkkien tilastollisten käsitteiden sijaan. Syvää oppimista voidaan käyttää sekä valvotuissa että valvomattomissa lähestymistavoissa.

Tässä artikkelissa tarkastelemme joitain yksinkertaisempia valvottuja koneoppimisalgoritmeja ja käytämme niitä laskemaan yksilön selviytymiskertoimet titaanin traagisessa uppoamisessa. Mutta yleensä, jos et ole varma, mitä algoritmia haluat käyttää, hyvä paikka aloittaa on Koneoppimisen algoritmin tarkastelusivu scikit-oppia .

Valvotun koneoppimisen perusmallit

Ehkä yksinkertaisin algoritmi on lineaarinen regressio. Joskus tämä voidaan esittää graafisesti suorana viivana, mutta nimestään huolimatta tämä viiva voi olla käyrä, jos polynomihypoteesi on olemassa. Kummassakin tapauksessa mallinnetaan suhteet skalaarista riippuvan muuttujan $ ja $ ja yhden tai useamman selittävän arvon välillä, joita merkitään $ x $: lla.

Maallikon termeillä tämä tarkoittaa, että lineaarinen regressio on algoritmi, joka oppii jo tunnettujen $ x $: n ja $ y $: n välisen riippuvuuden niin paljon, että voimme käyttää sitä ennustamaan $ y $ tuntemattomalle $ x -näytteelle. $.

Ensimmäisessä valvotussa oppimisesimerkissämme käytämme lineaarisen regressiomallin ennustamaan henkilön verenpaineen iän perusteella. Itään Se on hyvin yksinkertainen tietojoukko, jolla on kaksi tärkeää ominaisuutta: ikä ja verenpaine.

Kuten edellä mainittiin, useimmat koneoppimisalgoritmit toimivat löytämällä tilastollinen riippuvuus heille toimitetuista tiedoista. Tätä riippuvuutta kutsutaan a hypoteesi ja sitä merkitään yleensä arvolla $ h ( theta) $.

Tämän hypoteesin tulkitsemiseksi aloitetaan lataamalla ja tutkimalla tietoja.

import matplotlib.pyplot as plt from pandas import read_csv import os # Cargar datos data_path = os.path.join(os.getcwd(), 'data/blood-pressure.txt') dataset = read_csv(data_path, delim_whitespace=True) # Tenemos 30 entradas en nuestro set de data y cuatro características. La primera característica es la identificación de la entrada. # La segunda característica siempre es la nro. 1. La tercera es la edad y la última es la presión arterial. # Ahora dejaremos de lado la Identificación y la característica Uno por ahora, ya que no es importante. dataset = dataset.drop(['ID', 'One'], axis=1) # Y mostraremos esta gráfica %matplotlib inline dataset.plot.scatter(x='Age', y='Pressure') # Ahora, asumiremos que ya sabemos la hipótesis y parece una línea recta h = lambda x: 84 + 1.24 * x # ahora agreguemos esta línea a la gráfica ages = range(18, 85) estimated = [] for i in ages: estimated.append(h(i)) plt.plot(ages, estimated, 'b')

[]

Yllä olevassa kaaviossa kukin sininen piste edustaa näytetietojamme ja sininen viiva on hypoteesi, jonka algoritmin on opittava. Joten mikä tämä hypoteesi on?

Tämän ongelman ratkaisemiseksi meidän on opittava riippuvuus $ x $: n ja $ y $: n välillä, jota merkitään $ y = f (x) $. Siksi $ f (x) $ on ihanteellinen tavoitetoiminto. Koneoppimisalgoritmi yrittää arvata hypoteesifunktion $ h (x) $, joka on tuntemattoman $ f (x) $: n lähin likiarvo.

Lineaarisen regressio-ongelman yksinkertaisin hypoteesimuoto näyttää tältä: $ h_ theta (x) = theta_0 + theta_1 * x $. Meillä on yksinkertainen skalaarimuuttuja $ x $, joka tuottaa yksinkertaisen skalaarimuuttujan $ y $, jossa $ theta_0 $ ja $ theta_1 $ ovat parametreja, jotka meidän on opittava. Tämän sinisen viivan sovittamista prosessiin kutsutaan lineaariseksi regressioksi. On tärkeää ymmärtää, että meillä on vain yksi syöttöparametri $ x_1 $; monet hypoteesifunktiot sisältävät kuitenkin myös kaltevaa yksikköä ($ x_0 $). Joten tuloksena olevan hypoteesimme muoto on $ h_ theta (x) = theta_0 * x_0 + theta_1 * x_1 $. Mutta voimme välttää $ x_0 $: n kirjoittamisen, koska se on melkein aina yhtä kuin 1.

Palataan siniseen viivaan. Hypoteesimme näyttää tältä $ h (x) = 84 + 1,24x $, mikä tarkoittaa, että $ theta_0 = 84 $ ja $ theta_1 = 1,24 $. Kuinka voimme johtaa nämä $ theta $ -arvot automaattisesti?

Meidän on määriteltävä a kustannustoiminto . Pohjimmiltaan kustannusfunktio laskee ennustemallin ja itse tuotoksen välisen juuren neliövirheen.

[J ( theta) = frac {1} {2m} sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i)}) ^ 2 ]

Esimerkiksi hypoteesimme ennustaa, että jollekin, joka on 48-vuotias, hänen verenpaineensa tulisi olla $ h (48) = 84 + 1,24 * 48 = 143 mmHg $; Koulutusnäytteessämme arvo on kuitenkin 130 dollaria mmHg $. Siksi virhe on $ (143-130) ^ 2 = $ 169. Nyt meidän on laskettava tämä virhe jokaiselle syötteelle harjoittelutietojoukossa ja lisättävä se sitten kaikki yhteen ($ sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i )}) ^ 2 $) ja ota merkittävä arvo sieltä. Tämä antaa meille yhden skalaariluvun, joka edustaa funktion kustannuksia. Tavoitteenamme on löytää arvot $ theta $, jotta kustannusfunktio on pienempi; toisin sanoen haluamme minimoida kustannustoiminnon. Toivottavasti tämä on intuitiivista: jos meillä on pieni kustannusfunktion arvo, se tarkoittaa, että myös ennustusvirhe olisi pieni.

import numpy as np # Calculemos el costo para la hipótesis de arriba h = lambda x, theta_0, theta_1: theta_0 + theta_1 * x def cost(X, y, t0, t1): m = len(X) # the number of the training samples c = np.power(np.subtract(h(X, t0, t1), y), 2) return (1 / (2 * m)) * sum(c) X = dataset.values[:, 0] y = dataset.values[:, 1] print('J(Theta) = %2.2f' % cost(X, y, 84, 1.24))

J(Theta) = 1901.95

Nyt meidän on löydettävä $ theta $: n arvot niin paljon kuin meidän kustannustoiminto on minimaalinen. Mutta miten voimme tehdä sen?

[minJ ( theta) = frac {1} {2m} sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i)}) ^ 2 ]

Algoritmeja on monia, mutta suosituin on alaspäin kaltevuus . Laittakoon se ensin kaavioon ymmärtääksemme gradientin laskeutumismenetelmän taustalla olevaa intuitiota. Oletamme yksinkertaisuuden vuoksi yksinkertaisemman hypoteesin $ h ( theta) = theta_1 * x $. Sitten meillä on yksinkertainen 2D-kaavio, jossa $ x $ on $ theta $: n arvo ja $ y $ on kustannusfunktio tässä vaiheessa.

import matplotlib.pyplot as plt fig = plt.figure() # Genera los datos theta_1 = np.arange(-10, 14, 0.1) J_cost = [] for t1 in theta_1: J_cost += [ cost(X, y, 0, t1) ] plt.plot(theta_1, J_cost) plt.xlabel(r'$ heta_1$') plt.ylabel(r'$J( heta)$') plt.show()

Kustannusfunktio on kupera, mikä tarkoittaa, että aikavälillä $ [a, b] $ on vain yksi minimi. Mikä tarkoittaa, että parhaat parametrit $ theta $ ovat kohdassa, jossa kustannusfunktio on pienin.

Periaatteessa kaltevuuslasku on algoritmi, joka yrittää löytää joukon parametreja, jotka minimoivat toiminnon. Se alkaa alkuparametreillä ja ottaa vuorovaikutteisesti askeleita kohti gradienttitoiminnon negatiivista suuntaa.

Jos laskemme hypoteesifunktion derivaatin tietyssä pisteessä, se antaa meille suoran pääsyn käyrän tangenttiin kyseisessä pisteessä. Tämä tarkoittaa, että voimme laskea pikakuvakkeen kaavion jokaisessa kohdassa.

Algoritmin toiminta on seuraava:

1. Valitsemme lähtökohdan satunnaisesti ($ theta $ satunnaisesti).
2. Etsi tässä vaiheessa kustannusfunktion derivaatti.
3. Ota pieni askel kohti pikakuvaketta $ theta_j: = theta_j - lambda * frac { partituali { osittainen theta_j} * J ( theta) $.
4. Toista vaiheet 2–3, kunnes se on lähentynyt.

Lähentymisehto riippuu nyt algoritmin toteutuksesta. Ehkä pysähdymme 50 askeleen jälkeen, jonkin nikaman tai muun jälkeen.

import math # Ejemplo del algoritmo simple de descenso gradiente tomado de Wikipedia cur_x = 2.5 # The algorithm starts at point x gamma = 0.005 # Step size multiplier precision = 0.00001 previous_step_size = cur_x df = lambda x: 2 * x * math.cos(x) # Recuerda la curva de aprendizaje y establécela while previous_step_size > precision: prev_x = cur_x cur_x += -gamma * df(prev_x) previous_step_size = abs(cur_x - prev_x) print('The local minimum occurs at %f' % cur_x)

El mínimo local pasa en 4.712194

Emme ota näitä algoritmeja käyttöön tässä artikkelissa. Sen sijaan käytämme jo hyväksyttyä scikit-learn -pythonin avoimen lähdekoodin koneoppimiskirjastoa. Se tarjoaa monia hyödyllisiä sovellusliittymiä erilaisille tiedonlouhinta- ja koneoppimisongelmille.

De sklearn.linear_model importar LinearRegression # La Regresión Lineal usa el método de descenso gradiente # Nuestra data X = dataset[['Age']] y = dataset[['Pressure']] regr = LinearRegression() regr.fit(X, y) # Salidas Argumentadas plt.xlabel('Age') plt.ylabel('Blood pressure') plt.scatter(X, y, color='black') plt.plot(X, regr.predict(X), color='blue') plt.show() plt.gcf().clear()

print( 'Predicted blood pressure at 25 y.o. = ', regr.predict(25) ) print( 'Predicted blood pressure at 45 y.o. = ', regr.predict(45) ) print( 'Predicted blood pressure at 27 y.o. = ', regr.predict(27) ) print( 'Predicted blood pressure at 34.5 y.o. = ', regr.predict(34.5) ) print( 'Predicted blood pressure at 78 y.o. = ', regr.predict(78) ) Predicted blood pressure at 25 y.o. = [[ 122.98647692]] Predicted blood pressure at 45 y.o. = [[ 142.40388395]] Predicted blood pressure at 27 y.o. = [[ 124.92821763]] Predicted blood pressure at 34.5 y.o. = [[ 132.20974526]] Predicted blood pressure at 78 y.o. = [[ 174.44260555]]

Tilastotietojen tyypit

Koneoppimisongelmien kanssa työskenneltäessä on tärkeää tietää, kuinka tunnistaa erityyppiset tiedot. Se voi olla numeerista (jatkuvaa tai erillistä), kategorista tai järjestysdataa.

Numeeriset tiedot niillä on merkitys mittana. Esimerkiksi: henkilön ikä, paino, bitcoinien määrä tai kuinka monta artikkelia henkilö voi kirjoittaa kuukaudessa. Numeerinen data voi olla myös erillistä tai jatkuvaa.

• Diskreetit tiedot edustavat tietoja, jotka voidaan laskea kokonaislukuina, esimerkiksi huoneiston huoneiden lukumäärä tai kolikon käännösajat.
• Jatkuvaa dataa ei välttämättä esitetä kokonaisluvuilla. Jos esimerkiksi mittaat etäisyyttä, jonka voit hypätä, se voi olla 2 metriä tai 1,5 metriä tai ehkä 1,652245.

Luokkatiedot ne edustavat arvoja, kuten henkilön sukupuoli, siviilisääty, maa jne. Nämä tiedot voivat olla numeerisia, mutta näillä numeroilla ei olisi matemaattista arvoa. Et voi lisätä niitä.

Järjestysdata se voi olla sekoitus muita tyyppejä, joissa luokat voitaisiin numeroida matemaattisesti merkityksellisellä tavalla. Yleinen esimerkki on luokitukset: Meitä pyydetään usein arvioimaan asiat asteikolla yhdestä kymmeneen, ja tällaisissa tapauksissa vain kokonaisluvut ovat sallittuja. Vaikka voimme käyttää näitä tietoja numeerisesti (esimerkiksi löytääksemme jonkin keskimääräisen sijoituksen), käsittelemme näitä tietoja usein kategorisina sovellettaessa koneoppimismenetelmiä.

Logistinen regressio

Lineaarinen regressio on uskomaton algoritmi, joka auttaa meitä ennustamaan numeerisia arvoja, kuten tietyn koon talon ja tiettyjen huoneiden hinta. Toisinaan voimme kuitenkin ennustaa kategorisia tietoja saadaksemme vastauksia esimerkiksi:

• Onko se koira vai kissa?
• Onko tämä kasvain pahanlaatuinen tai hyvänlaatuinen?
• Onko tämä viini hyvä vai huono?
• Onko tämä sähköposti roskapostia vai ei?

Tai jopa:

• Mikä numero on tässä valokuvassa?
• Mihin luokkaan tämä sähköposti kuuluu?

Kaikki nämä kysymykset koskevat erityisesti luokitusongelma . Ja kutsutaan yksinkertaisin luokitusalgoritmi Logistinen regressio , joka on lopulta yhtä suuri kuin regressio lineaarinen Paitsi että sinulla on erilainen hypoteesi.

Ensinnäkin voimme käyttää samaa lineaarista hypoteesia $ h_ theta (x) = theta ^ T X $ (tämä on vektoroidussa muodossa). Vaikka lineaarinen regressio voisi tuottaa minkä tahansa luvun välillä $ [a, b] $, logistinen regressio voi saada arvot vain $ [- 1, 1] $: ssa, mikä viittaa todennäköisyyteen, että objekti kuuluu luokkaan tai ei.

Jos käytämme a sigmoidifunktio , voimme muuntaa minkä tahansa numeerisen arvon edustamaan arvoa alueella $ [- 1, 1] $.

[f (x) = frac {1} {1 + e ^ x} ]

Nyt $ x $: n sijaan meidän on läpäistävä olemassa oleva hypoteesi ja saisimme:

[f (x) = frac {1} {1 + e ^ { theta_0 + theta_1 * x_1 + ... + theta_n * x_n}} ]

Tämän jälkeen voimme soveltaa yksinkertaista kynnystä, joka sanoo, että jos hypoteesi on suurempi kuin nolla, se on todellinen arvo, muuten se on väärä.

[h_ theta (x) = aloita {tapaukset} 1 & mbox {if} theta ^ T X> 0 \ 0 & mbox {muut} loppu {tapaukset} ]

Tämä tarkoittaa, että voimme käyttää samaa kustannustoiminto ja sama laskeva gradienttialgoritmi logistisen regressiohypoteesin oppimiseksi.

Seuraavassa koneoppimisesimerkissä neuvomme avaruussukkulalentäjiä pitäisikö heidän hallita laskeutumista manuaalisesti vai automaattisesti. Meillä on hyvin pieni tietojoukko —15 näytettä - koostuvat kuudesta ominaisuudesta ja perustotuus .

Koneoppimisalgoritmeissa termi “ perustotuus ”Viittaa valvottujen oppimistekniikoiden harjoitussarjojen luokittelun oikeellisuuteen.

Tietojoukkomme on valmis, mikä tarkoittaa, ettei puuttuvia ominaisuuksia ole; Tästä huolimatta joillakin ominaisuuksilla on luokan sijasta '*', mikä tarkoittaa, että tällä ominaisuudella ei ole merkitystä. Kaikki tämänkaltaiset tähdet korvataan nollilla.

de sklearn.linear_model importar LogisticRegression # Data data_path = os.path.join(os.getcwd(), 'data/shuttle-landing-control.csv') dataset = read_csv(data_path, header=None, names=['Auto', 'Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility'], na_values='*').fillna(0) # Preparar características X = dataset[['Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility']] y = dataset[['Auto']].values.reshape(1, -1)[0] model = LogisticRegression() model.fit(X, y) # Por ahora nos falta un concepto importante. No sabemos qué tan bien funciona nuestro # modelo y debido a ello, en realidad no podemos mejorar el rendimiento de nuestra hipótesis. # Hay muchas métricas útiles pero por ahora, validaremos que tan bien # Actúa nuestro algoritmo en el set de datos, en el cual aprendió. 'La puntuación de nuestro modelo es %2.2f%%' % (model.score(X, y) * 100)

Puntuación de nuestro modelo es 73.33%

Vahvistus?

Yllä olevassa esimerkissä vahvistimme mallimme suorituskyvyn oppimistietojen avulla. Onko se kuitenkin hyvä valinta, kun otetaan huomioon, että algoritmimme saattaa jättää huomiotta tiedot? Katsotaanpa yksinkertaisempi esimerkki, jossa meillä on ominaisuus, joka edustaa talon kokoa, ja toinen, joka edustaa hintaa.

de sklearn.pipeline importar make_pipeline de sklearn.preprocessing importer PolynomialFeatures de sklearn.linear_model importar LinearRegression de sklearn.model_selection importar cross_val_score # Función Verdad del terreno ground_truth = lambda X: np.cos(15 + np.pi * X) # Generar observaciones aleatorias alrededor de la función verdad del terreno n_samples = 15 degrees = [1, 4, 30] X = np.linspace(-1, 1, n_samples) y = ground_truth(X) + np.random.randn(n_samples) * 0.1 plt.figure(figsize=(14, 5)) models = {} # Trazar todos modelos del algoritmo de aprendizaje de máquina para idx, degree in enumerate(degrees): ax = plt.subplot(1, len(degrees), idx + 1) plt.setp(ax, xticks=(), yticks=()) # Definir el modelo polynomial_features = PolynomialFeatures(degree=degree) model = make_pipeline(polynomial_features, LinearRegression()) models[degree] = model # Entrenar el modelo model.fit(X[:, np.newaxis], y) # Evaluar el modelo usando validación cruzada scores = cross_val_score(model, X[:, np.newaxis], y) X_test = X plt.plot(X_test, model.predict(X_test[:, np.newaxis]), label='Model') plt.scatter(X, y, edgecolor='b', s=20, label='Observations') plt.xlabel('x') plt.ylabel('y') plt.ylim((-2, 2)) plt.title('Degree {} MSE = {:.2e}'.format( degree, -scores.mean())) plt.show()

Koneoppimisalgoritmimalli on liikaa jos et voi yleistää harjoitustietoja tai uusia havaintoja. Yllä olevassa esimerkissä käytämme yksinkertaista lineaarista hypoteesia, joka ei edusta varsinaista harjoitustietoa ja toimii hyvin huonosti. Yleensä yleistämisestä ei keskustella, koska se voidaan helposti havaita hyvillä mittauksilla.

Jos algoritmimme muistaa jokaisen havainnon, joka sille näytettiin, se ei toimi yhtä hyvin uusien havaintojen kanssa, jotka ovat harjoitteludatan ulkopuolella. Tätä kutsutaan liikaa . Esimerkiksi kolmekymmentä asteen polynomimalli läpäisee suurimman osan pisteistä ja sillä on hyvät pisteet harjoitusjoukossa, mutta kaikki muu kuin tämä toimii huonosti.

Tietojoukko koostuu yksinkertaisesta ominaisuudesta, joka voidaan piirtää 2D-muodossa; mutta tosielämässä meillä voisi olla tietojoukkoja, joissa on satoja ominaisuuksia, mikä tekee niistä mahdotonta visuaalisesti piirtää euklidista avaruutta. Mitä muita vaihtoehtoja meillä on nähdä, onko malli yleistetty vai sovitettu liikaa?

On aika esitellä sinulle käsite oppimiskäyrä . Tämä on yksinkertainen kaavio, joka piirtää neliövirheen harjoitusnäytteiden lukumäärään.

Oppimateriaaleista löydät samanlaisia ​​grafiikoita:

Mutta tosielämässä et ehkä törmää niin täydelliseen kuvaan. Piirretään jokaisen mallimme oppimiskäyrä.

from sklearn.model_selection import learning_curve, ShuffleSplit # Trazar curvas de aprendizaje plt.figure(figsize=(20, 5)) for idx, degree in enumerate(models): ax = plt.subplot(1, len(degrees), idx + 1) plt.title('Degree {}'.format(degree)) plt.grid() plt.xlabel('Training examples') plt.ylabel('Score') train_sizes = np.linspace(.6, 1.0, 6) # Validación cruzada con 100 iteraciones para obtener una prueba sencilla de *mean* y entrenamiento # curvas de puntuación cada vez con 20% de los datos seleccionados aleatoriamente como set de validación. cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0) model = models[degree] train_sizes, train_scores, test_scores = learning_curve( model, X[:, np.newaxis], y, cv=cv, train_sizes=train_sizes, n_jobs=4) train_scores_mean = np.mean(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) plt.plot(train_sizes, train_scores_mean, 'o-', color='r', label='Training score') plt.plot(train_sizes, test_scores_mean, 'o-', color='g', label='Test score') plt.legend(loc = 'best') plt.show()

Simuloidussa skenaariossa harjoittelupisteitä edustava sininen viiva näyttää suoralta. Itse asiassa se pienenee hieman - voit nähdä sen ensimmäisen asteen polynomin kaaviossa, mutta muissa se on liian hienovaraista nähdäksesi tämän resoluution. Ainakin voimme nähdä, että koulutuksen oppimiskäyrien ja 'korkean kallistuksen' skenaarion mukaisten testihavaintojen välillä on suuri ero.

Keskellä olevasta “normaalista” oppimisluokitustaulukosta näet, kuinka harjoittelun ja testin pisteet yhdistyvät.

Ja korkean varianssin kaaviosta näet, että pienellä näytemäärällä testi- ja harjoittelupisteet ovat hyvin samanlaiset, mutta kun kasvatat testien määrää, harjoittelupisteet pysyvät melkein täydellisinä niin kauan kuin testi kasvaa pois.

---

Voimme korjata yleistetyt mallit (joita kutsutaan myös malleiksi suuri kaltevuus ), jos käytämme epälineaarista hypoteesia, esimerkiksi hypoteesi, jolla on enemmän polynomiominaisuuksia.

Yli varustettu malli ( suuri vaihtelu ) jokaisesta sinulle näytetystä esimerkistä; mutta vaikka testitiedot otetaan käyttöön, oppimiskäyrien välinen ero kasvaa. Voimme käyttää laillistamista, ristivalidointia ja muita datanäytteitä korjaamaan yliasennetut mallit.

Ristivalidointi

Yksi yleisistä käytännöistä, joita käytetään yliasennuksen välttämiseen, on tallentaa osa käytettävissä olevista tiedoista ja käyttää niitä testijoukkona. Kuitenkin, kun arvioidaan mallin eri kokoonpanoja, kuten polynomiominaisuuksien lukumäärä, on edelleen olemassa riski testisarjan yliasennuksesta, koska parametreja voidaan muuttaa hieman estimaattorin optimaalisen suorituskyvyn saavuttamiseksi, ja siksi tietämyksemme testisarjassa voi vuotaa malliin. Tämän ongelman ratkaisemiseksi meidän on omistettava toinen osa tietojoukosta, jota kutsutaan 'validointijoukoksi'. Harjoittelu tapahtuu harjoitusryhmässä ja kun uskomme, että olemme saavuttaneet mallin optimaalisen suorituskyvyn, voimme tehdä arvioinnin validointijoukon avulla.

Kuitenkin, jos teemme kolme joukkoa osiota tiedoista, näytteiden määrä, jota voidaan käyttää mallien kouluttamiseen, vähenee dramaattisesti ja tulokset voivat riippua tietystä satunnaisesta valinnasta validointikoulutussarjojen parille.

Yksi ratkaisu tähän ongelmaan on menettely, jota kutsutaan ristivalidoinniksi. Tavallisessa $ k $ -kertaisessa ristivalidoinnissa tiedot jaetaan $ k $ -alaryhmiin, joita kutsutaan taitoksiksi. Tällöin algoritmi opetetaan iteratiivisesti $ k-1 $ -kertaisilla, kun taas jäljellä olevia taitoksia käytetään testijoukkona (kutsutaan “ Holdout laskokset ”)

Ristivalidointi sallii parametrien porrastamisen vain alkuperäisen harjoitusjoukon kanssa. Tämän avulla voit pitää testisarjan näkymättömänä tietojoukkona lopullisen mallin valitsemiseksi.

On olemassa monia muita ristivalidointitekniikoita, kuten jätä P pois , kerrostettu $ k $ -kertainen , sekoita ja jaa , jne. mutta nämä eivät kuulu tämän artikkelin soveltamisalaan.

Säännönmukaistaminen

Tämä on toinen tekniikka, joka voi auttaa ratkaisemaan mallin yliasennuksen ongelman. Useimmilla tietojoukoilla on kuvio ja kohinaa. Laillistamisen tavoitteena on vähentää melun vaikutusta malliin.

Normalisointitekniikoita on kolme: Lasso, Tihhonov ja venytysverkko.

L1 laillistaminen (tai Lasso-laillistaminen ) on se, joka valitsee joitain ominaisuuksia nollaksi minimoimiseksi, niin että niillä ei ole mitään tekemistä lopullisen mallin kanssa. L1 voidaan nähdä menetelmänä tärkeiden ominaisuuksien valitsemiseksi.

** L2-laillistaminen ** (tai ** Tihhonov-laillistaminen **) on se, joka vastaa pakottamisesta kaikki ominaisuuksien olevan suhteellisen pieniä, joten ne eivät vaikuta vähemmän malliin.

Joustava verkko on yhdistelmä L1: n ja L2: n arvot.

Normalisointi (skaalausominaisuus)

Skaalausominaisuus on myös tärkeä vaihe tietojen esikäsittelyn aikana. Tietojoukollamme voi olla joitain ominaisuuksia $ [- infty, infty] $ -arvoilla ja muita ominaisuuksia eri asteikoilla. Tämä on menetelmä, jonka avulla voidaan standardoida riippumattomien arvojen alueet.

Skaalausominaisuus on tärkeä prosessi oppimismallien suorituskyvyn parantamiseksi. Ensinnäkin kaltevuuslasku lähestyy paljon nopeammin, jos kaikki ominaisuudet skaalataan samaan kuvioon. Vastaavasti monet algoritmit - esimerkiksi: tukivektorikoneet (SVM) - työskentelevät laskemalla kahden pisteen välisen etäisyyden ja jos yhdellä ominaisuudesta on suuret arvot, tämä ominaisuus vaikuttaa suuresti etäisyyteen.

Tuki vektorikoneille

SVM (englanninkielisellä nimellä Tuki vektorikoneille ) on toinen suosittu koneoppimisalgoritmi, jota voidaan käyttää luokittelu- ja regressio-ongelmiin. SVM: ssä kukin havainto on piirretty pisteeksi $ n $ -ulotteiseen avaruuteen - missä $ n $ on meillä olevien ominaisuuksien määrä. Kunkin ominaisuuden arvo on tiettyjen koordinaattien arvo. Sitten yritämme löytää hypertason, joka erottaa kaksi luokkaa hyvin.

Parhaan hypertason tunnistamisen jälkeen haluamme lisätä marginaaleja, jotka auttavat edelleen erottamaan nämä kaksi luokkaa.

SVM on erittäin tehokas, kun ominaisuuksien määrä on erittäin suuri tai jos ominaisuuksien määrä on suurempi kuin datanäytteiden määrä. Vaikka SVM toimii normaalisti vektorien kanssa, on tärkeää normalisoida tiedot ennen niiden käyttöä.

Neuroverkot

Neuraaliverkkoalgoritmit ovat luultavasti mielenkiintoisin haara koneoppimisen tutkimuksissa. Neuroverkot yrittävät jäljitellä aivojen neuronien yhteyttä.

Näin hermoverkko kulkee. Yhdistämme monia solmuja, joissa kukin solmu ottaa joukon lähtöjä, tekee joitain laskelmia ja antaa sitten arvon.

Sekä valvottua että valvomatonta oppimista varten on olemassa laaja valikoima hermoverkkoalgoritmeja. Neuroverkkoja voidaan käyttää autonomisten autojen ajamiseen, videopelien, maatasojen pelaamiseen, kuvien luokitteluun ja muuhun.

Surullisen Titanic

RMS Titanic oli brittiläinen alus, joka upposi Pohjois-Atlantilla 15. huhtikuuta 1912 törmätessään jäävuoreen. Aluksella oli noin 2224 matkustajaa ja miehistöä, joista yli 1500 kuoli, mikä on yksi viime aikojen tappavimmista kaupallisista merikatastrofeista.

Nyt kun ymmärrämme ongelman luokittelussa käytetyn yhden perustavanlaatuisimman koneoppimisalgoritmin intuition, voimme soveltaa tietämystämme ennustamaan Titanicilla olevien selviytymisasteen.

Tietojoukkomme tulee Kagglen kilpailukykyä käsittelevä tiedealusta .

import os from pandas import read_csv, concat # Cargar datos data_path = os.path.join(os.getcwd(), 'data/titanic.csv') dataset = read_csv(data_path, skipinitialspace=True) dataset.head(5)

	Matkustajan tunnus	Selviytynyt	Luokka	Nimi	Sukupuoli	Ikä	SibSp	kunnioittaminen	Lippu	Tehdä	Mökki	Lähti
0	yksi	0	3	Braund, herra Owen Harris	Uros	22.0	yksi	0	A / 5 21171	7,2500	NaN	S
yksi	2	yksi	yksi	Cumings, rouva John Bradley (Florence Briggs Th ...	Nainen	38,0	yksi	0	PC 17599	71,2833	C85	C
2	3	yksi	3	Heikkinen, Miss. Laina	Nainen	26.0	0	0	STON / O2. 3101282	7,9250	NaN	S
3	4	yksi	yksi	Futrelle, rouva Jacques Heath (Lily May Peel)	Nainen	35,0	yksi	0	113803	53,1000	C123	S
4	5	0	3	Allen, herra William Henry	Uros	35,0	0	0	373450	8.0500	NaN	S

Ensimmäinen askelemme on ladata ja tutkia tietoja. Meillä on 891 testitietuetta; jokaisella tietueella on seuraava rakenne:

• passengerId - aluksella olevan matkustajan tunnus
• selviytyminen - onko henkilö selvinnyt onnettomuudesta vai ei
• pclase - Lipputyyppi, esim. 1., 2., 3.
• sukupuoli - Matkustajan sukupuoli: mies tai nainen
• nimi - Otsikko sisältyy
• ikä - ikä vuosina
• sibsp - sukulaisten / puolisoiden lukumäärä Titanicilla
• parch - Titanicilla olevien vanhempien / lasten lukumäärä
• lippu - lipun numero
• hinta - Lippujen hinta
• hytti - hytin numero
• alukseen - Laivan satama

Tämä tietojoukko sisältää sekä numeerisia että kategorisia tietoja. Yleensä on hyvä kaivaa syvemmälle omistamaasi dataa ja luoda sen perusteella oletuksia. Tässä tapauksessa ohitamme tämän vaiheen ja siirrymme suoraan ennusteisiin.

import pandas as pd # Necesitamos eliminar algunas características insignificantes y mapear el resto. # Número y costo del boleto no deberían contribuir en el rendimiento de nuestro modelo. # Característica de nombres viene con títulos (como: Sr. Srta. Doctor) incluidos. # El género es muy importante. # El Puerto de embarcación podría ser atribuir algún valor. # Usar el Puerto de embarcación podría ser contra-intuitivo pero podría # existir una tasa de supervivencia más alta para pasajeros que abordaron en el mismo Puerto. dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+).', expand=False) dataset = dataset.drop(['PassengerId', 'Ticket', 'Cabin', 'Name'], axis=1) pd.crosstab(dataset['Title'], dataset['Sex'])

Otsikko Sukupuoli	Nainen	Uros
Kapteeni	0	yksi
Kanssa	0	2
Kreivitär	yksi	0
Don	0	yksi
DR	yksi	6
Jonkheer	0	yksi
Nainen	yksi	0
Suuri	0	2
Hallita	0	40
Neiti	182	0
neiti	2	0
rouva	yksi	0
Herra	0	517
rouva	125	0
neiti	yksi	0
Rev	0	6
arvon herra	0	yksi

# Reemplazaremos muchos títulos con un nombre más común, equivalente Inglés, # o re-clasificación dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Other') dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss') dataset['Title'] = dataset['Title'].replace('Ms', 'Miss') dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs') dataset[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()

	Otsikko	Selviytynyt
0	Hallita	0,575000
yksi	Neiti	0,702703
2	Herra	0,156673
3	rouva	0,793651
4	Muu	0,3447826

# Ahora mapearemos categorias alfanumericas a números title_mapping = { 'Mr': 1, 'Miss': 2, 'Mrs': 3, 'Master': 4, 'Other': 5 } gender_mapping = { 'female': 1, 'male': 0 } port_mapping = { 'S': 0, 'C': 1, 'Q': 2 } # Mapa de título dataset['Title'] = dataset['Title'].map(title_mapping).astype(int) # Mapa de género dataset['Sex'] = dataset['Sex'].map(gender_mapping).astype(int) # Mapa de puerto freq_port = dataset.Embarked.dropna().mode()[0] dataset['Embarked'] = dataset['Embarked'].fillna(freq_port) dataset['Embarked'] = dataset['Embarked'].map(port_mapping).astype(int) # Arreglar errores de edades que falten dataset['Age'] = dataset['Age'].fillna(dataset['Age'].dropna().median()) dataset.head()

	Selviytynyt	Luokka	Sukupuoli	Ikä	SibSp	kunnioittaminen	Tehdä	Lähti	Otsikko
0	0	3	0	22.0	yksi	0	7,2500	0	yksi
yksi	yksi	yksi	yksi	38,0	yksi	0	71,2833	yksi	3
2	yksi	3	yksi	26.0	0	0	7,9250	0	2
3	yksi	yksi	yksi	35,0	yksi	0	53,1000	0	3
4	0	3	0	35,0	0	0	8.0500	0	yksi

Tässä vaiheessa luokitellaan erityyppiset koneoppimisalgoritmit Pythonissa käyttämällä scikit-learn luoda erilainen mallisto. On helppo nähdä, kumpi toimii paremmin.

• Logistinen regressio muunnelukuisten polynomien avulla
• Tukee vektorikonetta lineaarisella ytimellä
• Tukee vektorikonetta polynomilla
• Punainen hermosolu

Kussakin mallissa käytämme $ k $ -fold -vahvistusta.

de sklearn.model_selection importar KFold, train_test_split de sklearn.pipeline importar make_pipeline de sklearn.preprocessing importar PolynomialFeatures, StandardScaler de sklearn.neural_network importar MLPClassifier de sklearn.svm importar SVC # Preparar data X = dataset.drop(['Survived'], axis = 1).values y = dataset[['Survived']].values X = StandardScaler().fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = None) # Prepare cross-validation (cv) cv = KFold(n_splits = 5, random_state = None) # Rendimiento p_score = lambda model, score: print('Performance of the %s model is %0.2f%%' % (model, score * 100)) # Clasificadores names = [ 'Logistic Regression', 'Logistic Regression with Polynomial Hypotheses', 'Linear SVM', 'RBF SVM', 'Neural Net', ] classifiers = [ LogisticRegression(), make_pipeline(PolynomialFeatures(3), LogisticRegression()), SVC(kernel='linear', C=0.025), SVC(gamma=2, C=1), MLPClassifier(alpha=1), ] # iterate over classifiers models = [] trained_classifiers = [] for name, clf in zip(names, classifiers): scores = [] for train_indices, test_indices in cv.split(X): clf.fit(X[train_indices], y[train_indices].ravel()) scores.append( clf.score(X_test, y_test.ravel()) ) min_score = min(scores) max_score = max(scores) avg_score = sum(scores) / len(scores) trained_classifiers.append(clf) models.append((name, min_score, max_score, avg_score)) fin_models = pd.DataFrame(models, columns = ['Name', 'Min Score', 'Max Score', 'Mean Score']) fin_models.sort_values(['Mean Score']).head()

	Nimi	Minun tulokseni	Max Pisteet	Keskimääräinen pisteet
2	Lineaarinen SVM	0,793296	0,821229	0,803352
0	Logistinen regressio	0,826816	0,860335	0,846927
4	Neuraaliverkko	0,826816	0,860335	0,849162
yksi	Logistinen regressio polynomihypoteeseilla	0,854749	0,882682	0,869274
3	RBF SVM	0,843575	0,8888268	0,869274

No, kokeellinen tutkimus kertoo meille, että SVM-luokittelijalla on paras suorituskyky radiaalisen perustoiminnon (RBF) ytimellä. Nyt voimme sarjata mallimme ja käyttää sitä uudelleen tuotantosovelluksissa.

import pickle svm_model = trained_classifiers[3] data_path = os.path.join(os.getcwd(), 'best-titanic-model.pkl') pickle.dump(svm_model, open(data_path, 'wb'))

Koneoppiminen ei ole monimutkaista, mutta se on hyvin laaja tutkimusala, ja se vaatii tietoa matematiikasta ja tilastoista ymmärtääkseen kaikki sen käsitteet.

Tällä hetkellä koneoppiminen ja syvällinen oppiminen ovat Piilaakson halutuimpia keskusteluaiheita, pääasiassa siksi, että ne voivat automatisoida monia toistuvia tehtäviä, kuten puheen tunnistaminen, autojen ajaminen, finanssikauppa, potilashoito , kokki , markkinointi , monien muiden joukossa.

Tämän tiedon avulla voit nyt ratkaista haasteita Kagglessa.

Tämä oli lyhyt esittely valvotusta koneoppimisalgoritmista. Onneksi verkossa on paljon kursseja ja tietoa koneoppimisalgoritmeista. Henkilökohtaisesti suosittelen aloittamista Andrew Ng: n kurssilla Courseralla.

Lähteet

• Andrew Ng -kurssi Courserassa
• Kaggle-tietojoukot
• Lukemisluettelo syvällisestä oppimisesta
• Luettelo ilmaisista kirjoista koneoppimisalgoritmeista, tiedonlouhinnasta, syvällisestä oppimisesta ja siihen liittyvistä aiheista
• Johdatus koneoppimisteoriaan ja sen sovelluksiin: Visuaalinen opetusohjelma esimerkkien kera