Neuralt netværk til klassificering med Tensorflow

Denne artikel blev offentliggjort som en del af Data Science Blogathon

I denne artikel skal jeg bygge neurale netværksmodeller med TensorFlow for at løse et klassifikationsproblem. Lad os sammen undersøge, hvordan vi kan gribe et klassifikationsproblem an i Tensorflow. Men først vil jeg gerne sikre mig, at vi er i stand til at besvare disse spørgsmål:

er neuralt netværk?

Hovedformålet med et neuralt netværk er at forsøge at finde sammenhængen mellem funktioner i et datasæt., og det består af et sæt algoritmer, der efterligner den menneskelige hjernes arbejde. Et "neuron" i et neuralt netværk er en matematisk funktion, der indsamler og klassificerer information i henhold til en bestemt arkitektur.

Hvad er klassificering?

Klassifikationsproblem involverer at forudsige, om noget tilhører én klasse eller ej. Med andre ord, mens vi gør det, prøver vi at se, at noget er det ene eller det andet.

Typer af klassifikation

• Antag, at du vil forudsige, om en person har diabetes eller ej. Hvis du står over for denne slags situation, er der to muligheder, ikke? Det hedder det Binær klassifikation.
• Antag, at du vil identificere, om et billede er af et stykke legetøj, en person eller en kat, ikke? dette kaldes Multi-klasse klassifikation fordi der er mere end to muligheder.
• Antag, at du vil bestemme, hvilke kategorier der skal tildeles en artikel. I så fald kaldes det Multi-label klassificering, fordi én artikel kunne have mere end én kategori tildelt. Lad os tage vores forklaring gennem denne artikel. Vi kan tildele kategorier som "Deep Learning, TensorFlow, Classification" osv. til denne artikel

Nu kan vi komme videre, fordi vi har en fælles forståelse af det problem, vi skal arbejde på. Så det er tid til kodning. Jeg håber, du skriver dem ned med mig, fordi den eneste måde at blive bedre på, lave færre fejl, er at skrive mere kode.

Vi begynder med at importere biblioteker, som vi vil bruge:

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

Oprettelse af et datasæt

Det er på tide at lave et datasæt at arbejde på:

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 -0.96382443 XNUMX] [ XNUMX XNUMX]]

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

Okay, vi har set vores datasæt mere detaljeret, men vi ved stadig ikke noget om det, vel? Derfor er et vigtigt skridt her at blive ét med dataene, og visualisering er den bedste måde at gøre dette på.

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

Her opstår et spørgsmål, hvilken slags etiketter har vi at gøre med?

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

Det ser ud til, at vi har at gøre med et binært klassifikationsproblem, fordi vi har 2 etiketter (0 og 1).

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

Som jeg nævnte ovenfor, er den bedste måde at få en med dataene på visualisering. Nu siger plot selv, at hvilken slags model skal vi bygge. Vi vil bygge en model, som er i stand til at skelne blå prikker fra røde prikker.

Før vi bygger en neural netværksmodel, skal vi kontrollere formerne på vores input- og outputfunktioner. de skal være ens!

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

Vi har den samme mængde værdier for hver funktion, men formen på X er forskellig? Hvorfor? Lad os tjekke det ud.

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

Okay, vi har 2 X-funktioner i 1 år. Så vi kan komme videre uden problemer.

Trin i modellering af neuralt netværk til klassificering med Tensorflow

I TensorFlow er der faste stadier til at skabe en model:

• Oprettelse af en model – sammensæt lagene i et neuralt netværk ved hjælp af den funktionelle eller sekventielle API
• Kompilering af en model – at definere, hvordan en models ydeevne skal måles, og hvordan den skal forbedres (tabsfunktion og optimering)
• Tilpasning af en tilstandl – lade en model finde mønstre i dataene

Vi vil bruge Sequential API. Så lad os 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/trin - tab: 2.8544 - nøjagtighed: 0.4600 Epoke 2/5 32/32 [==========================================] - 0s 2ms/trin - tab : 0.7131 - nøjagtighed: 0.5430 Epoke 3/5 32/32 [================================] - 0s 2ms/trin - tab: 0.6973 - nøjagtighed: 0.5090 Epoke 4/5 32/32 [===============================] - 0s 2ms /trin - tab: 0.6950 - nøjagtighed: 0.5010 Epoke 5/5 32/32 [=========================================== 0s 1ms/trin - tab: 0.6942 - nøjagtighed: 0.4830

Modellens nøjagtighed er cirka 50%, hvilket dybest set betyder, at modellen bare gætter, lad os prøve at træne den længere

model_1.fit(X, y, epoker = 200, verbose = 0) #vi sætter verbose = 0 for at fjerne træningsproceduren ) model_1.evaluate(X, y)

>> 32/32 [===============================] - 0s 1ms/trin - tab: 0.6935 - nøjagtighed: 0.5000 [0.6934829950332642, 0.5]

Selv efter 200 epoker fungerer den stadig, som om den gætter. Næste trin er at tilføje flere lag og træne i længere tid.

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 = ['accuracy']) model_2.fit(X, y, epoker = 100, verbose = 0)

 model_2.evaluate(X,y)

>> 32/32 [===============================] - 0s 1ms/trin - tab: 0.6933 - nøjagtighed: 0.5000 [0.6933314800262451, 0.5]

