Neuraaliverkko Tensorflow-luokitukseen

Tämä artikkeli julkaistiin osana Data Science Blogathon

Tässä artikkelissa aion rakentaa neuroverkkomalleja TensorFlow'lla luokitusongelman ratkaisemiseksi. Tutkitaan yhdessä, kuinka voimme lähestyä luokitusongelmaa Tensorflowssa. Mutta ensinnäkin haluaisin varmistaa, että pystymme vastaamaan näihin kysymyksiin:

onko hermoverkko?

Hermoverkon päätarkoitus on yrittää löytää suhde tietojoukon ominaisuuksien välillä., ja se koostuu joukosta algoritmeja, jotka jäljittelevät ihmisen aivojen toimintaa. "Neuroni" hermoverkossa on matemaattinen funktio, joka kerää ja luokittelee tietoa tietyn arkkitehtuurin mukaan.

Mikä on luokittelu?

Luokitteluongelma sisältää ennustamisen, kuuluuko jokin johonkin luokkaan vai ei. Toisin sanoen sitä tehdessämme yritämme nähdä, että jokin on yhtä tai toista.

Luokittelutyypit

• Oletetaan, että haluat ennustaa, onko henkilöllä diabetes vai ei. Jos kohtaat tällaisen tilanteen, on kaksi mahdollisuutta, eikö? Sitä kutsutaan Binääriluokitus.
• Oletetaan, että haluat tunnistaa, onko valokuva lelusta, ihmisestä vai kissasta, eikö niin? tätä kutsutaan Moniluokkainen luokitus koska vaihtoehtoja on enemmän kuin kaksi.
• Oletetaan, että haluat päättää, mitkä luokat artikkelille määritetään. Jos on, sitä kutsutaan Multi-label-luokitus, koska yhdelle artikkelille voi olla määritetty useampi kuin yksi luokka. Käydään selitys läpi tämän artikkelin. Voimme määrittää tälle artikkelille luokkia, kuten "Syvä oppiminen, TensorFlow, Luokittelu" jne

Nyt voimme siirtyä eteenpäin, koska meillä on yhteinen käsitys ongelmasta, jonka parissa työskentelemme. Joten on koodauksen aika. Toivon, että kirjoitat ne muistiin kanssani, koska ainoa tapa parantaa ja tehdä vähemmän virheitä on kirjoittaa enemmän koodia.

Aloitamme tuomalla kirjastoja, joita tulemme käyttämään:

tuonti numpy muodossa np tuo pandat pd:nä tuonti matplotlib.pyplot as plt tuonti tensorflow tf print(tf.__version__)

Tietojoukon luominen

On aika luoda tietojoukko työstettäväksi:

kohteesta sklearn.datasets tuo make_circles samples = 1000 X, y = make_circles(näytteet, kohina = 0.03, satunnainen_tila = 42)

Tulosta (X >> [0.75424625] [-0.23148074 0.75615888] ... [-0.15325888 -0.81539193] [0.17328203 -0.13690036] [0.81001183 0.67036156]]

tulosta(y) >> [1 1 1 1 0 1 1 1 1 0]

Okei, olemme nähneet tietojoukkomme tarkemmin, mutta emme silti tiedä siitä mitään, eikö niin? Tästä syystä tässä yksi tärkeä askel on yhtyä tietojen kanssa, ja visualisointi on paras tapa tehdä tämä.

circle = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'tunniste' : y}) circle.head()

Tässä herää yksi kysymys, minkä tyyppisten tarrojen kanssa olemme tekemisissä?

circle.label.value_counts() >> 1 500 0 500 Nimi: otsikko, dtype: int64

Näyttää siltä, ​​että olemme tekemisissä binääriluokitusongelma, koska meillä on 2 tunnistetta (0 ja 1).

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Kuten edellä mainitsin, paras tapa saada yksi tiedoista on visualisointi. Nyt juoni sanoo itse, että millainen malli meidän pitää rakentaa. Rakennamme mallin, joka pystyy erottamaan siniset pisteet punaisista.

Ennen kuin rakennamme minkä tahansa hermoverkkomallin, meidän on tarkistettava tulo- ja lähtöominaisuuksiemme muodot. niiden täytyy olla samat!

