Nevralt nettverk for klassifisering med Tensorflow

Denne artikkelen ble publisert som en del av Data Science Blogathon

I denne artikkelen skal jeg bygge nevrale nettverksmodeller med TensorFlow for å løse et klassifiseringsproblem. La oss sammen utforske hvordan vi kan nærme oss et klassifiseringsproblem i Tensorflow. Men først vil jeg forsikre meg om at vi er i stand til å svare på disse spørsmålene:

er Neural Network?

Hovedformålet med et nevralt nettverk er å prøve å finne forholdet mellom funksjoner i et datasett., og det består av et sett med algoritmer som etterligner arbeidet til den menneskelige hjernen. Et "nevron" i et nevralt nettverk er en matematisk funksjon som samler inn og klassifiserer informasjon i henhold til en bestemt arkitektur.

Hva er klassifisering?

Klassifikasjonsproblem innebærer å forutsi om noe tilhører en klasse eller ikke. Med andre ord, mens vi gjør det prøver vi å se at noe er det ene eller det andre.

Typer av klassifisering

• Anta at du vil forutsi om en person har diabetes eller ikke. Hvis du står overfor en slik situasjon, er det to muligheter, ikke sant? Det heter Binær klassifisering.
• Anta at du vil identifisere om et bilde er av et leketøy, en person eller en katt, ikke sant? dette kalles Klassifisering i flere klasser fordi det er mer enn to alternativer.
• Anta at du vil bestemme hvilke kategorier som skal tilordnes en artikkel. I så fall heter det Multi-label klassifisering, fordi én artikkel kan ha mer enn én kategori tilordnet. La oss ta vår forklaring gjennom denne artikkelen. Vi kan tilordne kategorier som "Deep Learning, TensorFlow, Classification" osv. til denne artikkelen

Nå kan vi gå videre fordi vi har en felles forståelse av problemet vi skal jobbe med. Så det er på tide med koding. Jeg håper du skriver dem ned med meg fordi den eneste måten å bli bedre på, gjøre færre feil er å skrive mer kode.

Vi begynner med å importere biblioteker som vi skal bruke:

importer numpy som np importer pandaer som pd importer matplotlib.pyplot som plt importer tensorflow som tf print(tf.__version__)

Opprette et datasett

Det er på tide å lage et datasett å jobbe med:

fra sklearn.datasets importer make_circles samples = 1000 X, y = make_circles(samples, noise = 0.03, random_state = 42)

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

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

Ok, vi har sett datasettet vårt mer detaljert, men vi vet fortsatt ikke noe om det, ikke sant? Derfor er et viktig skritt her å bli ett med dataene, og visualisering er den beste måten å gjøre dette på.

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

Her oppstår ett spørsmål, hva slags merkelapper har vi å gjøre med?

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

Ser ut som vi har å gjøre med et binært klassifiseringsproblem, fordi vi har 2 etiketter (0 og 1).

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

Som jeg nevnte ovenfor, er visualisering den beste måten å få en med dataene på. Nå sier tomten seg selv at hva slags modell vi må bygge. Vi skal bygge en modell som er i stand til å skille blå prikker fra røde prikker.

Før vi bygger noen nevrale nettverksmodeller, må vi sjekke formene til inngangs- og utgangsfunksjonene våre. de må være like!

print(X.shape, y.shape) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Vi har samme mengde verdier for hver funksjon, men formen på X er forskjellig? Hvorfor? La oss sjekke det ut.

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

Ok, vi har 2 X-funksjoner i 1 år. Så vi kan gå videre uten problemer.

Trinn i modellering av nevralt nettverk for klassifisering med Tensorflow

I TensorFlow er det faste stadier for å lage en modell:

• Lage en modell – sett sammen lagene i et nevralt nettverk ved hjelp av funksjonell eller sekvensiell API
• Kompilere en modell – definere hvordan en modells ytelse skal måles, og hvordan den skal forbedres (tapfunksjon og optimizer)
• Tilpasse en modusl – la en modell finne mønstre i dataene

Vi vil bruke Sequential API. Så la oss komme i gang

tf.random.set_seed(42)

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

 optimizer = tf.keras.optimizers.SGD(), #SGD står for Stokastisk Gradient Descent metrics = ['accuracy']) model_1.fit(X, y, epoker = 5)

>> Epoke 1/5 32/32 [=========================================] - 1s 1ms/trinn - tap: 2.8544 - nøyaktighet: 0.4600 Epoke 2/5 32/32 [==========================================] - 0s 2ms/trinn - tap : 0.7131 - nøyaktighet: 0.5430 Epoke 3/5 32/32 [========================================] - 0s 2ms/steg - tap: 0.6973 - nøyaktighet: 0.5090 Epoke 4/5 32/32 [========================================] - 0s 2ms /trinn - tap: 0.6950 - nøyaktighet: 0.5010 Epoke 5/5 32/32 [=========================================== 0s 1ms/trinn - tap: 0.6942 - nøyaktighet: 0.4830

Modellens nøyaktighet er omtrent 50%, noe som betyr at modellen bare gjetter, la oss prøve å trene den lenger

model_1.fit(X, y, epoker = 200, verbose = 0) #vi setter verbose = 0 for å fjerne opplæringsprosedyren ) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/trinn - tap: 0.6935 - nøyaktighet: 0.5000 [0.6934829950332642, 0.5]

Selv etter 200 epoker, fungerer den fortsatt som den gjetter. Neste trinn er å legge til flere lag og trene lenger.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer = tf.keras.optimizers.SGD(), metrics = ['nøyaktighet']) model_2.fit(X, y, epoker = 100, verbose = 0)

 model_2.evaluate(X,y)

