Selle lugemise peamine eesmärk on mõista piisavalt statistilist metoodikat, et oleks võimalik ära kasutada raamatukogus olevaid masinõppe algoritme scikit-õppida Python ja seejärel rakendage neid teadmisi klassikalise masinõppe probleemi lahendamiseks.

Esimene peatus meie teekonnal viib läbi lühikese masinõppe ajaloo. Seejärel sukeldume erinevatesse algoritmidesse. Lõpp-peatuses kasutame õpitu lahendamiseks Titanicu elulemuse prognoosimise probleem .

Mõned lahtiütlused:

• Olen tarkvarainsener täis virna , mitte masinõppe algoritmide ekspert.
• Vist teate midagi põhilist Python .
• See on uuriv, nii et kõiki üksikasju ei selgitata, kuidas see oleks õpetus .

Seda öeldes alustame!

Kiire sissejuhatus masinõppe algoritmidesse

Niipea kui sellesse valdkonda julgete, saate sellest aru masinõpe see on vähem romantiline kui arvate. Esialgu oli mul täis lootusi, et pärast lisateavet saan luua oma AI Jarvise, et veedan terve päeva tarkvara kodeerimiseks ja enda jaoks raha teenimiseks, et saaksin terve päeva õues raamatuid lugeda, mootorrattaga sõita. ja hoolimatute eluviiside nautimine, samal ajal kui minu isiklik Jarvis paneb mu taskud sügavamale minema. Peagi sain aga aru, et masinõppe algoritmide aluseks on statistika, mis mulle isiklikult tundub igav ja ebahuvitav. Õnneks selgus, et 'igaval' statistikal on väga põnevaid rakendusi.

Peagi avastate, et nende põnevate rakenduste juurde pääsemiseks peate statistikat väga hästi mõistma. Masinõppe algoritmide üks eesmärke on statistiliste sõltuvuste leidmine esitatud andmetest.

Esitatud andmed võivad ulatuda vererõhu ja vanuse kontrollimisest käsitsi kirjutatud teksti leidmiseni erinevate pikslite värvi põhjal.

Seda öeldes oli mul uudishimulik, kas saaksin kasutada masinõppe algoritme sõltuvuste leidmiseks krüptograafilistest räsifunktsioonidest (SHA, MD5 jne) - te ei saa seda siiski teha, sest sobivad krüptoprimitiivid on üles ehitatud nii et need kõrvaldavad sõltuvused ja annavad tulemusi, mida on oluliselt raske ennustada. Ma arvan, et lõpmatu ajaga võivad masinõppe algoritmid murda mis tahes krüptomudeli.

Kahjuks pole meil nii palju aega, seega peame leidma uue võimaluse krüptoraha tõhusaks kaevandamiseks. Kui kaugele oleme nii kaugele jõudnud?

Masinõppe algoritmide lühilugu

Masinõppe algoritmide juured pärinevad Thomas Bayesilt, kes oli inglise statistik ja elas 18. sajandil. Tema artikkel Essee võimaluste doktriini probleemi lahendamiseks alused Bayesi teoreem , mida kasutatakse laialdaselt statistika valdkonnas.

19. sajandil avaldas Pierre-Simon Laplace Analüütiline tõenäosusteooria , laiendades Bayesi tööd ja määratledes selle, mida me täna teame, Bayesi teoreemina. Veidi enne kirjeldas Adrien-Marie Legendre meetodit „kõige väiksemad ruudud“, mida kasutatakse tänapäeval ka juhendatud õppes.

20. sajand on periood, mil selles valdkonnas on tehtud enamus avalikult tuntud avastusi. Andrei Markov mõtles välja Markovi ketid, mida ta kasutas luuletuste analüüsimiseks. Alan Turing pakkus välja õppemasinat, mis võiks saada kunstlikult intelligentseks, aimates põhimõtteliselt geneetilisi algoritme. Frank Rosenblatt leiutas Perceptron , mis tekitas suurt elevust ja suurt kajastust meedias.

