Neurala nätverk är ett viktigt begrepp inom områdena artificiell intelligens och maskininlärning. De består av sammankopplade noder, organiserade i lager, och efterliknar hur den mänskliga hjärnan fungerar. Noderna representerar den mänskliga hjärnans neuroner.
Du kan skapa ditt eget enkla neurala nätverk för klassificering i flera klasser med feed-forward. Träna den att klassificera handskrivna siffror med hjälp av MNIST-datauppsättningen. Du kan sedan använda datorseende för att klassificera dina egna handskrivna siffror.
Vad är flerklassklassificering?
Multi-class klassificering är en typ av maskininlärning som kan klassificera data i mer än två kategorier. Neurala nätverk använder softmax-klassificeraren för att fördela sannolikhet över möjliga klasser.
Du kan använda flerklassklassificering för att klassificera handskrivna bilder från MNIST-datauppsättningen i 10 kategorier. Dessa kategorier kommer att motsvara siffrorna 0 till 9.
Förstå MNIST-datauppsättningen
MNIST-datauppsättningen är en populär referensdatauppsättning för maskininlärning och datorseendealgoritmer. Den innehåller 70 000 gråskala handskrivna bilder som är 28 gånger 28 pixlar i storlek. De handskrivna siffrorna ligger i intervallet 0 till 9.
Innan du bygger någon maskininlärningsmodell är det viktigt att förstå vad din datauppsättning innehåller. Genom att förstå datauppsättningen kan du utföra bättre förbearbetning av data.
Förbered din miljö
För att följa denna handledning bör du vara bekant med grunderna i Python. Du bör också ha en grundläggande kunskaper om maskininlärning. Slutligen bör du vara bekväm med att använda Jupyter Notebook eller Google Colab.
Den fullständiga källkoden finns tillgänglig i en GitHub-förråd.
Skapa en ny Jupyter Notebook eller logga in på Google Colab. Kör det här kommandot för att installera de nödvändiga paketen:
!pip installera numpy matplotlib tensorflow opencv-python
Du kommer att använda:
- Matplotlib för datavisualisering.
- NumPy för att manipulera arrayer.
- TensorFlow för att skapa och träna din modell.
- OpenCV för att mata modellen med dina egna handskrivna siffror.
Importera de nödvändiga modulerna
Importera paketen du installerade i din miljö. Detta gör att du senare kan ringa och använda deras funktioner och moduler i din kod.
importera tensorflöde som tf
från tensorflöde importera keras
importera matplotlib.pyplot som plt
%matplotlib inline
importera numpy som np
importera cv2Den andra raden med kod importerar Keras-modulen från Google TensorFlow-bibliotek. Du kommer att använda Keras för att träna ditt djupa neurala nätverk med TensorFlow som backend.
Laddar och visar datauppsättningen
MNIST-datauppsättningen är inbyggd i Keras. Ladda MNIST-datauppsättningen och dela upp den i tränings- och testset. Du kommer att använda träningssetet för att träna din modell och testsetet för att utvärdera noggrannheten hos din modell vid klassificering av nya osynliga bilder.
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
Kontrollera längden på träningen och testseten. MNIST-datauppsättningen har 60 000 bilder för träning och 10 000 bilder för testning.
len (X_tåg)
len (X_test)Kontrollera formen på den första bilden i MNIST-datauppsättningen som ska vara 28 gånger 28 pixlar. Skriv sedan ut dess pixelvärden och visualisera det med Matplotlib.
X_train[0].form
X_train[0]
plt.matshow (X_train[0])
y_train[0]Visualiseringsutgången är som följer:
Den visualiserade bilden visar att den första bilden i datasetet innehåller siffran fem.
Dataförbehandling
Innan du använder data i datamängden för att träna och testa din modell måste du förbehandla den. Förbearbetning förbättrar en modells noggrannhet genom att standardisera data.
Normalisera pixelvärdena
Normalisera pixelvärdena för bilderna i datamängden genom att dividera varje värde med 255. Pixelvärdena för den onormaliserade datamängden sträcker sig från 0 till 255 där noll är svart och 255 är vit. Att dividera varje pixelvärde med 255 säkerställer att varje pixel ligger i intervallet mellan 0 och 1. Detta gör det lättare för modellen att lära sig relevanta egenskaper och mönster i data.
X_train = X_train / 255
X_test = X_test / 255Skriv sedan ut pixelvärdena för den första bilden.
X_train[0]Observera att de nu ligger i intervallet mellan 0 och 1.
Konvertera bildmatriserna till en 1D-array
Det neurala nätverkets indatalager förväntar sig i allmänhet 1D-ingångar, så skapa en 1D-array av bildens pixelvärden. För att göra det, använd funktionen reshape() med antalet raws inställt på antalet bilder i datamängden.
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_flatened[0]
Dina bilder är nu redo att träna och testa modellen.
Skapa den djupa neurala nätverksmodellen
Skapa en sekventiell modell med Tensorflows Keras-modul med ett indatalager, två dolda lager och ett utdatalager. Ställ in inmatningsformen till 28 gånger 28 eftersom detta är formen på originalbilderna i datamängden. Använd 128 noder för de dolda lagren. Utdatalagret bör endast ha 10 neuroner eftersom du bara klassificerar siffrorna 0 till 9.
modell = keras. Sekventiell([
keras.lager. Platta (input_shape=(28, 28)),keras.lager. Tät(128, aktivering='relu'),
keras.lager. Tät(128, aktivering='relu'),
keras.lager. Tät(10, aktivering='softmax')
])
Kompilera modellen med hjälp av Adam optimerare, sparse_categorical_crossentropy som förlustfunktion och måtten för att utvärdera modellens prestanda som noggrannhet. Passa sedan in träningsdata i modellen och ställ in antalet epoker till fem.
model.compile (optimizer='Adam',
förlust="sparse_categorical_crossentropy",
mätvärden=['noggrannhet'])
model.fit (X_train, y_train, epochs=5)
Modellen kommer att ta några minuter att träna. Efter att modellträningen har avslutats, utvärdera dess prestanda på testsetet.
model.evaluate (X_test, y_test)
Utvärderingsfunktionen kommer att returnera modellens förlust och noggrannhet. Modellen ger en noggrannhet på 98%.
Använda modellen för att klassificera dina egna handskrivna siffror
För att klassificera dina egna handskrivna siffror måste du förbereda dina bilder för att matcha dem i MNIST-datauppsättningen. Om du inte gör det kommer din modell att prestera dåligt.
Så här förbearbetar du bilderna:
- Ladda bilden som innehåller siffran med OpenCV.
- Konvertera den till gråskala och ändra storlek på den till 28 x 28 pixlar.
- Vänd och normalisera pixelvärdena.
- Slutligen plattar du ut bilden till en 1D-array.
Skicka den förbehandlade bilden till modellen för förutsägelse och skriv ut det förutsagda värdet på skärmen.
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# Platta ut bilden till en 1D-array
input_data = img_normalized.flatten().reshape( 1,28,28)
# Gör en förutsägelse med hjälp av modellen
prediction = model.predict (indata)
skriva ut (f'Prognos: {np.argmax (förutsägelse)}')
Skicka en förbehandlad bild som innehåller ett nummer till modellen.
Resultatet av modellen är som följer:
Modellen kunde klassificera siffran sju korrekt.
Neurala nätverk i chatbots
Användningen av neurala nätverk har exploderat under de senaste åren. De har främst använts i naturlig språkbehandling för språköversättning och generativ AI.
På senare tid har det skett en ökning av antalet chatbots som kan kommunicera på ett mänskligt sätt. De använder en typ av neurala nätverk som kallas ett transformatorneurala nätverk. Interagera med några av dem och upplev kraften i neurala nätverk.