>> 32/32 [==============================] - 0s 1ms/trinn - tap: 0.6933 - nøyaktighet: 0.5000 [0.6933314800262451, 0.5]

Likevel er det ikke engang en liten endring, det virker som om noe er galt.

Forbedring av det nevrale nettverket for klassifiseringsmodellen med Tensorflow

Det er forskjellige måter å forbedre en modell på på forskjellige stadier:

• Lage en modell – legg til flere lag, øk antall skjulte enheter (nevroner), endre aktiveringsfunksjonene til hvert lag
• Kompilere en modell – prøv forskjellige optimaliseringsfunksjoner, for eksempel bruk Adam() i stedet for SGD().
• Montering av en modell – vi kunne øke antallet epoker

La oss prøve å legge til flere nevroner og prøv Adam optimizer

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # legg til 100 tette nevroner tf.keras.layers.Dense(10), # legg til et nytt lag med 10 nevroner tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, epoker =100, detaljert=0)

model_3.evaluate(X,y) >> 32/32 [===============================] - 0s 1ms/step - tap: 0.6980 - nøyaktighet: 0.5080 [0.6980254650115967, 0.5080000162124634]

Blir fortsatt ikke bedre! La oss visualisere dataene for å se hva som går galt.

Visualiser den nevrale nettverksmodellen

For å visualisere modellens spådommer skal vi lage en funksjon plot_decision_boundary() som:

• Tar inn en opplært modell, funksjoner og etiketter
• Lag et meshgrid av de forskjellige X-verdiene.
• Gir spådommer på tvers av meshgrid.
• Tegner spådommene med linje.

OBS:  Denne funksjonen er tilpasset fra to ressurser:

CS231n Laget med grunnleggende ML 

def plot_decision_boundary(modell, X, y): # Definer aksegrensene til plottet og lag et maskenett 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)) # Lag X-verdier (vi skal forutsi alle disse) x_in = np.c_[xx.ravel(), yy.ravel()] # Lag spådommer ved å bruke de trente modell y_pred = model.predict(x_in) # Se etter multi-class

 if len(y_pred[0]) > 1: print("gjør flerklasseklassifisering...") # Vi må omforme spådommene våre for å gjøre dem klare til å plotte y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("gjør binær klassifisering...") y_pred = np.round(y_pred).reshape(xx.shape) # Plott beslutningsgrense 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(modell_3, X, y)

Her er det! Igjen viser visualisering oss hva som er galt og hva vi skal gjøre? Vår modell prøver å tegne en rett linje gjennom dataene, men dataene våre kan ikke separeres med en rett linje. Er det noe som går glipp av klassifiseringsproblemet vårt? Hva det er?

Dette er ikke-linearitet! Vi trenger noen ikke-lineære linjer. Du kan bli forvirret nå, hvis du tenker at du ikke så den slags funksjon før, tar du feil, for det har du. La oss se dem visuelt. Visualisering fungerer alltid bedre!

Det er noen aktiveringsfunksjoner i Neural Network som vi kan bruke, for eksempel ReLu, Sigmoid. La oss lage litt leketøy tensor og sjekk disse funksjonene på den.

Aktiveringsfunksjoner for nevrale nettverk

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.], form=(24,), dtype=float32)

La oss se hvordan leketøytensoren vår ser ut?

plt.plot(A)

Det ser slik ut, en rett linje! 

La oss nå gjenskape aktiveringsfunksjoner for å se hva de gjør med tensoren vår?

Sigmoid:

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

En ikke-rett linje!

ReLu:

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

Nok en ikke-rett linje!

Nå har du sett ikke-lineære aktiveringsfunksjoner, og det er disse som vil fungere for oss, modellen kan ikke lære noe på et ikke-lineært datasett med lineære aktiveringsfunksjoner! Hvis du har lært dette, er det på tide å dele opp dataene våre i trenings- og testsett og bygge sterke modeller.

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'), #vi kan rette det "tf.keras.activations.relu" også tf.keras.layers.Dense(4 , activation = '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), metrikk = ['nøyaktighet']) model_4.fit(X_train, y_train, epoker = 25, verbose = 0)

Evaluer modellen

tap, nøyaktighet = model_4.evaluate(X_test, y_test) print(f' Modelltap på testsettet: {loss}') print(f' Modellnøyaktighet på testsettet: {100*accuracy}')

>> 7/7 [===============================] - 0s 2ms/trinn - tap: 0.1247 - nøyaktighet: 1.0000 Modelltap på testsettet: 0.1246885135769844 Modellnøyaktighet på testsettet: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Train") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

La oss ta en kort titt på hva vi snakker om i denne artikkelen. Sammen så vi på hvordan vi kan tilnærme oss en klassifiseringsoppgave i Neural Network med TensorFlow. Vi laget 3 modeller på den første måten som kom til tankene, og ved hjelp av visualisering innså vi hvor vi tok feil, vi utforsket linearitet, ikke-linearitet, og til slutt klarte vi å bygge en generalisert modell. Det jeg prøvde å vise med alle disse kodene og trinnene jeg fulgte var at ingenting er 100 prosent nøyaktig eller fast, alt fortsetter å endre seg hver dag. For å gjette hvilket problem du sannsynligvis vil møte i hvilken type data og for å se hvilke kombinasjoner som fører til et bedre resultat, er alt du trenger å skrive mye mer kode og få erfaring.

Jeg håper artikkelen var litt nyttig for deg og ga noen bidrag.

Mediene vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn

I slekt

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