Kuid siis, 1970. aastatel, oli tehisintellekti idee ümber palju pessimismi ja seetõttu ka rahastuse vähenemist, mistõttu seda perioodi nimetatakse “talveks”. 1980-ndatel aastatel taaslevinud taaselustamine põhjustas masinõppe uurimistöö taaselustamist. Ja täna on see taas üks kuum teema.

Varalahkunud Leo Breiman eristas kahte statistilise paradigma mudelit. 'Algoritmiline modelleerimine', mis tähendab enam-vähem masinõppe algoritme, mis on sarnane juhuslik mets .

Masinõpe ja statistika on seotud valdkonnad. Michael I. Jordani sõnul Masinaõppe ideed, alates metoodilistest põhimõtetest kuni teoreetiliste tööriistadeni, on statistikas olnud pikka aega. Samuti soovitas see dateerimisteadus stabiilse terminina üldisele probleemile, millega masinõppe spetsialistid ja riigimehed on töötanud.

Masinaõppimise algoritmide kategooriad

Masinõppe valdkond on rajatud kahele sambale, mida nimetatakse juhendatud õppimine Y järelevalveta õppimine . Mõned inimesed kaaluvad ka uut õppesuunda, näiteks: sügav õppimine —See on lahus juhendatava või järelevalveta õppimise levinud küsimusest.

Juhendatud õppimine tekib siis, kui arvutile esitatakse sisendite ja nende soovitud väljundite näited. Eesmärk on õppida üldvalemeid, mis kaardistavad sisendeid väljunditesse. Selle võib jagada järgmiselt:

• Pooljuhendatud õppimine , tekib siis, kui arvutile antakse mittetäielik koolitus koos puuduvate väljunditega
• Aktiivne õppimine , ilmneb siis, kui arvuti saab õppesildid hankida ainult piiratud hulga eksemplaride jaoks. Interaktiivselt kasutades saab teie treeningukomplekte kasutajale sildilisena esitada
• Tugevdusõpe , tekib siis, kui treeningandmed antakse ainult tagasisidena programmi toimingutele dünaamilises keskkonnas, näiteks sõiduki juhtimine või mängimine vastasega

Seevastu järelevalveta õppimine See juhtub siis, kui silte ei anta ja algoritmi ülesanne on ülesehitus üles leida. Järelevalveta õppimine võib olla eesmärk omaette, kui peame lihtsalt avastama varjatud mustrid.

Sügav õppimine See on uus uurimisvaldkond, mis on inspireeritud inimese aju struktuurist ja funktsioonist, samamoodi põhineb see statistiliste mõistete asemel kunstlikel närvivõrkudel. Sügavat õppimist saab kasutada nii järelevalve all kui järelevalves.

Selles artiklis vaatleme mõningaid lihtsamaid juhendatud masinõppe algoritme ja arvutame nende abil üksikisiku ellujäämise koefitsiendid titaaniku traagilises uppumises. Kuid üldiselt, kui te pole kindel, millist algoritmi kasutada, on hea koht alustamiseks Masinaõppimise algoritmi ülevaateleht scikit-õppida .

Juhendatud masinõppe põhimudelid

Võib-olla on lihtsaim algoritm lineaarne regressioon. Mõnikord võib seda graafiliselt kujutada sirgjoonena, kuid vaatamata selle nimele võib polünoomhüpoteesi olemasolu korral see joon olla kõver. Mõlemal juhul modelleerib skalaarist sõltuva muutuja $ ja $ seosed ühe või mitme selgitava väärtusega, mida tähistatakse tähega $ x $.

Võhises mõttes tähendab see, et lineaarne regressioon on algoritm, mis õpib sõltuvust juba teadaolevate $ x $ ja $ y $ vahel nii palju, et saaksime seda kasutada $ y $ ennustamiseks tundmatule valimile $ x $.

millist animatsioonitehnoloogiat saavad veebikasutajad vaadata ilma brauseri pistikprogrammita?

Oma esimeses juhendatud õppenäites kasutame inimese vererõhu ennustamiseks tema vanuse põhjal põhilist lineaarse regressiooni mudelit. Idas See on väga lihtne andmekogum, millel on kaks olulist omadust: vanus ja vererõhk.