tulosta(X.muoto, y.muoto) tulosta(lin(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Meillä on sama määrä arvoja jokaiselle ominaisuudelle, mutta X:n muoto on erilainen? Miksi? Katsotaanpa se.

X[0], y[0] >> (taulukko([0.75424625, 0.23148074]), 1)

Okei, meillä on 2 X -ominaisuutta yhden vuoden ajan. Joten voimme mennä eteenpäin ilman ongelmia.

Vaiheet neuroverkon mallintamiseen Tensorflow-luokituksen avulla

TensorFlow'ssa mallin luomiseen on kiinteät vaiheet:

• Mallin luominen – yhdistä hermoverkon kerrokset funktionaalisen tai peräkkäisen API:n avulla
• Mallin kokoaminen – määritetään, kuinka mallin suorituskykyä tulisi mitata ja miten sen pitäisi parantaa (häviötoiminto ja optimointi)
• Tilan sovittaminenl – mallin antaminen löytää kuvioita tiedoista

Käytämme peräkkäistä sovellusliittymää. Joten aloitetaan

tf.random.set_seed(42)

malli_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optimoija = tf.keras.optimizers.SGD(), #SGD on lyhenne sanoista Stochastic Gradient Descent metrics = ['tarkkuus']) model_1.fit(X, y, epochs = 5)

>> Epoch 1 [===============================] - 5 s 32 ms/askel - häviö: 32 - tarkkuus: 1 Epoch 1/2.8544 0.4600/2 [===============================] - 5 s 32ms/askel - häviö : 32 - tarkkuus: 0 Epoch 2/0.7131 0.5430/3 [==============================] - 5 s 32 ms/askel - häviö: 32 - tarkkuus: 0 Epoch 2/0.6973 0.5090/4 [==============================] - 5s 32ms /askel - häviö: 32 - tarkkuus: 0 Epoch 2/0.6950 0.5010/5 [===============================] - 5s 32ms/askel - häviö: 32 - tarkkuus: 0

Mallin tarkkuus on noin 50 %, mikä tarkoittaa käytännössä sitä, että malli vain arvailee, yritetään harjoitella sitä pidempään

model_1.fit(X, y, epochs = 200, verbose = 0) #me asetamme verbose = 0 poistaaksesi koulutusmenettelyn ) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/askel - häviö: 0.6935 - tarkkuus: 0.5000 [0.6934829950332642, 0.5]

Jopa 200 aikakauden jälkeen se toimii edelleen kuin arvelee. Seuraava askel on lisätä tasoja ja harjoitella pidempään.

tf.random.set_seed(42)

malli_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimoija = tf.keras.optimizers.SGD(), metrics = ['tarkkuus']) model_2.fit(X, y, epochs = 100, verbose = 0)

 malli_2.evaluate(X,y)

>> 32/32 [==============================] - 0s 1ms/askel - häviö: 0.6933 - tarkkuus: 0.5000 [0.6933314800262451, 0.5]

Siltikään ei ole tapahtunut edes pientä muutosta, näyttää siltä, ​​​​että jotain on vialla.

Neuraaliverkon luokittelumallin parantaminen Tensorflow:lla

On olemassa erilaisia ​​tapoja parantaa mallia eri vaiheissa:

• Mallin luominen - lisää kerroksia, lisää piilotettujen yksiköiden (neuronien) määrää, muuta jokaisen kerroksen aktivointitoimintoja
• Mallin kokoaminen - kokeile erilaisia ​​optimointifunktioita, esimerkiksi käytä Adam() SGD() sijaan.
• Mallin sovittaminen - voisimme lisätä aikakausien määrää

Yritetään lisää neuroneja ja yritä Aatami Optimizer

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # add 100 tiheä neuronia tf.keras.layers.Dense(10), # lisää toinen kerros, jossa on 10 neuronia tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimoija=tf.keras.optimizers.Adam(), metrics=['tarkkuus']) model_3.fit(X, y, epochs =100, monisanainen = 0)

malli_3.evaluate(X,y) >> 32/32 [===============================] - 0 s 1 ms/askel - häviö: 0.6980 - tarkkuus: 0.5080 [0.6980254650115967, 0.5080000162124634]

Ei vieläkään parane! Visualisoidaan tiedot nähdäksemme, mikä on vialla.

Visualisoi hermoverkkomalli

Mallimme ennusteiden visualisoimiseksi luomme funktion plot_decision_boundary(), joka:

• Sisältää koulutetun mallin, ominaisuudet ja tarrat
• Luo eri X-arvoista meshgrid.
• Tekee ennusteita koko meshgridissä.
• Piirtää ennusteet viivalla.

Huomautus:  Tämä toiminto on mukautettu kahdesta lähteestä:

CS231n Valmistettu ML:n perusteista 

def plot_decision_boundary(malli, X, y): # Määritä kaavion akselirajat ja luo meshgrid x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Luo X-arvot (ennustamme kaikki nämä) x_in = np.c_[xx.ravel(), yy.ravel()] # Tee ennusteita käyttämällä koulutettuja malli y_pred = model.predict(x_in) # Tarkista moniluokkaisuus

 if len(y_pred[0]) > 1: print("tekee moniluokkaista luokittelua...") # Meidän on muotoiltava ennusteemme uudelleen saadaksemme ne valmiiksi piirtämistä varten y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("binääriluokittelu...") y_pred = np.round(y_pred).reshape(xx.shape) # Piirrä päätösraja plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alfa=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(malli_3, X, y)

Tässä se on! Jälleen visualisointi näyttää, mikä on vialla ja mitä tehdä? Mallimme yrittää piirtää suoran viivan datan läpi, mutta dataamme ei voida erottaa suoralla viivalla. Puuttuuko jokin luokitusongelmastamme? Mikä se on?

Tämä on epälineaarisuutta! Tarvitsemme joitain epälineaarisia viivoja. Saatat nyt hämmentyä, jos ajattelet, ettet nähnyt tällaista toimintoa aiemmin, olet väärässä, koska olet. Katsotaanpa niitä visuaalisesti. Visualisointi toimii aina paremmin!

Neural Networkissa on joitain aktivointitoimintoja, joita voimme käyttää, kuten ReLu, sigmoid. Luodaan vähän lelutensori ja tarkista ne toiminnot siinä.

Neuraaliverkkojen aktivointitoiminnot

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], muoto=(24,), dtype=float32)