Alligevel er der ikke engang en lille forandring, det ser ud til, at der er noget galt.

Forbedring af Neural Network For Classification-modellen med Tensorflow

Der er forskellige måder at forbedre en model på på forskellige stadier:

• Oprettelse af en model – tilføje flere lag, øge antallet af skjulte enheder (neuroner), ændre aktiveringsfunktionerne for hvert lag
• Kompilering af en model – prøv forskellige optimeringsfunktioner, for eksempel brug Adam() i stedet for SGD().
• Montering af en model – vi kunne øge antallet af epoker

Lad os prøve at tilføje flere neuroner og prøv Adam optimering

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # tilføj 100 tætte neuroner tf.keras.layers.Dense(10), # tilføj endnu et lag med 10 neuroner tf.keras.layers.Dense (1) ]) model_3.compile(tab=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, epoker =100, verbose=0)

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

Det bliver stadig ikke bedre! Lad os visualisere dataene for at se, hvad der går galt.

Visualiser Neural Network-modellen

For at visualisere vores models forudsigelser vil vi oprette en funktion plot_decision_boundary(), som:

• Indtager en trænet model, funktioner og etiketter
• Opret et meshgrid af de forskellige X-værdier.
• Foretager forudsigelser på tværs af meshgrid.
• Tegner forudsigelserne med linje.

Bemærk:  Denne funktion er blevet tilpasset fra to ressourcer:

CS231n Lavet med ML basics 

def plot_decision_boundary(model, X, y): # Definer plottets aksegrænser og opret et maskegitter 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)) # Opret X-værdier (vi skal forudsige på alle disse) x_in = np.c_[xx.ravel(), yy.ravel()] # Lav forudsigelser ved hjælp af den trænede model y_pred = model.predict(x_in) # Check for multi-class

 if len(y_pred[0]) > 1: print("gør multiklasseklassifikation...") # Vi skal omforme vores forudsigelser for at gøre dem klar til at plotte y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("gør binær klassifikation...") y_pred = np.round(y_pred).reshape(xx.shape) # Plotbeslutningsgrænse 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(model_3, X, y)

Her er det! Igen viser visualisering os, hvad der er galt, og hvad vi skal gøre? Vores model forsøger at tegne en ret linje gennem dataene, men vores data kan ikke adskilles med en ret linje. Er der noget, der går glip af vores klassificeringsproblem? Hvad er det?

Dette er ikke-linearitet! Vi har brug for nogle ikke-lineære linjer. Du kan blive forvirret nu, hvis du tænker, at du ikke så den slags funktion før, tager du fejl, for det har du. Lad os se dem visuelt. Visualisering fungerer altid bedre!

Der er nogle aktiveringsfunktioner i Neural Network, som vi kan bruge, f.eks ReLu, Sigmoid. Lad os skabe lidt legetøjs tensor og tjek disse funktioner på den.

Aktiveringsfunktioner for neurale netværk

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)

Lad os se, hvordan vores legetøjstensor ser ud?

plt.plot(A)

Det ser sådan ud, en lige linje! 

Lad os nu genskabe aktiveringsfunktioner for at se, hvad de gør ved vores tensor?

Sigmoid:

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

En ikke-lige linje!

ReLu:

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

Endnu en ikke-lige linje!

Nu har du set ikke-lineære aktiveringsfunktioner, og det er disse, der vil fungere for os, modellen kan ikke lære noget på et ikke-lineært datasæt med lineære aktiveringsfunktioner! Hvis du har lært dette, er det tid til at opdele vores data i trænings- og testsæt og opbygge stærke 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 også rette det "tf.keras.activations.relu" 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), metrics = ['nøjagtighed']) model_4.fit(X_train, y_train, epoker = 25, verbose = 0)

Vurder modellen

tab, nøjagtighed = model_4.evaluate(X_test, y_test) print(f' Modeltab på testsættet: {tab}') print(f' Modelnøjagtighed på testsættet: {100*accuracy}')

>> 7/7 [===============================] - 0s 2ms/trin - tab: 0.1247 - nøjagtighed: 1.0000 Modeltab på testsættet: 0.1246885135769844 Modelnøjagtighed på testsættet: 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()

Lad os tage et kort kig på, hvad vi taler om i denne artikel. Sammen så vi på, hvordan man griber en klassifikationsopgave an i det neurale netværk med TensorFlow. Vi skabte 3 modeller på den første måde, der kom til at tænke på, og ved hjælp af visualisering indså vi, hvor vi tog fejl, vi udforskede linearitet, ikke-linearitet, og til sidst lykkedes det os at bygge en generaliseret model. Det, jeg prøvede at vise med alle disse koder og de trin, jeg fulgte, var, at intet er 100 procent nøjagtigt eller fast, alt fortsætter med at ændre sig hver dag. For at gætte, hvilket problem du sandsynligvis vil stå over for i hvilken slags data, og for at se hvilke kombinationer der fører til et bedre resultat, skal du bare skrive meget mere kode og få erfaring.

Jeg håber, at artiklen var lidt nyttig for dig og gav nogle bidrag.

Medierne vist i denne artikel ejes ikke af Analytics Vidhya og bruges efter forfatterens skøn

Relaterede

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