Nagu eespool mainitud, töötavad enamik masinõppe algoritme statistilise sõltuvuse andmetest, mis neile antakse. Seda sõltuvust nimetatakse a hüpotees ja seda tähistatakse tavaliselt tähega $ h ( theta) $.

visuaalse taju geštalt-seadused

Selle hüpoteesi dešifreerimiseks alustame andmete allalaadimisest ja uurimisest.

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

[]

Ülaltoodud graafikul tähistab iga sinine punkt meie näidisandmeid ja sinine joon on hüpotees, mille meie algoritm peab õppima. Mis see hüpotees siis on?

Selle probleemi lahendamiseks peame õppima sõltuvust $ x $ ja $ y $ vahel, mida tähistatakse tähtedega $ y = f (x) $. Seega on $ f (x) $ ideaalne eesmärkfunktsioon. Masinaõppimise algoritm püüab ära arvata hüpoteesifunktsiooni $ h (x) $, mis on tundmatu $ f (x) $ lähim lähendus.

Lineaarse regressiooni ülesande hüpoteesi lihtsaim vorm näeb välja selline: $ h_ theta (x) = theta_0 + theta_1 * x $. Meil on lihtne sisendmuutuja $ x $, mis väljastab lihtsa skalaarmuutuja $ y $, kus $ theta_0 $ ja $ theta_1 $ on parameetrid, mida peame õppima. Selle sinise joone andmete sisestamise protsessi nimetatakse lineaarseks regressiooniks. Oluline on mõista, et meil on ainult üks sisendparameeter $ x_1 $; paljud hüpoteesifunktsioonid hõlmavad aga ka kaldega üksust ($ x_0 $). Seega on meie saadud hüpoteesi kuju $ h_ theta (x) = theta_0 * x_0 + theta_1 * x_1 $. Kuid me võime vältida $ x_0 $ kirjutamist, sest see on peaaegu alati võrdne 1-ga.

Tagasi sinise joone juurde. Meie hüpotees näeb välja selline: $ h (x) = 84 + 1,24x $, mis tähendab, et $ theta_0 = 84 $ ja $ theta_1 = 1,24 $. Kuidas saame need $ theta $ väärtused automaatselt tuletada?

Peame määratlema a kulude funktsioon . Põhimõtteliselt teeb kulufunktsioon prognoosimudeli ja väljundi vahelise ruutnurga vea arvutamise.

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

Näiteks ennustab meie hüpotees, et 48-aastase inimese vererõhk peaks olema $ h (48) = 84 + 1,24 * 48 = 143mmHg $; aga meie koolitusvalimis on väärtuseks $ 130 mmHg $. Seetõttu on viga $ (143 - 130) ^ 2 = $ 169. Nüüd peame selle vea arvutama iga treeningandmete kogumi sisendi kohta ja seejärel kõik kokku lisama ($ sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i )}) ^ 2 $) ja võtke sealt oluline väärtus. See annab meile ühe skalaararvu, mis tähistab funktsiooni maksumust. Meie eesmärk on leida väärtused $ theta $, nii et kulufunktsioon oleks madalam; teisisõnu soovime minimeerida kulude funktsiooni. Loodetavasti on see intuitiivne: kui meil on väike kulufunktsiooni väärtus, tähendab see, et ka ennustusviga oleks madal.

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

Nüüd peame leidma $ theta $ väärtused nii palju, et meie väärtus kulude funktsioon on minimaalne. Aga kuidas me saaksime seda teha?

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

Võimalikke algoritme on palju, kuid kõige populaarsem on allakäik . Gradientse laskumismeetodi taga oleva intuitsiooni mõistmiseks paneme selle kõigepealt graafikule. Lihtsuse huvides eeldame lihtsamat hüpoteesi $ h ( theta) = theta_1 * x $. Siis on meil lihtne 2D graafik, kus $ x $ on $ theta $ väärtus ja $ y $ on kulude funktsioon selles punktis.

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

Kulufunktsioon on kumer, mis tähendab, et intervallis $ [a, b] $ on ainult üks miinimum. Mis tähendab, et parimad parameetrid $ theta $ on selles punktis, kus kulufunktsioon on kõige madalam.