Katsotaanpa, miltä lelutensorimme näyttää?

plt.plot(A)

Se näyttää tältä, suora viiva! 

Luodaan nyt aktivointifunktiot uudelleen nähdäksemme, mitä ne tekevät tensorillemme?

Sigmoidi:

def sigmoid(x): return 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Ei-suora viiva!

ReLu:

def relu(x): palauttaa tf.maximum(0,x) plt.plot(relu(A))

Toinen ei-suora viiva!

Nyt olet nähnyt epälineaarisia aktivointifunktioita, ja nämä toimivat meille, malli ei voi oppia mitään epälineaarisesta tietojoukosta lineaarisilla aktivointifunktioilla! Jos olet oppinut tämän, on aika jakaa tietomme koulutus- ja testisarjoihin ja rakentaa vahvoja malleja.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2) ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, activation = 'relu'), #saamme korjata sen "tf.keras.activations.relu" myös tf.keras.layers.Dense(4 , aktivointi = 'relu'), tf.keras.layers.Dense(1, activation = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, Optimizer = tf.keras.optimizers.Adam( lr = 0.01), metriikka = ['tarkkuus']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

Arvioi malli

häviö, tarkkuus = malli_4.evaluate(X_test, y_test) print(f' Mallin menetys testisarjassa: {häviö}') print(f' Mallin tarkkuus testisarjassa: {100*tarkkuus}')

>> 7/7 [==============================] - 0 s 2 ms/askel - häviö: 0.1247 - tarkkuus: 1.0000 0.1246885135769844 Mallihäviö testisarjassa: 100.0 Mallin tarkkuus testisarjassa: XNUMX

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Juna") plot_decision_boundary(malli_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Testi") plot_decision_boundary(malli_4, X=X_testi, y=y_testi) plt.show()

Katsotaanpa lyhyesti, mistä tässä artikkelissa puhumme. Yhdessä tarkastelimme, kuinka lähestyä luokitustehtävää hermoverkossa TensorFlown avulla. Teimme 3 mallia ensimmäisellä mieleen tulevalla tavalla ja visualisoinnin avulla tajusimme missä olimme väärässä, tutkimme lineaarisuutta, epälineaarisuutta ja lopulta onnistuimme rakentamaan yleisen mallin. Yritin näyttää kaikilla näillä koodeilla ja seuraamillani vaiheilla, että mikään ei ole 100 prosenttia tarkkaa tai kiinteää, kaikki muuttuu edelleen joka päivä. Arvataksesi, minkä ongelman todennäköisesti kohtaat minkä tyyppisissä tiedoissa, ja nähdäksesi, mitkä yhdistelmät johtavat parempaan tulokseen, sinun tarvitsee vain kirjoittaa paljon enemmän koodia ja hankkia kokemusta.

Toivon, että artikkeli auttoi sinua ja antoi jotain apua.

Tässä artikkelissa näkyvät mediat eivät ole Analytics Vidhyan omistuksessa, ja niitä käytetään tekijän harkinnan mukaan

liittyvä

Lähde: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/