Neurale netværk er et vigtigt begreb inden for kunstig intelligens og maskinlæring. De består af indbyrdes forbundne noder, organiseret i lag og efterligner, hvordan den menneskelige hjerne fungerer. Noderne repræsenterer den menneskelige hjernes neuroner.
Du kan oprette dit eget simple feed-forward, multi-class klassifikation neurale netværk. Træn den til at klassificere håndskrevne cifre ved hjælp af MNIST-datasættet. Du kan derefter bruge computersyn til at klassificere dine egne håndskrevne cifre.
Hvad er multi-klasse klassificering?
Multi-class klassificering er en type maskinlæring, der kan klassificere data i mere end to kategorier. Neurale netværk bruger softmax-klassifikatoren til at fordele sandsynlighed over mulige klasser.
Du kan bruge multi-class klassificering til at klassificere håndskrevne billeder fra MNIST-datasættet i 10 kategorier. Disse kategorier svarer til cifrene 0 til 9.
Forståelse af MNIST-datasættet
MNIST-datasættet er et populært benchmark-datasæt til maskinlæring og computervisionsalgoritmer. Den indeholder 70.000 håndskrevne gråtonebilleder, som er 28 gange 28 pixels store. De håndskrevne cifre er i intervallet 0 til 9.
Før du bygger en maskinlæringsmodel, er det vigtigt at forstå, hvad dit datasæt indeholder. Forståelse af datasættet vil gøre dig i stand til at udføre bedre dataforbehandling.
Forbered dit miljø
For at følge denne vejledning skal du være bekendt med det grundlæggende i Python. Du skal også have en grundlæggende viden om maskinlæring. Endelig bør du være fortrolig med at bruge Jupyter Notebook eller Google Colab.
Den fulde kildekode er tilgængelig i en GitHub-depot.
Opret en ny Jupyter Notebook eller log ind på Google Colab. Kør denne kommando for at installere de nødvendige pakker:
!pip installer numpy matplotlib tensorflow opencv-python
Du vil bruge:
- Matplotlib til datavisualisering.
- NumPy til at manipulere arrays.
- TensorFlow til at skabe og træne din model.
- OpenCV for at fodre modellen med dine egne håndskrevne cifre.
Import af de nødvendige moduler
Importer de pakker, du har installeret i dit miljø. Dette giver dig mulighed for senere at ringe og bruge deres funktioner og moduler i din kode.
importere tensorflow som tf
fra tensorflow importere keras
importere matplotlib.pyplot som plt
%matplotlib inline
importere nusset som np
importere cv2Den anden kodelinje importerer Keras-modulet fra Google TensorFlow-bibliotek. Du vil bruge Keras til at træne dit dybe neurale netværk med TensorFlow som backend.
Indlæsning og visning af datasættet
MNIST-datasættet er indbygget i Keras. Indlæs MNIST-datasættet og opdel det i trænings- og testsæt. Du vil bruge træningssættet til at træne din model og testsættet til at evaluere nøjagtigheden af din model til at klassificere nye usete billeder.
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
Tjek længden af trænings- og testsættene. MNIST-datasættet har 60.000 billeder til træning og 10.000 billeder til test.
len (X_tog)
len (X_test)Tjek formen på det første billede i MNIST-datasættet, som skal være 28 gange 28 pixels. Udskriv derefter dens pixelværdier og visualiser den ved hjælp af Matplotlib.
X_train[0].form
X_train[0]
plt.matshow (X_train[0])
y_train[0]Visualiseringsoutput er som følger:
Det visualiserede billede viser, at det første billede i datasættet indeholder tallet fem.
Dataforbehandling
Før du bruger dataene i datasættet til at træne og teste din model, skal du forbehandle den. Forbehandling øger en models nøjagtighed ved at standardisere dataene.
Normalisering af pixelværdier
Normaliser pixelværdierne for billederne i datasættet ved at dividere hver værdi med 255. Pixelværdierne for det unormaliserede datasæt spænder fra 0 til 255, hvor nul er sort og 255 er hvidt. At dividere hver pixelværdi med 255 sikrer, at hver pixel er i området mellem 0 og 1. Dette gør det lettere for modellen at lære de relevante funktioner og mønstre i dataene.
X_tog = X_tog / 255
X_test = X_test / 255Udskriv derefter pixelværdierne for det første billede.
X_train[0]Bemærk, at de nu er i området mellem 0 og 1.
Konvertering af billedmatricer til et 1D-array
Det neurale netværks inputlag forventer generelt 1D-input, så opret en 1D-array af billedets pixelværdier. For at gøre det skal du bruge funktionen reshape() med antallet af raws indstillet til antallet af billeder i datasættet.
X_train_flattened = X_train.reshape (len (X_train), 28 * 28)
X_test_flattened = X_test.reshape (len (X_test), 28 * 28)
X_tog_fladet.form
X_train_fladet[0]
Dine billeder er nu klar til at træne og teste modellen.
Oprettelse af den dybe neurale netværksmodel
Opret en sekventiel model med Tensorflows Keras-modul ved hjælp af et inputlag, to skjulte lag og et outputlag. Indstil inputformen til 28 x 28, da dette er formen på de originale billeder i datasættet. Brug 128 noder til de skjulte lag. Outputlaget bør kun have 10 neuroner, da du kun klassificerer cifrene 0 til 9.
model = keras. Sekventiel([
keras.lag. Flatten (input_shape=(28, 28)),keras.lag. Tæt(128, aktivering='relu'),
keras.lag. Tæt(128, aktivering='relu'),
keras.lag. Tæt(10, aktivering='softmax')
])
Kompiler modellen ved hjælp af adam optimizer, sparse_categorical_crossentropy som tabsfunktionen og metrikken til at evaluere modellens ydeevne som nøjagtighed. Tilpas derefter træningsdataene i modellen og indstil antallet af epoker til fem.
model.compile (optimizer='adam',
tab ='sparse_categorical_crossentropy',
metrics=['nøjagtighed'])
model.fit (X_train, y_train, epoker=5)
Modellen vil tage et par minutter at træne. Når modeltræningen er afsluttet, skal du evaluere dens præstation på testsættet.
model.evaluate (X_test, y_test)
Evalueringsfunktionen vil returnere tabet og nøjagtigheden af modellen. Modellen giver en nøjagtighed på 98%.
Brug af modellen til at klassificere dine egne håndskrevne cifre
For at klassificere dine egne håndskrevne cifre skal du forberede dine billeder til at matche dem i MNIST-datasættet. Hvis du ikke gør det, vil det føre til, at din model klarer sig dårligt.
For at forbehandle billederne:
- Indlæs billedet, der indeholder cifferet, ved hjælp af OpenCV.
- Konverter den til gråtoner og tilpas den til 28 gange 28 pixels.
- Vend og normaliser pixelværdierne.
- Til sidst skal du flad billedet til et 1D-array.
Send det forbehandlede billede ind i modellen til forudsigelse og udskriv den forudsagte værdi 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# Flad billedet ud til et 1D-array
input_data = img_normalized.flatten().reshape( 1,28,28)
# Lav en forudsigelse ved hjælp af modellen
forudsigelse = model.forudsigelse (input_data)
Print (f'Forudsigelse: {np.argmax (forudsigelse)}')
Sende et forbehandlet billede indeholdende et nummer til modellen.
Modellens output er som følger:
Modellen var i stand til at klassificere tallet syv korrekt.
Neurale netværk i chatbots
Brugen af neurale netværk er eksploderet i de seneste par år. De er overvejende blevet brugt i naturlig sprogbehandling til sprogoversættelse og generativ AI.
På det seneste har der været en stigning i antallet af chatbots, der kan kommunikere på en menneskelignende måde. De bruger en type neuralt netværk kendt som et transformer-neuralt netværk. Interager med nogle af dem og oplev kraften i neurale netværk.