Põhimõtteliselt on gradientne laskumine algoritm, mis püüab leida funktsiooni minimeerivate parameetrite komplekti. See algab algsest parameetrite komplektist ja astub interaktiivselt gradientfunktsiooni negatiivse suuna suunas.

Kui arvutame hüpoteesifunktsiooni tuletise konkreetses punktis, annab see meile otsese juurdepääsu kõvera puutujale selles punktis. See tähendab, et saame otsetee arvutada graafiku igas punktis.

Algoritmi tööviis on järgmine:

1. Lähtepunkti valime juhuslikult ($ theta $ juhuslikult).
2. Leidke selles punktis kulude funktsiooni tuletis.
3. Tehke väike samm otsetee $ theta_j suunas: = theta_j - lambda * frac { osaline} { osaline teeta_j} * J ( teeta) $.
4. Korrake samme 2-3 kuni lähenemiseni.

Nüüd sõltub lähenemistingimus algoritmi rakendamisest. Võib-olla peatume pärast 50 sammu, pärast mõnda lumbaarset või midagi muud.

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

Me ei rakenda neid algoritme selles artiklis. Selle asemel kasutame juba vastuvõetud Pythoni avatud lähtekoodiga masinõppekogu scikit-learn See pakub palju kasulikke API-sid erinevate andmekaevandus- ja masinõppeprobleemide jaoks.

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

kui suur on veinitööstus

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]]

Statistiliste andmete tüübid

Masinõppeprobleemidega töötamisel on oluline teada, kuidas eri tüüpi andmeid ära tunda. See võib olla arvuline (pidev või diskreetne), kategooriline või järjekorranumber.

Numbrilised andmed neil on tähendus kui mõõt. Näiteks: inimese vanus, kaal, bitcoinide arv või mitu artiklit inimene kuus kirjutada saab. Numbrilised andmed võivad olla ka diskreetsed või pidevad.

• Diskreetsed andmed tähistavad andmeid, mida saab lugeda täisarvudega, näiteks korteri tubade arv või mündi pööramise aeg.
• Pidevaid andmeid ei esitata tingimata täisarvudega. Näiteks kui mõõdate kaugust, mida saate hüpata, võib see olla 2 meetrit või 1,5 meetrit või võib-olla 1,652245.

Kategoorilised andmed need esindavad selliseid väärtusi nagu inimese sugu, perekonnaseis, riik jne. Need andmed võivad olla arvväärtusega, kuid nendel numbritel poleks matemaatilist väärtust. Te ei saa neid lisada.

Järjestusandmed see võib olla segu teistest tüüpidest, kus kategooriaid saaks matemaatiliselt tähenduslikult nummerdada. Levinud näide on hinnangud: sageli palutakse meil asju hinnata skaalal üks kuni kümme ja sellistel juhtudel on lubatud ainult täisarvud. Ehkki saame neid andmeid kasutada arvuliselt (näiteks millegi keskmise auastme leidmiseks), käsitleme neid andmeid masinõppemeetodite rakendamisel sageli kategoorilistena.

Logistiline taandareng

Lineaarne regressioon on uskumatu algoritm, mis aitab meil ennustada arvulisi väärtusi, näiteks kindla suurusega maja hinda ja teatud ruume. Mõnikord võiksime siiski ennustada kategoorilisi andmeid, et saada vastuseid järgmistele küsimustele:

• Kas koer või kass?
• Kas see kasvaja on pahaloomuline või healoomuline?
• Kas see vein on hea või halb?
• Kas see meil on rämpspost või mitte?

Või isegi:

• Mis number on sellel fotol?
• Mis kategooriasse see meil kuulub?

Kõik need küsimused on konkreetsed klassifitseerimisprobleem . Ja nimetatakse kõige lihtsamat klassifikatsiooni algoritmi Logistiline taandareng , mis on lõpuks võrdne regressiooniga lineaarne Välja arvatud teil on teistsugune hüpotees.

