Neurale netwerken zijn een belangrijk concept op het gebied van kunstmatige intelligentie en machine learning. Ze bestaan uit onderling verbonden knooppunten, georganiseerd in lagen, en bootsen na hoe het menselijk brein werkt. De knooppunten vertegenwoordigen de neuronen van het menselijk brein.
U kunt uw eigen eenvoudige feed-forward, multi-class classificatie neuraal netwerk creëren. Train het om handgeschreven cijfers te classificeren met behulp van de MNIST-dataset. U kunt dan computervisie gebruiken om uw eigen handgeschreven cijfers te classificeren.
Wat is classificatie met meerdere klassen?
Classificatie met meerdere klassen is een type machine learning dat gegevens in meer dan twee categorieën kan classificeren. Neurale netwerken gebruiken de softmax-classificatie om waarschijnlijkheid over mogelijke klassen te verdelen.
U kunt classificatie met meerdere klassen gebruiken om handgeschreven afbeeldingen uit de MNIST-dataset in 10 categorieën te classificeren. Deze categorieën komen overeen met de cijfers 0 tot en met 9.
De MNIST-gegevensset begrijpen
De MNIST-dataset is een populaire benchmark-dataset voor machine learning en computer vision-algoritmen. Het bevat 70.000 handgeschreven afbeeldingen in grijstinten die 28 bij 28 pixels groot zijn. De handgeschreven cijfers liggen tussen 0 en 9.
Voordat u een machine learning-model bouwt, is het belangrijk om te begrijpen wat uw dataset bevat. Als u de dataset begrijpt, kunt u de gegevens beter voorbewerken.
Uw omgeving voorbereiden
Om deze tutorial te volgen, moet u bekend zijn met de basisprincipes van Python. Je moet ook een basiskennis van machine learning. Ten slotte zou u vertrouwd moeten zijn met het gebruik van Jupyter Notebook of Google Colab.
De volledige broncode is beschikbaar in een GitHub-opslagplaats.
Maak een nieuwe Jupyter Notebook of meld u aan bij Google Colab. Voer deze opdracht uit om de vereiste pakketten te installeren:
!pip installeer numpy matplotlib tensorflow opencv-python
Je gebruikt:
- Matplotlib voor datavisualisatie.
- NumPy om arrays te manipuleren.
- TensorFlow om uw model te maken en te trainen.
- OpenCV om het model te voeden met uw eigen handgeschreven cijfers.
De benodigde modules importeren
Importeer de pakketten die u in uw omgeving hebt geïnstalleerd. Hierdoor kunt u later hun functies en modules in uw code aanroepen en gebruiken.
importeren tensorstroom als tf
van tensorstroom importeren kera's
importeren matplotlib.pyplot als plt
%matplotlib inline
importeren onnozel als np
importeren cv2De tweede regel code importeert de Keras-module uit het Google TensorFlow-bibliotheek. Je gebruikt Keras om je diepe neurale netwerk te trainen met TensorFlow als backend.
Laden en bekijken van de dataset
De MNIST-dataset is ingebouwd in Keras. Laad de MNIST-gegevensset en splits deze op in trainings- en testsets. U gebruikt de trainingsset om uw model te trainen en de testset om de nauwkeurigheid van uw model te evalueren bij het classificeren van nieuwe ongeziene afbeeldingen.
(X_trein, y_trein), (X_test, y_test) = keras.datasets.mnist.load_data()
Controleer de lengte van de trainings- en testsets. De MNIST-dataset bevat 60.000 afbeeldingen voor training en 10.000 afbeeldingen voor testen.
len (X_trein)
lens (X_test)Controleer de vorm van de eerste afbeelding in de MNIST-dataset die 28 bij 28 pixels zou moeten zijn. Druk vervolgens de pixelwaarden af en visualiseer deze met Matplotlib.
X_trein[0].vorm
X_trein[0]
plt.matshow (X_train[0])
y_trein[0]De visualisatie-uitvoer is als volgt:
De gevisualiseerde afbeelding laat zien dat de eerste afbeelding in de dataset het getal vijf bevat.
Voorbewerking van gegevens
Voordat u de gegevens in de gegevensset gebruikt om uw model te trainen en te testen, moet u het vooraf verwerken. Preprocessing verbetert de nauwkeurigheid van een model door de gegevens te standaardiseren.
De pixelwaarden normaliseren
Normaliseer de pixelwaarden van de afbeeldingen in de dataset door elke waarde te delen door 255. De pixelwaarden van de niet-genormaliseerde dataset variëren van 0 tot 255, waarbij nul zwart is en 255 wit. Door elke pixelwaarde door 255 te delen, zorgt u ervoor dat elke pixel in het bereik tussen 0 en 1 ligt. Dit maakt het voor het model gemakkelijker om de relevante kenmerken en patronen in de gegevens te leren.
X_trein = X_trein / 255
X_test = X_test / 255Druk vervolgens de pixelwaarden van de eerste afbeelding af.
X_trein[0]Merk op dat ze nu in het bereik tussen 0 en 1 liggen.
De afbeeldingsmatrices omzetten in een 1D-array
De invoerlaag van het neurale netwerk verwacht over het algemeen 1D-invoer, dus maak een 1D-array van de pixelwaarden van de afbeelding. Gebruik hiervoor de functie reshape() waarbij het aantal raws is ingesteld op het aantal afbeeldingen in de dataset.
X_train_flattened = X_train.reshape (len (X_train), 28 * 28)
X_test_flattened = X_test.reshape (lens (X_test), 28 * 28)
X_train_flattened.shape
X_train_flattened[0]
Uw afbeeldingen zijn nu klaar om het model te trainen en te testen.
Het creëren van het diepe neurale netwerkmodel
Maak een sequentieel model met de Keras-module van Tensorflow met behulp van een invoerlaag, twee verborgen lagen en een uitvoerlaag. Stel de invoervorm in op 28 bij 28, aangezien dit de vorm is van de originele afbeeldingen in de dataset. Gebruik 128 nodes voor de verborgen lagen. De uitvoerlaag zou slechts 10 neuronen moeten hebben, aangezien u alleen de cijfers 0 tot en met 9 classificeert.
model = keras. Opeenvolgend([
keras.lagen. Afvlakken (input_shape=(28, 28)),keras.lagen. Gespannen(128, activering='relu'),
keras.lagen. Gespannen(128, activering='relu'),
keras.lagen. Gespannen(10, activering='softmax')
])
Stel het model samen met behulp van de Adam optimalisatie, sparse_categorical_crossentropy als de verliesfunctie en de maatstaf om de prestaties van het model te evalueren nauwkeurigheid. Pas vervolgens de trainingsgegevens in het model aan en stel het aantal tijdperken in op vijf.
model.compile (optimizer='Adam',
verlies='sparse_categorical_crossentropy',
statistieken=['nauwkeurigheid'])
model.fit (X_train, y_train, epochs=5)
Het model heeft een paar minuten nodig om te trainen. Nadat de modeltraining is voltooid, evalueert u de prestaties op de testset.
model.evaluate (X_test, y_test)
De evaluatiefunctie retourneert het verlies en de nauwkeurigheid van het model. Het model produceert een nauwkeurigheid van 98%.
Het model gebruiken om uw eigen handgeschreven cijfers te classificeren
Om uw eigen handgeschreven cijfers te classificeren, moet u uw afbeeldingen voorbereiden zodat ze overeenkomen met die van de MNIST-dataset. Als u dit niet doet, zal uw model slecht presteren.
De afbeeldingen voorbewerken:
- Laad de afbeelding met het cijfer met behulp van OpenCV.
- Converteer het naar grijstinten en verklein het naar 28 bij 28 pixels.
- Draai en normaliseer de pixelwaarden.
- Maak ten slotte de afbeelding plat tot een 1D-array.
Geef de voorbewerkte afbeelding door aan het model voor voorspelling en print de voorspelde waarde op het scherm.
img = cv2.imread('cijfers/cijfer1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.resize (img, (28, 28))
img_flip = cv2.bitwise_not (img_resize)
img_normalized = img_flip.astype('zweven32') / 255.0# Maak de afbeelding plat tot een 1D-array
input_data = img_normalized.flatten().reshape( 1,28,28)
# Maak een voorspelling met behulp van het model
voorspelling = model.predict (input_data)
afdrukken (f'Voorspelling: {np.argmax (voorspelling)}')
Een voorbewerkte afbeelding met een nummer doorgeven aan het model.
De uitvoer van het model is als volgt:
Het model was in staat om het cijfer zeven correct te classificeren.
Neurale netwerken in chatbots
Het gebruik van neurale netwerken is de afgelopen jaren explosief gestegen. Ze zijn voornamelijk gebruikt in natuurlijke taalverwerking voor taalvertaling en generatieve AI.
Meer recentelijk is er een toename van het aantal chatbots dat op een mensachtige manier kan communiceren. Ze gebruiken een type neuraal netwerk dat bekend staat als een neuraal netwerk van transformatoren. Communiceer met een aantal van hen en ervaar de kracht van neurale netwerken.
