Nevrale nettverk er et viktig begrep innen kunstig intelligens og maskinlæring. De består av sammenkoblede noder, organisert i lag, og etterligner hvordan den menneskelige hjernen fungerer. Nodene representerer den menneskelige hjernens nevroner.
Du kan lage ditt eget enkle nevrale nettverk for feed-forward, multi-class klassifisering. Tren den til å klassifisere håndskrevne sifre ved å bruke MNIST-datasettet. Du kan deretter bruke datasyn til å klassifisere dine egne håndskrevne sifre.
Hva er flerklasseklassifisering?
Multi-class klassifisering er en type maskinlæring som kan klassifisere data i mer enn to kategorier. Nevrale nettverk bruker softmax-klassifikatoren for å fordele sannsynlighet over mulige klasser.
Du kan bruke flerklasseklassifisering for å klassifisere håndskrevne bilder fra MNIST-datasettet i 10 kategorier. Disse kategoriene vil tilsvare sifrene 0 til 9.
Forstå MNIST-datasettet
MNIST-datasettet er et populært referansedatasett for maskinlæring og datasynsalgoritmer. Den inneholder 70 000 håndskrevne gråtonebilder som er 28 x 28 piksler i størrelse. De håndskrevne sifrene er i området 0 til 9.
Før du bygger en maskinlæringsmodell, er det viktig å forstå hva datasettet ditt inneholder. Å forstå datasettet vil gjøre deg i stand til å utføre bedre dataforbehandling.
Forberede miljøet ditt
For å følge denne opplæringen bør du være kjent med grunnleggende om Python. Du bør også ha en grunnleggende kunnskap om maskinlæring. Til slutt bør du være komfortabel med å bruke Jupyter Notebook eller Google Colab.
Den fullstendige kildekoden er tilgjengelig i en GitHub-depot.
Opprett en ny Jupyter Notebook eller logg på Google Colab. Kjør denne kommandoen for å installere de nødvendige pakkene:
!pip installer numpy matplotlib tensorflow opencv-python
Du vil bruke:
- Matplotlib for datavisualisering.
- NumPy for å manipulere matriser.
- TensorFlow for å lage og trene modellen din.
- OpenCV for å mate modellen med dine egne håndskrevne sifre.
Importere de nødvendige modulene
Importer pakkene du installerte i miljøet ditt. Dette vil tillate deg å ringe og bruke deres funksjoner og moduler i koden din senere.
import tensorflyt som tf
fra tensorflyt import keras
import matplotlib.pyplot som plt
%matplotlib inline
import nusset som np
import cv2Den andre linjen med kode importerer Keras-modulen fra Google TensorFlow-bibliotek. Du vil bruke Keras til å trene ditt dype nevrale nettverk med TensorFlow som backend.
Laster og viser datasettet
MNIST-datasettet er innebygd i Keras. Last inn MNIST-datasettet og del det opp i trenings- og testsett. Du vil bruke treningssettet til å trene modellen din og testsettet til å evaluere nøyaktigheten til modellen din i klassifisering av nye usette bilder.
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
Sjekk lengden på treningen og testsettene. MNIST-datasettet har 60 000 bilder for trening og 10 000 bilder for testing.
len (X_train)
len (X_test)Sjekk formen på det første bildet i MNIST-datasettet som skal være 28 x 28 piksler. Skriv deretter ut pikselverdiene og visualiser den ved hjelp av Matplotlib.
X_train[0].form
X_train[0]
plt.matshow (X_train[0])
y_train[0]Visualiseringsutgangen er som følger:
Det visualiserte bildet viser at det første bildet i datasettet inneholder tallet fem.
Dataforbehandling
Før du bruker dataene i datasettet til å trene og teste modellen din, må du forhåndsbehandle den. Forbehandling forbedrer en modells nøyaktighet ved å standardisere dataene.
Normalisering av pikselverdier
Normaliser pikselverdiene til bildene i datasettet ved å dele hver verdi med 255. Pikselverdiene til det unormaliserte datasettet varierer fra 0 til 255, hvor null er svart og 255 er hvitt. Å dele hver pikselverdi med 255 sikrer at hver piksel er i området mellom 0 og 1. Dette gjør det lettere for modellen å lære de relevante funksjonene og mønstrene i dataene.
X_train = X_train / 255
X_test = X_test / 255Skriv deretter ut pikselverdiene til det første bildet.
X_train[0]Legg merke til at de nå er i området mellom 0 og 1.
Konvertering av bildematrisene til en 1D-matrise
Det nevrale nettverkets inputlag forventer generelt 1D-innganger, så lag en 1D-array av bildets pikselverdier. For å gjøre det, bruk reshape()-funksjonen med antall raws satt til antall bilder i datasettet.
X_train_flattened = X_train.reshape (len (X_train), 28 * 28)
X_test_flattened = X_test.reshape (len (X_test), 28 * 28)
X_train_flatened.shape
X_train_flatet[0]
Bildene dine er nå klare til å trene og teste modellen.
Opprette den dype nevrale nettverksmodellen
Lag en sekvensiell modell med Tensorflows Keras-modul ved å bruke et inputlag, to skjulte lag og et utgangslag. Sett inngangsformen til 28 x 28, da dette er formen til de originale bildene i datasettet. Bruk 128 noder for de skjulte lagene. Utgangslaget skal kun ha 10 nevroner, siden du kun klassifiserer sifrene 0 til 9.
modell = keras. Sekvensiell([
keras.lag. Flatten (input_shape=(28, 28)),keras.lag. Tett(128, aktivering='relu'),
keras.lag. Tett(128, aktivering='relu'),
keras.lag. Tett(10, aktivering='softmax')
])
Kompiler modellen ved å bruke adam optimizer, sparse_categorical_crossentropy som tapsfunksjon, og metrikken for å evaluere ytelsen til modellen som nøyaktighet. Pass deretter treningsdataene inn i modellen og sett antall epoker til fem.
model.compile (optimizer='adam',
tap='sparse_categorical_crossentropy',
metrics=['nøyaktighet'])
model.fit (X_train, y_train, epoker=5)
Modellen vil ta noen minutter å trene. Etter at modelltreningen er fullført, evaluer ytelsen på testsettet.
model.evaluate (X_test, y_test)
Evalueringsfunksjonen vil returnere tapet og nøyaktigheten til modellen. Modellen gir en nøyaktighet på 98 %.
Bruke modellen til å klassifisere dine egne håndskrevne sifre
For å klassifisere dine egne håndskrevne sifre, må du forberede bildene dine slik at de samsvarer med MNIST-datasettet. Unnlatelse av å gjøre det vil føre til at modellen din gir dårlige resultater.
For å forhåndsbehandle bildene:
- Last inn bildet som inneholder sifferet ved hjelp av OpenCV.
- Konverter den til gråtoner og endre størrelsen på den til 28 x 28 piksler.
- Vend og normaliser pikselverdiene.
- Til slutt flater du bildet til en 1D-matrise.
Send det forhåndsbehandlede bildet inn i modellen for prediksjon og skriv ut den forutsagte verdien på skjermen.
img = cv2.imread('digits/digit1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.resize (img, (28, 28))
img_flip = cv2.bitwise_not (img_resize)
img_normalized = img_flip.astype('float32') / 255.0# Flat bildet til en 1D-matrise
input_data = img_normalized.flatten().reshape( 1,28,28)
# Gjør en forutsigelse ved å bruke modellen
prediksjon = model.predict (input_data)
skrive ut (f'Prediksjon: {np.argmax (prediksjon)}')
Sende et forhåndsbehandlet bilde som inneholder et nummer til modellen.
Utgangen til modellen er som følger:
Modellen var i stand til å klassifisere sifferet syv riktig.
Nevrale nettverk i Chatbots
Bruken av nevrale nettverk har eksplodert de siste årene. De har hovedsakelig blitt brukt i naturlig språkbehandling for språkoversettelse og generativ AI.
Nylig har det vært en økning i antall chatbots som kan kommunisere på en menneskelignende måte. De bruker en type nevrale nettverk kjent som et transformatornevralt nettverk. Samhandle med noen av dem og opplev kraften i nevrale nettverk.