Kõigepealt võime kasutada sama lineaarset hüpoteesi $ h_ theta (x) = theta ^ T X $ (see on vektoriseeritud kujul). Kui lineaarne regressioon võib väljuda mis tahes arvuna intervallides $ [a, b] $, siis logistiline regressioon saab väärtusi ainult $ [- 1, 1] $ väärtuses, mis viitab tõenäosusele, et objekt kuulub kategooriasse või mitte.

Kui kasutame a sigmoidfunktsioon , saame teisendada mis tahes arvväärtuse, et see esindaks väärtust vahemikus $ [- 1, 1] $.

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

Nüüd peaksime $ x $ asemel edastama olemasoleva hüpoteesi ja saame:

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

Pärast seda võime rakendada lihtsat künnist, mis ütleb, et kui hüpotees on suurem kui null, on see tõene väärtus, vastasel juhul on see vale.

[h_ theta (x) = algab {juhtudel} 1 & mbox {if} theta ^ T X> 0 \ 0 & mbox {else} end {juhtudel} ]

See tähendab, et saame kasutada sama kulude funktsioon ja sama langeva gradiendi algoritm logistilise regressiooni hüpoteesi õppimiseks.

Järgmises masinõppe näites anname kosmosesüstiku pilootidele nõu, kas nad peaksid maandumist käsitsi või automaatselt kontrollima. Meil on väga väike andmekogum —15 proovi - mis koosnevad kuuest tunnusest ja põhiline tõde .

Masinaõppimise algoritmides on mõiste põhiline tõde ”Viitab juhendatud õppetehnika tehnikakomplektide liigituse täpsusele.

Meie andmekogum on täielik, mis tähendab, et puuduvad funktsioonid; vaatamata sellele on mõnel funktsioonil kategooria asemel täht '*', mis tähendab, et see funktsioon pole oluline. Kõik sellised tärnid asendatakse nullidega.

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%

Valideerimine?

Ülaltoodud näites kinnitasime oma mudeli jõudlust õppeandmete abil. Kas see on siiski hea valik, kui arvestada, et meie algoritm võib andmeid mitte arvestada? Vaatame lihtsamat näidet, kus meil on omadus, mis tähistab maja suurust, ja teine, mis tähistab hinda.

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

Masinaõppimise algoritmi mudel on üleüldine kui te ei saa üldistada ei treeningu andmeid ega uusi tähelepanekuid. Ülaltoodud näites kasutame lihtsat lineaarset hüpoteesi, mis ei esinda tegelikke treeningandmeid ja töötab väga halvasti. Tavaliselt ei arutata üleüldistamist, sest seda saab heade mõõtmistega hõlpsasti tuvastada.

Kui meie algoritm mäletab kõiki vaatlusi, mida talle näidati, on see vähem efektiivne uute vaatlustega, mis jäävad väljapoole koolituse andmekogumit. Seda nimetatakse üleliigne . Näiteks kolmekümnenda astme polünoomimudel läbib suurema osa punktidest ja sellel on treeningkomplektis hea tulemus, kuid kõik muu kui see töötab halvasti.

Meie andmekogum koosneb lihtsast funktsioonist, mille saab joonistada 2D-s; kuid tegelikus elus võiks meil olla sadade funktsioonidega andmekogumeid, mis muudab nende Eukleidese ruumis visuaalse koostamise võimatuks. Milliseid muid valikuid peame nägema, kas mudel on üleüldine või üle paigaldatud?

On aeg tutvustada teile seda kontseptsiooni õppimiskõver . See on lihtne graafik, mis joonistab treeningproovide arvu ruutvea.

Õppematerjalidest leiate sarnaseid graafikaid:

Kuid tegelikus elus ei pruugi te nii täiusliku pildiga kokku puutuda. Koostame iga mudeli õppekõvera.

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

Meie simuleeritud stsenaariumi korral näeb treeningskoori tähistav sinine joon välja nagu sirge. Tegelikult väheneb see veidi - näete seda esimese astme polünoomi graafikul, kuid teistes on selle eraldusvõime nägemiseks liiga peen. Vähemalt näeme, et koolituse õppimiskõverate ja 'kõrge kallutuse' stsenaariumi testivaatluste vahel on suur erinevus.

Keskel olevas “tavalises” õppimise klassifikatsioonigraafikus on näha, kuidas koolituse ja testi skoori read kokku saavad.

Ja „suure dispersiooniga“ graafikul näete, et väikese proovide arvu korral on testide ja treeningute tulemused väga sarnased, kuid testide arvu suurendades jääb treeningu tulemus peaaegu täiuslikuks seni, kuni test kasvab ära.

---

Saame parandada üleüldiseid mudeleid (neid nimetatakse ka mudeliteks suur kalle ) kui kasutada näiteks mittelineaarset hüpoteesi, siis polünoomiomadustega hüpoteesi.

Meie ülimugav mudel ( suur variatsioon ) iga teile näidatud näite kohta; kuid isegi nii, kui testiandmeid sisestatakse, suureneb õppekõverate vahe. Üle paigaldatud mudelite parandamiseks saame kasutada seadistamist, ristvalideerimist ja muid andmeproove.

Ristvalideerimine

Üks levinumaid tavasid üleliigse paigaldamise vältimiseks on salvestada osa olemasolevatest andmetest ja kasutada neid testikomplektina. Kuid kui hinnatakse mudeli erinevaid konfiguratsioone, näiteks polünoomiomaduste arvu, on siiski oht testikomplekti üle sobitada, kuna parameetreid saab hindaja optimaalse jõudluse saavutamiseks veidi muuta ja seetõttu on meie teadmised testikomplekt võib mudelisse lekkida. Selle probleemi lahendamiseks peame omistama andmekogumi teise osa, mida nimetatakse 'valideerimiskomplektiks'. Koolitus toimub treeningkomplektis ja kui usume, et oleme saavutanud mudeli optimaalse jõudluse, saame hindamise teha valideerimiskomplekti abil.

Kui aga koostame kolm andmepartitsioonide komplekti, väheneb dramaatiliselt proovide arv, mida saab mudelite treenimiseks kasutada ja tulemused võivad sõltuda valideerimise-koolituskomplektide paari konkreetsest juhuslikust valikust.

Selle probleemi üks lahendus on protseduur, mida nimetatakse ristkinnitamiseks. Standardses ristkinnituses $ k $ -fold jagatakse andmed $ k $ alamhulkadeks, mida nimetatakse voldideks. Seejärel koolitatakse algoritm iteratiivselt kordadega $ k-1 $, kasutades ülejäänud komplekte testhulkadena (nn väljapandud voldid ”)

Ristvalideerimine võimaldab parameetrite gradueerimist ainult algse treeningkomplektiga. See võimaldab teil oma testimiskomplekti säilitada lõpliku mudeli valimiseks nähtamatu andmekogumina.

On ka palju muid ristkinnitamise tehnikaid nagu jäta P välja , kihiline $ k $ -kordne , segada ja jagada , jne. kuid need jäävad selle artikli reguleerimisalast välja.

Reguleerimine

See on veel üks tehnika, mis aitab teil lahendada mudeli üleliigse paigaldamise probleemi. Enamikul andmekogumitel on muster ja müra. Reguleerimise eesmärk on vähendada müra mõju mudelile.

On kolm peamist seadustamistehnikat: Lasso, Tihhonov ja veniv võrk.

mida rööbastel tähendab

L1 seadustamine (või Lasso seadustamine ) on see, mis valib nulli minimeerimiseks mõned omadused, nii et neil pole lõpliku mudeliga midagi pistmist. L1 võib vaadelda kui meetodit oluliste omaduste valimiseks.

** L2 seadustamine ** (või ** Tihhonovi seadustamine **) on see, mis vastutab sundimise eest kõik omadused on suhteliselt väikesed, nii et need mõjutavad mudelit vähem.

Veniv võrk on kombinatsioon L1 ja L2.

Normaliseerimine (skaleerimise karakteristik)

Ka skaleerimise funktsioon on oluline samm andmete eeltöötluse ajal. Meie andmekogumil võib olla mõningaid omadusi $ [- infty, infty] $ väärtustega ja muid erineva skaalaga omadusi. See on meetod, mis võimaldab standardiseerida sõltumatute väärtuste vahemikke.

Skaleerimise funktsioon on oluline protsess õppemudelite jõudluse parandamiseks. Kõigepealt läheneb gradientne laskumine palju kiiremini, kui kõik funktsioonid on skaleeritud sama mustriga. Samamoodi töötavad paljud algoritmid - näiteks: tugivektorimasinad (SVM) - arvutades kahe punkti vahelise kauguse ja kui ühel omadusel on suured väärtused, mõjutab see funktsioon kaugust suuresti.

Toetage vektormasinaid

SVM (ingliskeelse nimega Toetage vektormasinaid ) on veel üks populaarne masinõppe algoritm, mida saab kasutada klassifitseerimise ja regressiooni probleemide jaoks. SVM-is on iga vaatlus joonistatud punktina $ n $ -dimensiooniruumis - kus $ n $ on meie funktsioonide arv. Iga tunnuse väärtus on teatud koordinaatide väärtus. Seejärel proovime leida hüperlennuki, mis eraldaks kahte klassi väga hästi.

Pärast parima hüpertasandi kindlakstegemist soovime lisada veerised, mis aitaksid neid kahte klassi veelgi eraldada.

SVM on väga tõhus, kui funktsioonide arv on väga suur või kui funktsioonide arv on suurem kui andmeproovide arv. Ehkki kuna SVM töötab tavaliselt vektoritega, on andmete normaliseerimine enne nende kasutamist ülioluline.

Närvivõrgud

Närvivõrgu algoritmid on ilmselt masinõppe kõige põnevam haru. Närvivõrgud üritavad jäljendada aju neuronite ühendust.

Nii läheb närvivõrk. Ühendame palju sõlme, kus iga sõlm võtab väljundite komplekti, teeb mõned arvutused ja väljastab seejärel väärtuse.

Nii juhendatava kui ka järelevalveta õppimise jaoks on palju erinevaid närvivõrgu algoritme. Närvivõrke saab kasutada autonoomsete autode juhtimiseks, videomängude, maalennukite mängimiseks, piltide klassifitseerimiseks ja muuks.

sissejuhatus väledasse projektijuhtimisse

Kurikuulus Titanic

RMS Titanic oli Suurbritannia laev, mis uppus Atlandi ookeani põhjaosas 15. aprillil 1912 pärast kokkupõrget jäämäega. Pardal oli umbes 2224 reisijat ja meeskonda, kellest enam kui 1500 hukkus, mistõttu on see viimase aja üks ohvriterohkematest kaubanduslikest katastroofidest.

Nüüd, kui oleme aru saanud probleemide klassifitseerimisel kasutatava ühe kõige põhilisema masinõppe algoritmi intuitsioonist, saame oma teadmisi rakendada Titanicu pardal viibijate ellujäämise prognoosimiseks.

Meie andmekogum pärineb Kaggle'i konkurentsivõime teaduse andmeplatvorm .

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)

	Reisija ID	Ellu jäänud	Klass	Nimi	Seks	Vanus	SibSp	austust	Pilet	Tegema	Kajut	Alustas
0	üks	0	3	Braund, hr Owen Harris	mees	22,0	üks	0	A / 5 21171	7,2500	NaN	S
üks	2	üks	üks	Cumings, proua John Bradley (Florence Briggs Th ...	emane	38,0	üks	0	PC 17599	71.2833	C85	C
2	3	üks	3	Heikkinen, preili. Laen	emane	26,0	0	0	KIVI / O2. 3101282	7,9250	NaN	S
3	4	üks	üks	Futrelle, proua Jacques Heath (Lily May Peel)	emane	35,0	üks	0	113803	53,1000	C123	S
4	5	0	3	Allen, hr William Henry	mees	35,0	0	0	373450	8.0500	NaN	S

Meie esimene samm on andmete laadimine ja uurimine. Testide arvestust on meil 891; igal kirjel on järgmine struktuur:

• passengerId - pardal oleva reisija ID
• ellujäämine - kas inimene elas õnnetuse üle või mitte
• pclase - pileti tüüp, nt 1., 2., 3.
• sugu - reisija sugu: mees või naine
• nimi - pealkiri on lisatud
• vanus - vanus aastates
• sibsp - Titanicu pardal olevate sugulaste / abikaasade arv
• parch - Titanicu pardal olevate vanemate / laste arv
• pilet - pileti number
• hind - piletihind
• salong - salongi number
• pardale - laevaport

See andmekogum sisaldab nii arvulist kui ka kategoorilist teavet. Tavaliselt on hea mõte olemasolevatesse andmetesse süveneda ja sellest lähtuvalt oletusi luua. Kuid sel juhul jätame selle sammu vahele ja läheme otse ennustuste juurde.

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'])

Pealkiri Sugu	emane	mees
Kapten	0	üks
Koos	0	2
Krahvinna	üks	0
Don	0	üks
dr	üks	6
Jonkheer	0	üks
Proua	üks	0
Major	0	2
Meister	0	40
Igatsema	182	0
Prl	2	0
proua	üks	0
härra	0	517
proua	125	0
Prl	üks	0
Rev	0	6
Härra	0	üks

# 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()

	Pealkiri	Ellu jäänud
0	Meister	0,575000
üks	Igatsema	0,702703
2	härra	0,1556673
3	proua	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()

	Ellu jäänud	Klass	Seks	Vanus	SibSp	austust	Tegema	Alustas	Pealkiri
0	0	3	0	22,0	üks	0	7,2500	0	üks
üks	üks	üks	üks	38,0	üks	0	71.2833	üks	3
2	üks	3	üks	26,0	0	0	7,9250	0	2
3	üks	üks	üks	35,0	üks	0	53,1000	0	3
4	0	3	0	35,0	0	0	8.0500	0	üks

Siinkohal liigitame Pythonis erinevat tüüpi masinõppe algoritme, kasutades scikit-learn erineva mudelikomplekti loomiseks. On lihtne mõista, kumb neist paremini toimib.

• Logistiline regressioon variandide arvu polünoomidega
• Toetage lineaarse tuumaga vektormasinat
• Toetage vektormasinat polünoomi tuumaga
• Punane neuronaalne

Iga mudeli puhul kasutame valideerimist $ k $ -fold.

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	Minu skoor	Max Score	Keskmine skoor
2	Lineaarne SVM	0,793296	0,821229	0,803352
0	Logistiline regressioon	0,826816	0,860335	0,846927
4	Neuraalvõrk	0,826816	0,860335	0,849162
üks	Logistiline regressioon polünoomhüpoteesidega	0,854749	0,882682	0.869274
3	RBF SVM	0,843575	0,8888268	0.869274

Noh, meie eksperimentaalsed uuringud ütlevad meile, et SVM-i klassifikaatoril on radiaalse põhifunktsiooni (RBF) kerneliga parim jõudlus. Nüüd saame oma mudeli järjestada ja taaskasutada tootmisrakendustes.

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

Masinõpe pole keeruline, kuid see on väga lai õppevaldkond ning kõigi selle mõistete mõistmiseks on vaja teadmisi matemaatika ja statistika valdkonnas.

Praegu kuuluvad masinõpe ja süvaõpe Silicon Valley nõutavate aruteluteemade hulka peamiselt seetõttu, et need võivad automatiseerida paljusid korduvaid ülesandeid nagu kõnetuvastus, autode juhtimine, finantstehingud, patsiendi hooldus , Kokk , turundus paljude teiste seas.

Nüüd saate nende teadmistega Kaggle'is väljakutseid lahendada.

See oli lühike sissejuhatus juhendatava masinõppe algoritmi. Õnneks on palju veebikursusi ja teavet masinõppe algoritmide kohta. Ise soovitan alustada Andrew Ng Coursera kursusest.

Allikad

• Andrew Ng kursus Courseras
• Kaggle andmekogumid
• Lugemisloend süvendatud õppimise kohta
• Masinõppe algoritmide, andmekaevanduse, süvaõppe ja sellega seotud teemade kohta tasuta raamatute loend
• Sissejuhatus masinõppe teooriasse ja selle rakendustesse: visuaalne õpetus koos näidetega